id
int64 0
458k
| file_name
stringlengths 4
119
| file_path
stringlengths 14
227
| content
stringlengths 24
9.96M
| size
int64 24
9.96M
| language
stringclasses 1
value | extension
stringclasses 14
values | total_lines
int64 1
219k
| avg_line_length
float64 2.52
4.63M
| max_line_length
int64 5
9.91M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 7
101
| repo_stars
int64 100
139k
| repo_forks
int64 0
26.4k
| repo_open_issues
int64 0
2.27k
| repo_license
stringclasses 12
values | repo_extraction_date
stringclasses 433
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
15,400
|
adapter.py
|
translate_pootle/pootle/apps/accounts/adapter.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import logging
from django.conf import settings
from django.http import JsonResponse
from allauth.account.adapter import DefaultAccountAdapter
from pootle.i18n.gettext import ugettext_lazy as _
logger = logging.getLogger('action')
class PootleAccountAdapter(DefaultAccountAdapter):
"""Reimplementation of DefaultAccountAdapter from allauth to change
ajax_response and username validation.
Differences:
- the html key is removed for performance reasons
- form_errors is renamed to errors
- Latin1 usernames are allowed
"""
def ajax_response(self, request, response, form=None, data=None,
redirect_to=None):
if data is None:
data = {}
if redirect_to:
status = 200
data["location"] = redirect_to
if form:
if form.is_valid():
status = 200
else:
status = 400
data["errors"] = form._errors
return JsonResponse(data, status=status)
def is_open_for_signup(self, request):
"""Controls whether signups are enabled on the site.
This can be changed by setting `POOTLE_SIGNUP_ENABLED = False` in
the settings. Defaults to `True`.
"""
return getattr(settings, 'POOTLE_SIGNUP_ENABLED', True)
def add_message(self, request, level, message_template, *args, **kwargs):
"""Silence messages altogether."""
pass
def send_confirmation_mail(self, *args, **kwargs):
try:
super(PootleAccountAdapter, self).send_confirmation_mail(*args,
**kwargs)
except Exception:
logger.exception("ERROR: Sign up failed. Couldn't sent "
"confirmation email.")
raise RuntimeError(_('Some problem happened when tried to send '
'the confirmation email. Please try again '
'later.'))
| 2,314
|
Python
|
.py
| 54
| 32.592593
| 78
| 0.619875
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,401
|
social_adapter.py
|
translate_pootle/pootle/apps/accounts/social_adapter.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import traceback
from django.shortcuts import render
from allauth.exceptions import ImmediateHttpResponse
from allauth.socialaccount import providers
from allauth.socialaccount.adapter import DefaultSocialAccountAdapter
from pootle.middleware.errorpages import log_exception
from .utils import get_user_by_email
from .views import SocialVerificationView
class PootleSocialAccountAdapter(DefaultSocialAccountAdapter):
def is_open_for_signup(self, request, sociallogin):
"""Controls whether signups are enabled on the site when using
social authentication methods.
"""
# Allauth's default behavior is to disallow creating *any* users if the
# account adapter forbids so. In Pootle's case, the adapter's
# `is_open_for_signup()` is controlled by
# `settings.POOTLE_SIGNUP_ENABLED`, and we want to apply its semantics
# only to regular user accounts, not social accounts. So social
# accounts can sign up for new user accounts anytime. If this is
# considered to be problematic in the future, we might want to
# introduce a new setting to control this, separate from
# `POOTLE_SIGNUP_ENABLED`.
return True
def pre_social_login(self, request, sociallogin):
"""Hook to be run after receiving the OK from the social provider
but before completing the social login process. At this time no
new user accounts have been created and the user is still in the
process of signing in. The provider has also pre-filled the user
data in `sociallogin.user`.
We'll use this hook to customize Allauth's default behavior so
that sociallogin users reporting an email address that already
exists in the system will need to verify they actually own the
user account owning such email in Pootle.
"""
email_address = sociallogin.user.email
# There's a SocialAccount already for this login or the provider
# doesn't share an email address: nothing to do here
if sociallogin.user.pk is not None or not email_address:
return
# If there's already an existing email address on the system, we'll ask
# for its connected user's password before proceeding.
user = get_user_by_email(email_address)
if user is not None:
# Save `SocialLogin` instance for our custom view
request.session['sociallogin'] = sociallogin.serialize()
raise ImmediateHttpResponse(
response=SocialVerificationView.as_view()(request)
)
def authentication_error(self, request, provider_id, error=None,
exception=None, extra_context=None):
provider = providers.registry.by_id(provider_id)
retry_url = provider.get_login_url(request,
**dict(request.GET.iteritems()))
tb = traceback.format_exc()
log_exception(request, exception, tb)
ctx = {
'social_error': {
'error': error,
'exception': {
'name': exception.__class__.__name__,
'msg': unicode(exception),
},
'provider': provider.name,
'retry_url': retry_url,
},
}
raise ImmediateHttpResponse(
response=render(request, 'account/social_error.html', ctx)
)
| 3,758
|
Python
|
.py
| 76
| 39.973684
| 79
| 0.664484
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,402
|
forms.py
|
translate_pootle/pootle/apps/accounts/forms.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import logging
from django import forms
from allauth.account import app_settings
from allauth.account.app_settings import AuthenticationMethod
from allauth.account.forms import LoginForm
from pootle.i18n.gettext import ugettext_lazy as _
from .utils import get_user_by_email
logger = logging.getLogger(__name__)
class SignInForm(LoginForm):
def login(self, request, redirect_url=None):
try:
return super(SignInForm, self).login(request, redirect_url)
except Exception as e:
logger.exception("%s %s", e.__class__.__name__, e)
raise RuntimeError(_("An error occurred logging you in. Please "
"contact your system administrator"))
class SocialVerificationForm(LoginForm):
def __init__(self, *args, **kwargs):
self.sociallogin = kwargs.pop('sociallogin')
super(SocialVerificationForm, self).__init__(*args, **kwargs)
self.fields['login'].required = False
def clean_login(self):
# The plan is: let's gather the user based on the email information we
# have available on the session, this way we don't have to fiddle
# around customizing `user_credentials()`
email = self.sociallogin.user.email
if app_settings.AUTHENTICATION_METHOD == AuthenticationMethod.EMAIL:
return email
user = get_user_by_email(email)
if user is not None:
return user.username
# Oops, something must be really broken if this stage is reached
raise forms.ValidationError(
_('Your user seems to have disappeared. Please report this '
'to the site owners.')
)
| 1,969
|
Python
|
.py
| 43
| 38.534884
| 78
| 0.683438
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,403
|
views.py
|
translate_pootle/pootle/apps/accounts/views.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.shortcuts import redirect
from django.urls import reverse
from allauth.account.views import LoginView
from allauth.socialaccount.helpers import _add_social_account
from allauth.socialaccount.models import SocialLogin
from .forms import SocialVerificationForm
class SocialVerificationView(LoginView):
form_class = SocialVerificationForm
template_name = 'account/social_verification.html'
def dispatch(self, request, *args, **kwargs):
self.sociallogin = None
data = request.session.get('sociallogin', None)
if data is not None:
self.sociallogin = SocialLogin.deserialize(data)
if self.sociallogin is None:
return redirect(reverse('account_login'))
return super(SocialVerificationView, self).dispatch(request, *args,
**kwargs)
def get_context_data(self, **kwargs):
return {
'email': self.sociallogin.user.email,
'provider_name': self.sociallogin.account.get_provider().name,
}
def get_form_kwargs(self):
kwargs = super(SocialVerificationView, self).get_form_kwargs()
kwargs.update({
'sociallogin': self.sociallogin,
})
return kwargs
def form_valid(self, form):
# Authentication is OK, log in and request to connect accounts
form.login(self.request)
return _add_social_account(self.request, self.sociallogin)
| 1,759
|
Python
|
.py
| 40
| 36.3
| 77
| 0.687939
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,404
|
managers.py
|
translate_pootle/pootle/apps/accounts/managers.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.contrib.auth.models import BaseUserManager
from django.db.models import Q
from django.utils import timezone
from django.utils.lru_cache import lru_cache
from pootle_app.models.permissions import check_user_permission
from pootle_translationproject.models import TranslationProject
from . import utils
__all__ = ('UserManager', )
class UserManager(BaseUserManager):
"""Pootle User manager.
This manager hides the 'nobody' and 'default' users for normal
queries, since they are special users. Code that needs access to these
users should use the methods get_default_user and get_nobody_user.
"""
PERMISSION_USERS = ('default', 'nobody')
META_USERS = ('default', 'nobody', 'system')
def _create_user(self, username, email, password, is_superuser,
**extra_fields):
"""Creates and saves a User with the given username, email,
password and superuser status.
Adapted from the core ``auth.User`` model's ``UserManager``: we
have no use for the ``is_staff`` field.
"""
now = timezone.now()
if not username:
raise ValueError('The given username must be set')
email = self.normalize_email(email)
utils.validate_email_unique(email)
user = self.model(username=username, email=email,
is_active=True, is_superuser=is_superuser,
last_login=now, date_joined=now, **extra_fields)
user.set_password(password)
user.save(using=self._db)
return user
def create_user(self, username, email=None, password=None, **extra_fields):
return self._create_user(username, email, password, False,
**extra_fields)
def create_superuser(self, username, email, password, **extra_fields):
return self._create_user(username, email, password, True,
**extra_fields)
@lru_cache()
def get_default_user(self):
return self.get_queryset().get(username='default')
@lru_cache()
def get_nobody_user(self):
return self.get_queryset().get(username='nobody')
@lru_cache()
def get_system_user(self):
return self.get_queryset().get(username='system')
def hide_permission_users(self):
return self.get_queryset().exclude(username__in=self.PERMISSION_USERS)
def hide_meta(self):
return self.get_queryset().exclude(username__in=self.META_USERS)
def get_users_with_permission(self, permission_code, project, language,
tp=None):
default = self.get_default_user()
tp = (
tp
or TranslationProject.objects.get(
project=project,
language=language))
directory = tp.directory
if check_user_permission(default, permission_code, directory):
return self.hide_meta().filter(is_active=True)
user_filter = Q(
permissionset__positive_permissions__codename=permission_code
)
user_filter &= (
Q(permissionset__directory__pootle_path=directory.pootle_path)
| Q(permissionset__directory__pootle_path=language.pootle_path)
| Q(permissionset__directory__pootle_path=project.pootle_path)
)
user_filter |= Q(is_superuser=True)
return self.get_queryset().filter(user_filter).distinct()
| 3,734
|
Python
|
.py
| 81
| 37.148148
| 79
| 0.652785
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,405
|
0003_remove_pootleprofile_id.py
|
translate_pootle/pootle/apps/accounts/migrations/0003_remove_pootleprofile_id.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import migrations
def fix_accounts_alt_src_langs(apps, schema_editor):
"""Remove pootleprofile_id column from accounts_user_alt_src_langs
After migration from 2.5.x the pootleprofile_id column is left on
the m2m table accounts_user_alt_src_langs causing uniqueness issues
(#3856). This migration removes the problem column on mysql.
"""
cursor = schema_editor.connection.cursor()
# Check its mysql - should probs check its not too old.
if not hasattr(cursor.db, "mysql_version"):
return
# Get the db_name and table_name.
db_name = cursor.db.get_connection_params()['db']
table_name = (apps.get_model("accounts.User")
._meta.local_many_to_many[0].m2m_db_table())
# Check the problem column exists.
cursor.execute("SELECT COLUMN_NAME"
" FROM INFORMATION_SCHEMA.COLUMNS"
" WHERE TABLE_SCHEMA = '%s'"
" AND TABLE_NAME = '%s'"
" AND COLUMN_NAME = 'pootleprofile_id';"
% (db_name, table_name))
if not cursor.fetchone():
return
# Get constraints for column.
cursor.execute("SELECT CONSTRAINT_NAME "
" FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE "
" WHERE TABLE_SCHEMA = '%s' "
" AND TABLE_NAME = '%s' "
" AND COLUMN_NAME = 'pootleprofile_id'"
% (db_name, table_name))
uniq = None
fk = None
default = False
for constraint in cursor.fetchall():
if constraint[0].endswith("uniq"):
uniq = constraint[0]
elif constraint[0].startswith("pootleprofile_id_refs"):
fk = constraint[0]
elif constraint[0] == "pootleprofile_id":
default = True
# Removing uniq/fk has to happen in this order.
if uniq:
# Remove unique constraint.
cursor.execute("ALTER TABLE %s "
" DROP KEY %s"
% (table_name, uniq))
if fk:
# Remove foreign key constraint.
cursor.execute("ALTER TABLE %s "
" DROP FOREIGN KEY %s"
% (table_name, fk))
if default:
# Remove unique constraint from older migrated db.
cursor.execute("DROP INDEX pootleprofile_id"
" ON %s;" % (table_name))
# Remove column.
cursor.execute("ALTER TABLE %s "
" DROP COLUMN pootleprofile_id"
% (table_name))
class Migration(migrations.Migration):
dependencies = [
('accounts', '0002_user_alt_src_langs'),
]
operations = [
migrations.RunPython(fix_accounts_alt_src_langs),
]
| 2,823
|
Python
|
.py
| 69
| 30.681159
| 71
| 0.575603
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,406
|
0006_unicode_usernames_are_valid.py
|
translate_pootle/pootle/apps/accounts/migrations/0006_unicode_usernames_are_valid.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.4 on 2016-12-23 16:19
from __future__ import unicode_literals
import django.core.validators
from django.db import migrations, models
import re
class Migration(migrations.Migration):
dependencies = [
('accounts', '0005_user_indeces'),
]
operations = [
migrations.AlterField(
model_name='user',
name='username',
field=models.CharField(help_text='Required. 30 characters or fewer. Letters, numbers and @/./+/-/_ characters', max_length=30, unique=True, validators=[django.core.validators.RegexValidator(re.compile('^[\\w.@+-]+$', 32), 'Enter a valid username.', 'invalid')], verbose_name='Username'),
),
]
| 735
|
Python
|
.py
| 17
| 37.470588
| 299
| 0.660589
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,407
|
0002_user_alt_src_langs.py
|
translate_pootle/pootle/apps/accounts/migrations/0002_user_alt_src_langs.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
from django.db.utils import OperationalError
class AddFieldIfNotExists(migrations.AddField):
def database_forwards(self, app_label, schema_editor, from_state, to_state):
try:
super(AddFieldIfNotExists, self).database_forwards(
app_label, schema_editor, from_state, to_state)
except OperationalError:
pass
class Migration(migrations.Migration):
dependencies = [
('accounts', '0001_initial'),
('pootle_language', '0001_initial'),
]
operations = [
AddFieldIfNotExists(
model_name='user',
name='alt_src_langs',
field=models.ManyToManyField(to='pootle_language.Language', db_index=True, verbose_name='Alternative Source Languages', blank=True),
preserve_default=True,
),
]
| 937
|
Python
|
.py
| 24
| 31.208333
| 144
| 0.658564
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,408
|
0009_remove_currency_and_hourly_rate_fields.py
|
translate_pootle/pootle/apps/accounts/migrations/0009_remove_currency_and_hourly_rate_fields.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.5 on 2017-02-07 15:08
from __future__ import unicode_literals
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('accounts', '0008_add_system_user'),
]
operations = [
migrations.RemoveField(
model_name='user',
name='currency',
),
migrations.RemoveField(
model_name='user',
name='hourly_rate',
),
]
| 497
|
Python
|
.py
| 18
| 20.555556
| 48
| 0.586498
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,409
|
0008_add_system_user.py
|
translate_pootle/pootle/apps/accounts/migrations/0008_add_system_user.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.5 on 2017-02-02 19:02
from __future__ import unicode_literals
from django.db import migrations
def add_system_user(apps, schema_editor):
User = apps.get_model("accounts.User")
sysuser = User.objects.filter(username="system")
if not sysuser.exists():
User.objects.create(
username="system",
full_name="Pootle",
is_active=True)
class Migration(migrations.Migration):
dependencies = [
('accounts', '0007_update_system_username'),
]
operations = [
migrations.RunPython(add_system_user),
]
| 631
|
Python
|
.py
| 19
| 27.210526
| 52
| 0.654545
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,410
|
0001_initial.py
|
translate_pootle/pootle/apps/accounts/migrations/0001_initial.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
import django.utils.timezone
import re
import django.core.validators
class Migration(migrations.Migration):
dependencies = [
]
operations = [
migrations.CreateModel(
name='User',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('password', models.CharField(max_length=128, verbose_name='password')),
('last_login', models.DateTimeField(default=django.utils.timezone.now, verbose_name='last login')),
('username', models.CharField(help_text='Required. 30 characters or fewer. Letters, numbers and @/./+/-/_ characters', unique=True, max_length=30, verbose_name='Username', validators=[django.core.validators.RegexValidator(re.compile('^[\\w.@+-]+$'), 'Enter a valid username.', 'invalid')])),
('email', models.EmailField(max_length=255, verbose_name='Email Address')),
('full_name', models.CharField(max_length=255, verbose_name='Full Name', blank=True)),
('is_active', models.BooleanField(default=True, help_text='Designates whether this user should be treated as active. Unselect this instead of deleting accounts.', verbose_name='Active')),
('is_superuser', models.BooleanField(default=False, help_text='Designates that this user has all permissions without explicitly assigning them.', verbose_name='Superuser Status')),
('date_joined', models.DateTimeField(default=django.utils.timezone.now, verbose_name='date joined')),
('unit_rows', models.SmallIntegerField(default=9, verbose_name='Number of Rows')),
('rate', models.FloatField(default=0, verbose_name='Rate')),
('review_rate', models.FloatField(default=0, verbose_name='Review Rate')),
('hourly_rate', models.FloatField(default=0, verbose_name='Hourly Rate')),
('score', models.FloatField(default=0, verbose_name='Score')),
('currency', models.CharField(blank=True, max_length=3, null=True, verbose_name='Currency', choices=[('USD', 'USD'), ('EUR', 'EUR'), ('CNY', 'CNY'), ('JPY', 'JPY')])),
('is_employee', models.BooleanField(default=False, verbose_name='Is employee?')),
('twitter', models.CharField(max_length=15, null=True, verbose_name='Twitter', blank=True)),
('website', models.URLField(null=True, verbose_name='Website', blank=True)),
('linkedin', models.URLField(null=True, verbose_name='LinkedIn', blank=True)),
('bio', models.TextField(null=True, verbose_name='Short Bio', blank=True)),
],
options={
},
bases=(models.Model,),
),
]
| 2,896
|
Python
|
.py
| 39
| 62.25641
| 307
| 0.631837
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,411
|
0004_allow_null_last_login.py
|
translate_pootle/pootle/apps/accounts/migrations/0004_allow_null_last_login.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('accounts', '0003_remove_pootleprofile_id'),
]
operations = [
migrations.AlterField(
model_name='user',
name='last_login',
field=models.DateTimeField(null=True, verbose_name='last login', blank=True),
),
]
| 449
|
Python
|
.py
| 14
| 25.285714
| 89
| 0.627907
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,412
|
0011_remove_user_rates.py
|
translate_pootle/pootle/apps/accounts/migrations/0011_remove_user_rates.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.5 on 2017-03-03 20:53
from __future__ import unicode_literals
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('accounts', '0010_set_username_unique_error_message'),
]
operations = [
migrations.RemoveField(
model_name='user',
name='rate',
),
migrations.RemoveField(
model_name='user',
name='review_rate',
),
]
| 511
|
Python
|
.py
| 18
| 21.333333
| 63
| 0.594262
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,413
|
0007_update_system_username.py
|
translate_pootle/pootle/apps/accounts/migrations/0007_update_system_username.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.5 on 2017-01-21 14:42
from __future__ import unicode_literals
from django.db import migrations
def update_system_username(apps, schema_editor):
users = apps.get_model("accounts.User").objects
sysuser = users.filter(username="system").first()
if sysuser:
sysuser.full_name = "Pootle"
sysuser.save()
class Migration(migrations.Migration):
dependencies = [
('accounts', '0006_unicode_usernames_are_valid'),
]
operations = [
migrations.RunPython(update_system_username),
]
| 586
|
Python
|
.py
| 17
| 29.588235
| 57
| 0.687389
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,414
|
0010_set_username_unique_error_message.py
|
translate_pootle/pootle/apps/accounts/migrations/0010_set_username_unique_error_message.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.6 on 2017-03-03 10:47
from __future__ import unicode_literals
import django.core.validators
from django.db import migrations, models
import re
class Migration(migrations.Migration):
dependencies = [
('accounts', '0009_remove_currency_and_hourly_rate_fields'),
]
operations = [
migrations.AlterField(
model_name='user',
name='username',
field=models.CharField(error_messages={'unique': 'A user with that username already exists.'}, help_text='Required. 30 characters or fewer. Letters, numbers and @/./+/-/_ characters', max_length=30, unique=True, validators=[django.core.validators.RegexValidator(re.compile('^[\\w.@+-]+$', 32), 'Enter a valid username.', 'invalid')], verbose_name='Username'),
),
]
| 833
|
Python
|
.py
| 17
| 43.235294
| 371
| 0.673243
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,415
|
0005_user_indeces.py
|
translate_pootle/pootle/apps/accounts/migrations/0005_user_indeces.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.9.10 on 2016-10-23 14:27
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('accounts', '0004_allow_null_last_login'),
]
operations = [
migrations.AlterField(
model_name='user',
name='is_active',
field=models.BooleanField(db_index=True, default=True, help_text='Designates whether this user should be treated as active. Unselect this instead of deleting accounts.', verbose_name='Active'),
),
migrations.AlterField(
model_name='user',
name='is_superuser',
field=models.BooleanField(db_index=True, default=False, help_text='Designates that this user has all permissions without explicitly assigning them.', verbose_name='Superuser Status'),
),
]
| 913
|
Python
|
.py
| 20
| 38
| 205
| 0.666667
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,416
|
find_duplicate_emails.py
|
translate_pootle/pootle/apps/accounts/management/commands/find_duplicate_emails.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.contrib.auth import get_user_model
from django.core.management.base import BaseCommand
from accounts.utils import get_duplicate_emails
User = get_user_model()
class Command(BaseCommand):
def handle(self, **options):
duplicates = get_duplicate_emails()
if not duplicates:
self.stdout.write("There are no accounts with duplicate emails\n")
return
for email in duplicates:
users = (User.objects.hide_meta()
.filter(email=email).order_by("-last_login"))
if email:
self.stdout.write("The following users have the email: %s\n"
% email)
else:
self.stdout.write("The following users have no email set:\n")
for user in users:
args = (user.username,
" " * (25 - len(user.username)),
user.last_login.strftime('%Y-%m-%d %H:%M')
if user.last_login is not None else "never logged in",
(user.is_superuser
and "\t\tthis user is a Superuser" or ""))
self.stdout.write(" %s%slast login: %s%s\n" % args)
self.stdout.write("\n")
| 1,568
|
Python
|
.py
| 34
| 34.176471
| 78
| 0.57536
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,417
|
__init__.py
|
translate_pootle/pootle/apps/accounts/management/commands/__init__.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.contrib.auth import get_user_model
from django.core.management.base import BaseCommand, CommandError
User = get_user_model()
class UserCommand(BaseCommand):
"""Base class for handling user commands."""
def add_arguments(self, parser):
parser.add_argument(
"user",
nargs='+',
help="Username of account",
)
def handle(self, **options):
raise NotImplementedError
def get_user(self, username):
try:
return User.objects.get(username=username)
except User.DoesNotExist:
raise CommandError("User %s does not exist" % username)
| 931
|
Python
|
.py
| 25
| 31.28
| 77
| 0.683742
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,418
|
merge_user.py
|
translate_pootle/pootle/apps/accounts/management/commands/merge_user.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from . import UserCommand
from ... import utils
class Command(UserCommand):
help = "Merge user to other_user"
def add_arguments(self, parser):
parser.add_argument(
"user",
nargs=1,
help="Username of account to merge from",
)
parser.add_argument(
"other_user",
nargs=1,
help="Username of account to merge into",
)
parser.add_argument(
"--no-delete",
dest='delete',
action="store_false",
default=True,
help="Don't delete user after merging.",
)
def handle(self, **options):
src_user = self.get_user(username=options['user'][0])
utils.UserMerger(src_user,
self.get_user(username=options['other_user'][0])).merge()
if options["delete"]:
self.stdout.write("Deleting user: %s...\n" % src_user.username)
src_user.delete()
self.stdout.write("User deleted: %s\n" % src_user.username)
| 1,334
|
Python
|
.py
| 37
| 27.378378
| 82
| 0.589922
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,419
|
purge_user.py
|
translate_pootle/pootle/apps/accounts/management/commands/purge_user.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from . import UserCommand
class Command(UserCommand):
help = "Delete user and all related objects"
def handle(self, **options):
for user in options['user']:
self.get_user(user).delete(purge=True)
| 503
|
Python
|
.py
| 13
| 35.230769
| 77
| 0.720165
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,420
|
update_user_email.py
|
translate_pootle/pootle/apps/accounts/management/commands/update_user_email.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.contrib.auth import get_user_model
from django.core.management.base import CommandError
from django.core.validators import ValidationError
import accounts
from . import UserCommand
User = get_user_model()
class Command(UserCommand):
help = "Update user email address"
def add_arguments(self, parser):
parser.add_argument(
"user",
help="Username of account",
)
parser.add_argument(
"email",
help="New email address",
)
def handle(self, **options):
try:
accounts.utils.update_user_email(self.get_user(options['user']),
options['email'])
except ValidationError as e:
raise CommandError(e)
self.stdout.write("Email updated: %s, %s\n" % (options['user'],
options['email']))
| 1,205
|
Python
|
.py
| 32
| 28.875
| 77
| 0.618557
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,421
|
verify_user.py
|
translate_pootle/pootle/apps/accounts/management/commands/verify_user.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.contrib.auth import get_user_model
from django.core.management.base import CommandError
from django.core.validators import ValidationError
from . import UserCommand
from ... import utils
class Command(UserCommand):
help = "Verify a user of the system without requiring email verification"
def add_arguments(self, parser):
parser.add_argument(
"user",
nargs='*', # Allow 0 in case --all is used
help="Username of account",
)
parser.add_argument(
'--all',
dest='all',
action="store_true",
default=False,
help='Verify all users',
)
def handle(self, **options):
if bool(options['user']) == options['all']:
raise CommandError("Either provide a 'user' to verify or "
"use '--all' to verify all users")
if options['all']:
for user in get_user_model().objects.hide_meta():
try:
utils.verify_user(user)
self.stdout.write("Verified user '%s'" % user.username)
except (ValueError, ValidationError) as e:
self.stderr.write(e[0])
if options['user']:
for user in options['user']:
try:
utils.verify_user(self.get_user(user))
self.stdout.write("User '%s' has been verified" % user)
except (ValueError, ValidationError) as e:
self.stderr.write(e[0])
| 1,844
|
Python
|
.py
| 45
| 30.577778
| 77
| 0.584031
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,422
|
urls.py
|
translate_pootle/pootle/apps/contact/urls.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.conf.urls import url
from .views import ContactFormTemplateView, ContactFormView, ReportFormView
urlpatterns = [
url(r'^$',
ContactFormTemplateView.as_view(),
name='pootle-contact'),
url(r'^xhr/$',
ContactFormView.as_view(),
name='pootle-contact-xhr'),
url(r'report/$',
ReportFormView.as_view(),
name='pootle-contact-report-error'),
]
| 686
|
Python
|
.py
| 20
| 30.1
| 77
| 0.699396
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,423
|
forms.py
|
translate_pootle/pootle/apps/contact/forms.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django import forms
from django.conf import settings
from contact_form.forms import ContactForm as OriginalContactForm
from pootle.core.forms import MathCaptchaForm
from pootle.core.mail import send_mail
from pootle.i18n.gettext import ugettext_lazy as _
class ContactForm(MathCaptchaForm, OriginalContactForm):
field_order = ['name', 'email', 'email_subject', 'body', 'captcha_answer',
'captcha_token']
email_subject = forms.CharField(
max_length=100,
label=_(u'Subject'),
widget=forms.TextInput(
attrs={'placeholder': _('Please enter a message subject')}
),
)
def __init__(self, *args, **kwargs):
super(ContactForm, self).__init__(*args, **kwargs)
self.fields['name'].label = _(u'Name')
name_placeholder = _('Please enter your name')
self.fields['name'].widget.attrs['placeholder'] = name_placeholder
self.fields['email'].label = _(u'Email address')
email_placeholder = _('Please enter your email address')
self.fields['email'].widget.attrs['placeholder'] = email_placeholder
self.fields['body'].label = _(u'Message')
body_placeholder = _('Please enter your message')
self.fields['body'].widget.attrs['placeholder'] = body_placeholder
if self.request.user.is_authenticated:
del self.fields['captcha_answer']
del self.fields['captcha_token']
def get_context(self):
"""Get context to render the templates for email subject and body."""
ctx = super(ContactForm, self).get_context()
ctx['server_name'] = settings.POOTLE_TITLE
ctx['ip_address'] = (
self.request.META.get('HTTP_X_FORWARDED_FOR',
self.request.META.get('REMOTE_ADDR')))
return ctx
def recipient_list(self):
return [settings.POOTLE_CONTACT_EMAIL]
def save(self, fail_silently=False):
"""Build and send the email message."""
reply_to = u'%s <%s>' % (
self.cleaned_data['name'],
self.cleaned_data['email'],
)
kwargs = self.get_message_dict()
kwargs["headers"] = {"Reply-To": reply_to}
send_mail(fail_silently=fail_silently, **kwargs)
class ReportForm(ContactForm):
"""Contact form used to report errors on strings."""
field_order = ['name', 'email', 'context', 'body', 'captcha_answer',
'captcha_token']
subject_template_name = 'contact_form/report_form_subject.txt'
template_name = 'contact_form/report_form.txt'
context = forms.CharField(
label=_(u'String context'),
required=True,
disabled=True,
widget=forms.Textarea(attrs={'rows': 6}),
)
def __init__(self, *args, **kwargs):
self.unit = kwargs.pop('unit', None)
super(ReportForm, self).__init__(*args, **kwargs)
self.fields['body'].label = _(u'Question or comment')
body_placeholder = _('Please enter your question or comment')
self.fields['body'].widget.attrs['placeholder'] = body_placeholder
del self.fields['email_subject']
def get_context(self):
"""Get context to render the templates for email subject and body."""
ctx = super(ReportForm, self).get_context()
unit_pk = None
language_code = None
project_code = None
if self.unit:
unit_pk = self.unit.pk
language_code = self.unit.store.translation_project.language.code
project_code = self.unit.store.translation_project.project.code
ctx.update({
'unit': unit_pk,
'language': language_code,
'project': project_code,
})
return ctx
def recipient_list(self):
# Try to report string error to the report email for the project. If
# the project doesn't have a report email then fall back to the global
# string errors report email.
if self.unit:
report_email = (
self.unit.store.translation_project.project.report_email)
if report_email:
return [report_email]
report_email = getattr(settings, 'POOTLE_CONTACT_REPORT_EMAIL',
settings.POOTLE_CONTACT_EMAIL)
return [report_email]
| 4,630
|
Python
|
.py
| 103
| 36.067961
| 78
| 0.62739
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,424
|
views.py
|
translate_pootle/pootle/apps/contact/views.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.template.loader import render_to_string
from django.urls import reverse
from django.views.generic import TemplateView
from contact_form.views import ContactFormView as OriginalContactFormView
from pootle.core.views.mixins import AjaxResponseMixin
from pootle.i18n.gettext import ugettext_lazy as _
from pootle_store.models import Unit
from .forms import ContactForm, ReportForm
class ContactFormTemplateView(TemplateView):
template_name = 'contact_form/contact_form.html'
class ContactFormView(AjaxResponseMixin, OriginalContactFormView):
form_class = ContactForm
template_name = 'contact_form/xhr_contact_form.html'
def get_context_data(self, **kwargs):
ctx = super(ContactFormView, self).get_context_data(**kwargs)
# Provide the form action URL to use in the template that renders the
# contact dialog.
ctx.update({
'contact_form_title': _('Contact Us'),
'contact_form_url': reverse('pootle-contact-xhr'),
})
return ctx
def get_initial(self):
initial = super(ContactFormView, self).get_initial()
user = self.request.user
if user.is_authenticated:
initial.update({
'name': user.full_name,
'email': user.email,
})
return initial
def get_success_url(self):
# XXX: This is unused. We don't need a `/contact/sent/` URL, but the
# parent :cls:`ContactView` enforces us to set some value here
return reverse('pootle-contact')
class ReportFormView(ContactFormView):
form_class = ReportForm
def _get_reported_unit(self):
"""Get the unit the error is being reported for."""
unit_pk = self.request.GET.get('report', False)
if not unit_pk:
return None
try:
unit_pk = int(unit_pk)
except ValueError:
return None
try:
unit = Unit.objects.select_related(
'store__translation_project__project',
'store__translation_project__language',
).get(pk=unit_pk)
except Unit.DoesNotExist:
return None
if unit.is_accessible_by(self.request.user):
return unit
return None
def get_context_data(self, **kwargs):
ctx = super(ReportFormView, self).get_context_data(**kwargs)
# Provide the form action URL to use in the template that renders the
# contact dialog.
unit_pk = self.unit.pk if self.unit else ''
url = "%s?report=%s" % (reverse('pootle-contact-report-error'), unit_pk)
ctx.update({
'contact_form_title': _('Report problem with string'),
'contact_form_url': url,
})
return ctx
def get_form_kwargs(self):
kwargs = super(ReportFormView, self).get_form_kwargs()
self.unit = self._get_reported_unit()
if self.unit:
kwargs.update({'unit': self.unit})
return kwargs
def get_initial(self):
initial = super(ReportFormView, self).get_initial()
self.unit = self._get_reported_unit()
if not self.unit:
return initial
abs_url = self.request.build_absolute_uri(self.unit.get_translate_url())
initial.update({
'context': render_to_string(
'contact_form/report_form_context.txt',
context={
'unit': self.unit,
'unit_absolute_url': abs_url,
}),
})
return initial
| 3,854
|
Python
|
.py
| 95
| 31.768421
| 80
| 0.632566
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,425
|
models.py
|
translate_pootle/pootle/apps/pootle_language/models.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from collections import OrderedDict
from translate.lang.data import get_language_iso_fullname
from django.conf import settings
from django.db import models
from django.urls import reverse
from django.utils import translation
from django.utils.functional import cached_property
from pootle.core.delegate import data_tool, language_code, site_languages
from pootle.core.mixins import TreeItem
from pootle.core.url_helpers import get_editor_filter
from pootle.i18n.gettext import language_dir, tr_lang, ugettext_lazy as _
from staticpages.models import StaticPage
class Language(models.Model, TreeItem):
# any changes to the `code` field may require updating the schema
# see migration 0002_case_insensitive_schema.py
code = models.CharField(
max_length=50, null=False, unique=True, db_index=True,
verbose_name=_("Code"),
help_text=_('ISO 639 language code for the language, possibly '
'followed by an underscore (_) and an ISO 3166 country '
'code. <a href="http://www.w3.org/International/'
'articles/language-tags/">More information</a>')
)
fullname = models.CharField(max_length=255, null=False,
verbose_name=_("Full Name"))
specialchars = models.CharField(
max_length=255, blank=True, verbose_name=_("Special Characters"),
help_text=_('Enter any special characters that users might find '
'difficult to type')
)
plurals_help_text = _('For more information, visit '
'<a href="http://docs.translatehouse.org/projects/'
'localization-guide/en/latest/l10n/'
'pluralforms.html">'
'our page</a> on plural forms.')
nplural_choices = (
(0, _('Unknown')), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)
)
nplurals = models.SmallIntegerField(
default=0, choices=nplural_choices,
verbose_name=_("Number of Plurals"), help_text=plurals_help_text
)
pluralequation = models.CharField(
max_length=255, blank=True, verbose_name=_("Plural Equation"),
help_text=plurals_help_text)
directory = models.OneToOneField('pootle_app.Directory', db_index=True,
editable=False, on_delete=models.CASCADE)
objects = models.Manager()
class Meta(object):
ordering = ['code']
db_table = 'pootle_app_language'
# # # # # # # # # # # # # # Properties # # # # # # # # # # # # # # # # # #
@cached_property
def data_tool(self):
return data_tool.get(self.__class__)(self)
@property
def pootle_path(self):
return '/%s/' % self.code
@property
def name(self):
"""localised ISO name for the language or fullname
if request lang == server lang, and fullname is set. Uses code
as the ultimate fallback
"""
site_langs = site_languages.get()
server_code = language_code.get()(settings.LANGUAGE_CODE)
request_code = language_code.get()(translation.get_language())
use_db_name = (
not translation.get_language()
or (self.fullname
and server_code.matches(request_code)))
if use_db_name:
return self.fullname
iso_name = get_language_iso_fullname(self.code) or self.fullname
return (
site_langs.capitalize(tr_lang(iso_name))
if iso_name
else self.code)
@property
def direction(self):
"""Return the language direction."""
return language_dir(self.code)
# # # # # # # # # # # # # # Methods # # # # # # # # # # # # # # # # # # #
@classmethod
def get_canonical(cls, language_code):
"""Returns the canonical `Language` object matching `language_code`.
If no language can be matched, `None` will be returned.
:param language_code: the code of the language to retrieve.
"""
qs = cls.objects.select_related("directory")
try:
return qs.get(code__iexact=language_code)
except cls.DoesNotExist:
_lang_code = language_code
if "-" in language_code:
_lang_code = language_code.replace("-", "_")
elif "_" in language_code:
_lang_code = language_code.replace("_", "-")
try:
return qs.get(code__iexact=_lang_code)
except cls.DoesNotExist:
return None
def __unicode__(self):
return u"%s - %s" % (self.name, self.code)
def __init__(self, *args, **kwargs):
super(Language, self).__init__(*args, **kwargs)
def save(self, *args, **kwargs):
# create corresponding directory object
from pootle_app.models.directory import Directory
self.directory = Directory.objects.root.get_or_make_subdir(self.code)
# Do not repeat special chars.
self.specialchars = u"".join(
OrderedDict([
((specialchar
if isinstance(specialchar, unicode)
else specialchar.decode("unicode_escape")),
None)
for specialchar
in self.specialchars]).keys())
super(Language, self).save(*args, **kwargs)
def delete(self, *args, **kwargs):
directory = self.directory
super(Language, self).delete(*args, **kwargs)
directory.delete()
def get_absolute_url(self):
return reverse('pootle-language-browse', args=[self.code])
def get_translate_url(self, **kwargs):
return u''.join([
reverse('pootle-language-translate', args=[self.code]),
get_editor_filter(**kwargs),
])
def clean(self):
super(Language, self).clean()
if self.fullname:
self.fullname = self.fullname.strip()
# # # TreeItem
def get_children(self):
return self.translationproject_set.live()
# # # /TreeItem
def get_children_for_user(self, user, select_related=None):
return self.translationproject_set.for_user(
user, select_related=select_related
).select_related(
"project"
).order_by('project__fullname')
def get_announcement(self, user=None):
"""Return the related announcement, if any."""
return StaticPage.get_announcement_for(self.pootle_path, user)
| 6,773
|
Python
|
.py
| 155
| 34.354839
| 79
| 0.60793
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,426
|
getters.py
|
translate_pootle/pootle/apps/pootle_language/getters.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from pootle.core.delegate import language_code, language_team, site_languages
from pootle.core.language import LanguageCode
from pootle.core.plugin import getter
from .teams import LanguageTeam
from .utils import SiteLanguages
_site_languages = SiteLanguages()
@getter(language_code)
def language_code_getter(**kwargs_):
return LanguageCode
@getter(language_team)
def language_team_getter(**kwargs_):
return LanguageTeam
@getter(site_languages)
def site_languages_getter(**kwargs_):
return _site_languages
| 803
|
Python
|
.py
| 22
| 34.5
| 77
| 0.793774
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,427
|
teams.py
|
translate_pootle/pootle/apps/pootle_language/teams.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Permission
from django.utils.functional import cached_property
from pootle_store.constants import OBSOLETE
from pootle_store.models import Suggestion
User = get_user_model()
class LanguageTeam(object):
# this shouldnt be a dict
roles = dict(
member=["suggest"],
submitter=["suggest", "translate"],
reviewer=["suggest", "translate", "review"],
admin=["administrate", "suggest", "translate", "review"])
def __init__(self, language):
self.language = language
@property
def admins(self):
return self._get_members("administrate")
@property
def members(self):
return self._get_members("suggest", ["translate", "review", "administrate"])
@property
def submitters(self):
return self._get_members("translate", ["review", "administrate"])
@property
def reviewers(self):
return self._get_members("review", ["administrate"])
def add_member(self, user, role):
permission_set = self.get_permission_set(user, create=True)
for permission in self.get_permissions_for_role(role):
permission_set.positive_permissions.add(permission)
self.update_permissions()
def get_permissions_for_role(self, role):
return Permission.objects.filter(codename__in=self.roles[role])
def get_permission_set(self, user, create=False):
if create:
return (
self.language.directory.permission_sets.get_or_create(
user=user, directory=self.language.directory.id))[0]
return self.language.directory.permission_sets.get(
user=user, directory=self.language.directory.id)
def remove_member(self, user):
self.get_permission_set(user).delete()
self.update_permissions()
@property
def non_members(self):
return User.objects.exclude(
pk__in=self._get_members("suggest").values_list("id", flat=True))
@property
def suggestions(self):
suggestions = Suggestion.objects.filter(
state__name="pending",
unit__state__gt=OBSOLETE,
unit__store__translation_project__language=self.language)
suggestions = suggestions.exclude(
unit__store__translation_project__project__disabled=True
).exclude(unit__store__obsolete=True)
suggestions = suggestions.select_related(
"unit",
"unit__store",
"unit__store__translation_project",
"unit__store__translation_project__project")
return suggestions.order_by("-creation_time", "-pk")
@property
def users_with_suggestions(self):
return set(
self.suggestions.values_list(
"user__username",
"user__full_name"))
@property
def superusers(self):
return User.objects.filter(is_superuser=True)
@cached_property
def permissions(self):
return self.language.directory.permission_sets.values_list(
"positive_permissions__codename",
"user")
def _get_members(self, perm=None, exclude_perms=()):
members = set()
not_members = set()
for (permission, user) in self.permissions:
if permission == perm:
members.add(user)
if permission in exclude_perms:
not_members.add(user)
return User.objects.filter(
pk__in=members - not_members).order_by("username")
def update_permissions(self):
if "permissions" in self.__dict__:
del self.__dict__["permissions"]
| 3,975
|
Python
|
.py
| 97
| 32.701031
| 84
| 0.646525
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,428
|
urls.py
|
translate_pootle/pootle/apps/pootle_language/urls.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.conf.urls import url
from .views import (
LanguageBrowseView, LanguageSuggestionAdminView, LanguageTeamAdminFormView,
LanguageTeamAdminNewMembersJSON, LanguageTranslateView,
language_characters_admin)
urlpatterns = [
url(r'^(?P<language_code>[^/]*)/$',
LanguageBrowseView.as_view(),
name='pootle-language-browse'),
url(r'^(?P<language_code>[^/]*)/translate/$',
LanguageTranslateView.as_view(),
name='pootle-language-translate'),
# Admin
url(r'^(?P<language_code>[^/]*)/admin/team/$',
LanguageTeamAdminFormView.as_view(),
name='pootle-language-admin-team'),
url(r'^(?P<language_code>[^/]*)/admin/team/new_members/$',
LanguageTeamAdminNewMembersJSON.as_view(),
name='pootle-language-admin-team-new-members'),
url(r'(?P<language_code>[^/]*)/admin/suggestions/',
LanguageSuggestionAdminView.as_view(),
name='pootle-language-admin-suggestions'),
url(r'^(?P<language_code>[^/]*)/admin/characters/$',
language_characters_admin,
name='pootle-language-admin-characters')]
| 1,392
|
Python
|
.py
| 32
| 38.0625
| 79
| 0.688331
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,429
|
apps.py
|
translate_pootle/pootle/apps/pootle_language/apps.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle language. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import importlib
from django.apps import AppConfig
class PootleLanguageConfig(AppConfig):
name = "pootle_language"
verbose_name = "Pootle Language"
version = "0.1.4"
def ready(self):
importlib.import_module("pootle_language.getters")
importlib.import_module("pootle_language.receivers")
| 601
|
Python
|
.py
| 16
| 34.1875
| 78
| 0.746114
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,430
|
receivers.py
|
translate_pootle/pootle/apps/pootle_language/receivers.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.db.models.signals import post_save, pre_delete
from django.dispatch import receiver
from pootle.core.delegate import revision_updater
from .models import Language
@receiver(post_save, sender=Language)
def lang_created_handler(**kwargs):
if not kwargs.get("created"):
return
instance = kwargs["instance"]
revision_context = instance.directory.parent
updater = revision_updater.get(revision_context.__class__)
updater(revision_context).update(["languages"])
@receiver(pre_delete, sender=Language)
def lang_delete_handler(**kwargs):
instance = kwargs["instance"]
revision_context = instance.directory.parent
updater = revision_updater.get(revision_context.__class__)
updater(revision_context).update(["languages"])
| 1,050
|
Python
|
.py
| 25
| 38.96
| 77
| 0.760314
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,431
|
utils.py
|
translate_pootle/pootle/apps/pootle_language/utils.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from translate.lang.data import get_language_iso_fullname
from django.conf import settings
from django.utils.translation import get_language
from pootle.core import language
from pootle.core.decorators import persistent_property
from pootle.core.delegate import language_code, revision
from pootle.i18n.gettext import tr_lang
from pootle_app.models import Directory
from .apps import PootleLanguageConfig
from .models import Language
class SiteLanguages(object):
ns = "pootle.languages"
sw_version = PootleLanguageConfig.version
@property
def object(self):
return Directory.objects.root
@property
def request_lang(self):
return get_language()
@property
def cache_key(self):
rev_context = self.object
return (
"all_languages",
self.request_lang,
revision.get(rev_context.__class__)(
rev_context).get(key="languages"))
@property
def site_languages(self):
langs = Language.objects.filter(
translationproject__isnull=False,
translationproject__directory__obsolete=False).distinct()
return langs.values_list("code", "fullname")
def capitalize(self, language_name):
if self.request_lang in language.UPPERCASE_UI:
return "".join(
[language_name[0].upper(), language_name[1:]])
return language_name
def localised_languages(self, langs):
matches = False
if self.request_lang:
server_code = language_code.get()(settings.LANGUAGE_CODE)
request_code = language_code.get()(self.request_lang)
matches = server_code.matches(request_code)
if matches:
trans_func = lambda code, name: name
else:
trans_func = lambda code, name: self.capitalize(
tr_lang(
get_language_iso_fullname(code)
or name))
return {
code: trans_func(code, name)
for code, name
in langs}
@persistent_property
def all_languages(self):
return self.localised_languages(self.site_languages)
@persistent_property
def languages(self):
return self.localised_languages(
self.site_languages.filter(
translationproject__project__disabled=False).distinct())
| 2,658
|
Python
|
.py
| 70
| 30.071429
| 77
| 0.663817
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,432
|
__init__.py
|
translate_pootle/pootle/apps/pootle_language/__init__.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
default_app_config = 'pootle_language.apps.PootleLanguageConfig'
| 341
|
Python
|
.py
| 8
| 41.5
| 77
| 0.771084
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,433
|
forms.py
|
translate_pootle/pootle/apps/pootle_language/forms.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django import forms
from django.contrib.auth import get_user_model
from django.urls import reverse
from pootle.core.delegate import language_team, review
from pootle.core.forms import FormtableForm
from pootle.core.views.widgets import RemoteSelectWidget, TableSelectMultiple
from pootle.i18n.gettext import ugettext_lazy as _
from pootle_store.constants import OBSOLETE, STATES_MAP
from pootle_store.models import Suggestion
from pootle_translationproject.models import TranslationProject
from .models import Language
User = get_user_model()
LANGUAGE_TEAM_ROLES = (
("member", _("Member")),
("submitter", _("Submitter")),
("reviewer", _("Reviewer")),
("admin", _("Administrator")))
class LanguageSpecialCharsForm(forms.ModelForm):
class Meta(object):
model = Language
fields = ('specialchars',)
class LanguageTeamBaseAdminForm(forms.Form):
@property
def language_team(self):
return language_team.get(self.language.__class__)(self.language)
class LanguageTeamFormtableForm(FormtableForm, LanguageTeamBaseAdminForm):
pass
class LanguageTeamNewMemberSearchForm(LanguageTeamBaseAdminForm):
q = forms.CharField(max_length=255)
def __init__(self, *args, **kwargs):
self.language = kwargs.pop("language")
super(LanguageTeamNewMemberSearchForm, self).__init__(*args, **kwargs)
def search(self):
non_members = self.language_team.non_members
return dict(
results=[
dict(id=int(m["id"]), text=m["username"])
for m
in (non_members.filter(username__contains=self.cleaned_data["q"])
.values("id", "username"))])
class LanguageTeamAdminForm(LanguageTeamBaseAdminForm):
rm_admins = forms.ModelMultipleChoiceField(
label=_("Administrators"),
widget=TableSelectMultiple(item_attrs=["username"]),
required=False,
queryset=User.objects.none())
rm_reviewers = forms.ModelMultipleChoiceField(
required=False,
label=_("Reviewers"),
widget=TableSelectMultiple(item_attrs=["username"]),
queryset=User.objects.none())
rm_submitters = forms.ModelMultipleChoiceField(
required=False,
label=_("Submitters"),
widget=TableSelectMultiple(item_attrs=["username"]),
queryset=User.objects.none())
rm_members = forms.ModelMultipleChoiceField(
required=False,
label=_("Members"),
widget=TableSelectMultiple(item_attrs=["username"]),
queryset=User.objects.none())
new_member = forms.ModelChoiceField(
label=_("New member"),
help_text=_("Add a user to this team"),
required=False,
queryset=User.objects.none(),
initial=[],
widget=RemoteSelectWidget(
attrs={
"data-s2-placeholder": _("Search for users to add"),
'class': 'js-select2-remote js-s2-new-members'}))
role = forms.ChoiceField(
label=_("Role"),
required=False,
widget=forms.Select(
attrs={'class': 'js-select2'}),
choices=LANGUAGE_TEAM_ROLES)
def __init__(self, *args, **kwargs):
self.language = kwargs.pop("language")
super(LanguageTeamAdminForm, self).__init__(*args, **kwargs)
for role in self.language_team.roles:
self.fields["rm_%ss" % role].queryset = getattr(
self.language_team, "%ss" % role)
self.fields["rm_%ss" % role].choices = [
(item.id, item)
for item in
getattr(self.language_team, "%ss" % role)]
self.fields["new_member"].widget.attrs["data-select2-url"] = reverse(
"pootle-language-admin-team-new-members",
kwargs=dict(language_code=self.language.code))
self.fields["new_member"].queryset = self.language_team.non_members
def clean(self):
if any(self.errors):
return
no_role = (
self.cleaned_data.get("new_member")
and not self.cleaned_data.get("role"))
if no_role:
self.add_error(
"role",
forms.ValidationError(
_("Role is required when adding a new member")))
def should_save(self):
return (
self.cleaned_data["new_member"] and self.cleaned_data["role"]
or any(
self.cleaned_data["rm_%ss" % role]
for role in self.language_team.roles))
def save(self):
if self.cleaned_data["new_member"] and self.cleaned_data["role"]:
self.language_team.add_member(
self.cleaned_data["new_member"],
self.cleaned_data["role"])
else:
for role in self.language_team.roles:
if self.cleaned_data["rm_%ss" % role]:
for user in self.cleaned_data["rm_%ss" % role]:
self.language_team.remove_member(user)
class LanguageSuggestionAdminForm(LanguageTeamFormtableForm):
action_field = "actions"
search_field = "suggestions"
action_choices = (
("", "----"),
("reject", _("Reject")),
("accept", _("Accept")))
filter_suggester = forms.ChoiceField(
label=_("Filter by suggester"),
choices=(),
required=False,
widget=forms.Select(
attrs={'class': 'js-select2 select2-language'}))
filter_state = forms.ChoiceField(
label=_("Filter by state"),
required=False,
choices=(
[("", "-----")]
+ [(k, v)
for k, v
in STATES_MAP.items() if k != OBSOLETE]),
widget=forms.Select(
attrs={'class': 'js-select2 select2-language'}))
filter_tp = forms.ModelChoiceField(
label=_("Project"),
required=False,
queryset=TranslationProject.objects.none(),
widget=forms.Select(
attrs={'class': 'js-select2'}))
suggestions = forms.ModelMultipleChoiceField(
widget=TableSelectMultiple(
item_attrs=[
"unit_link",
"unit_state",
"unit",
"target_f",
"user",
"creation_time",
"project"]),
required=False,
queryset=Suggestion.objects.select_related(
"unit",
"unit__store",
"unit__store__translation_project",
"unit__store__translation_project__project").none())
def __init__(self, *args, **kwargs):
self.user = kwargs.pop("user")
self.language = kwargs.pop("language")
super(LanguageSuggestionAdminForm, self).__init__(*args, **kwargs)
self.fields["filter_suggester"].choices = self.filter_suggester_choices
self.fields["filter_tp"].queryset = self.filter_tp_qs
self.fields["suggestions"].queryset = self.suggestions_qs
@property
def filter_suggester_choices(self):
suggesters = list(
(username,
("%s (%s)" % (fullname, username)
if fullname.strip()
else username))
for username, fullname
in sorted(self.language_team.users_with_suggestions))
return [("", "-----")] + suggesters
@property
def suggestions_qs(self):
return self.language_team.suggestions.select_related("unit", "user").filter(
unit__store__translation_project__project__disabled=False,
unit__store__obsolete=False)
@property
def filter_tp_qs(self):
tps = self.language.translationproject_set.exclude(
project__disabled=True)
tps = tps.filter(
stores__unit__suggestion__state__name="pending")
return tps.order_by("project__code").distinct()
@property
def suggestions_to_save(self):
if not self.is_valid():
return []
return (
self.fields["suggestions"].queryset
if self.cleaned_data["select_all"]
else self.cleaned_data["suggestions"])
@property
def suggestions_review(self):
if not self.is_valid():
return
return review.get(Suggestion)(self.suggestions_to_save, self.user)
def save(self):
return (
self.suggestions_review.accept(
comment=self.cleaned_data["comment"])
if self.cleaned_data["actions"] == "accept"
else self.suggestions_review.reject(
comment=self.cleaned_data["comment"]))
def search(self):
searched = super(LanguageSuggestionAdminForm, self).search()
if self.cleaned_data.get("filter_suggester"):
searched = searched.filter(
user__username=self.cleaned_data["filter_suggester"])
if self.cleaned_data.get("filter_tp"):
searched = searched.filter(
unit__store__translation_project=self.cleaned_data["filter_tp"])
if self.cleaned_data.get("filter_state"):
searched = searched.filter(
unit__state=self.cleaned_data["filter_state"])
return searched
| 9,477
|
Python
|
.py
| 231
| 31.367965
| 84
| 0.606709
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,434
|
views.py
|
translate_pootle/pootle/apps/pootle_language/views.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.contrib import messages
from django.http import Http404
from django.shortcuts import redirect, render
from django.urls import reverse
from django.utils.functional import cached_property
from django.utils.safestring import mark_safe
from pootle.core.browser import make_project_item
from pootle.core.decorators import (
get_object_or_404, get_path_obj, permission_required)
from pootle.core.exceptions import Http400
from pootle.core.views import PootleBrowseView, PootleTranslateView
from pootle.core.views.admin import PootleFormView
from pootle.core.views.decorators import requires_permission, set_permissions
from pootle.core.views.formtable import Formtable
from pootle.core.views.mixins import PootleJSONMixin
from pootle.i18n import formatter
from pootle.i18n.gettext import ugettext_lazy as _, ungettext_lazy
from pootle_misc.util import cmp_by_last_activity
from pootle_store.constants import STATES_MAP
from .apps import PootleLanguageConfig
from .forms import (
LanguageSpecialCharsForm, LanguageSuggestionAdminForm,
LanguageTeamAdminForm, LanguageTeamNewMemberSearchForm)
from .models import Language
class LanguageMixin(object):
ns = "pootle.language"
sw_version = PootleLanguageConfig.version
model = Language
browse_url_path = "pootle-language-browse"
translate_url_path = "pootle-language-translate"
template_extends = 'languages/base.html'
@property
def language(self):
return self.object
@property
def permission_context(self):
return self.get_object().directory
@property
def url_kwargs(self):
return {"language_code": self.object.code}
def get_object(self):
return self.object
@cached_property
def object(self):
lang = Language.get_canonical(self.kwargs["language_code"])
if lang is None:
raise Http404
return lang
def get(self, *args, **kwargs):
self.object = self.get_object()
if self.object.code != kwargs["language_code"]:
return redirect(
self.url_pattern_name,
self.object.code,
permanent=True)
return super(LanguageMixin, self).get(*args, **kwargs)
class LanguageBrowseView(LanguageMixin, PootleBrowseView):
url_pattern_name = "pootle-language-browse"
view_name = "language"
@cached_property
def object_children(self):
items = [make_project_item(tp)
for tp in self.object.get_children_for_user(self.request.user)]
items = self.add_child_stats(items)
items.sort(cmp_by_last_activity)
return items
@property
def language(self):
return {
'code': self.object.code,
'name': self.object.name}
def get(self, *args, **kwargs):
response = super(LanguageBrowseView, self).get(*args, **kwargs)
response.set_cookie('pootle-language', self.object.code)
return response
class LanguageTranslateView(LanguageMixin, PootleTranslateView):
url_pattern_name = "pootle-language-translate"
@get_path_obj
@permission_required('administrate')
def language_characters_admin(request, language):
form = LanguageSpecialCharsForm(request.POST
if request.method == 'POST'
else None,
instance=language)
if form.is_valid():
form.save()
return redirect('pootle-language-browse', language.code)
ctx = {
'page': 'admin-characters',
'browse_url': reverse('pootle-language-browse', kwargs={
'language_code': language.code,
}),
'translate_url': reverse('pootle-language-translate', kwargs={
'language_code': language.code,
}),
'language': language,
'directory': language.directory,
'form': form,
}
return render(request, 'languages/admin/characters.html', ctx)
class SuggestionFormtable(Formtable):
row_field = "suggestions"
filters_template = "languages/admin/includes/suggestions_header.html"
@property
def messages(self):
return self.kwargs.get("messages", [])
class SuggestionDisplay(object):
def __init__(self, suggestion):
self.__suggestion__ = suggestion
@property
def unit(self):
return self.__suggestion__.unit.source_f
@property
def project(self):
tp = self.__suggestion__.unit.store.translation_project
return mark_safe(
"<a href='%s'>%s</a>"
% (tp.get_absolute_url(),
tp.project.code))
@property
def unit_state(self):
return STATES_MAP[self.__suggestion__.unit.state]
@property
def unit_link(self):
return mark_safe(
"<a href='%s'>#%s</a>"
% (self.__suggestion__.unit.get_translate_url(),
self.__suggestion__.unit.id))
def __getattr__(self, k):
try:
return getattr(self.__suggestion__, k)
except AttributeError:
return self.__getattribute__(k)
class PootleLanguageAdminFormView(PootleFormView):
@property
def permission_context(self):
return self.language.directory
@set_permissions
@requires_permission("administrate")
def dispatch(self, request, *args, **kwargs):
# get funky with the request 8/
return super(
PootleLanguageAdminFormView, self).dispatch(request, *args, **kwargs)
@cached_property
def language(self):
return get_object_or_404(
Language.objects.select_related("directory"),
code=self.kwargs["language_code"])
def get_form_kwargs(self):
kwargs = super(PootleLanguageAdminFormView, self).get_form_kwargs()
kwargs["language"] = self.language
return kwargs
@property
def success_kwargs(self):
return dict(language_code=self.language.code)
class LanguageSuggestionAdminView(PootleLanguageAdminFormView):
template_name = 'languages/admin/language_team_suggestions.html'
form_class = LanguageSuggestionAdminForm
success_url_pattern = "pootle-language-admin-suggestions"
formtable_columns = (
_("Unit"),
_("State"),
_("Source"),
_("Suggestion"),
_("Suggested by"),
_("Suggested at"),
_("Project"))
@property
def default_form_kwargs(self):
return dict(
page_no=1,
results_per_page=10)
def add_success_message(self, form):
count = (
form.fields["suggestions"].queryset.count()
if form.cleaned_data["select_all"]
else len(form.cleaned_data["suggestions"]))
reject_and_notify = (
form.cleaned_data["actions"] == "reject"
and form.cleaned_data["comment"])
accept_and_notify = (
form.cleaned_data["actions"] == "accept"
and form.cleaned_data["comment"])
if reject_and_notify:
message = ungettext_lazy(
"Rejected %s suggestion with comment. User will be notified",
"Rejected %s suggestions with comment. Users will be notified",
count, count)
elif accept_and_notify:
message = ungettext_lazy(
"Accepted %s suggestion with comment. User will be notified",
"Accepted %s suggestions with comment. Users will be notified",
count, count)
elif form.cleaned_data["actions"] == "reject":
message = ungettext_lazy(
"Rejected %s suggestion",
"Rejected %s suggestions",
count, count)
else:
message = ungettext_lazy(
"Accepted %s suggestion",
"Accepted %s suggestions",
count, count)
messages.success(self.request, message)
def get_context_data(self, **kwargs):
context = super(
LanguageSuggestionAdminView, self).get_context_data(**kwargs)
context["page"] = "admin-suggestions"
context["language"] = self.language
form = context["form"]
form.is_valid()
batch = form.batch()
form.fields["suggestions"].choices = [
(item.id, SuggestionDisplay(item))
for item in
batch.object_list]
context["formtable"] = SuggestionFormtable(
form,
columns=self.formtable_columns,
page=batch,
messages=messages.get_messages(self.request))
return context
def get_form_kwargs(self):
kwargs = super(LanguageSuggestionAdminView, self).get_form_kwargs()
if not self.request.POST:
kwargs["data"] = self.default_form_kwargs
kwargs["user"] = self.request.user
return kwargs
class LanguageTeamAdminFormView(PootleLanguageAdminFormView):
form_class = LanguageTeamAdminForm
template_name = "languages/admin/language_team.html"
success_url_pattern = "pootle-language-admin-team"
def get_context_data(self, **kwargs):
context = super(LanguageTeamAdminFormView, self).get_context_data(**kwargs)
form = context["form"]
context["tps"] = self.language.translationproject_set.exclude(
project__disabled=True)
stats = self.language.data_tool.get_stats(
include_children=False,
user=self.request.user)
keys = ("total", "critical", "incomplete", "translated", "fuzzy",
"untranslated")
for k in keys:
if k in stats:
stats[k + "_display"] = formatter.number(stats[k])
context["stats"] = stats
context["suggestions"] = form.language_team.suggestions.count()
context["suggestions_display"] = formatter.number(
context["suggestions"])
context["language"] = self.language
context["page"] = "admin-team"
context["browse_url"] = reverse(
"pootle-language-browse",
kwargs=dict(language_code=self.language.code))
context["translate_url"] = reverse(
"pootle-language-translate",
kwargs=dict(language_code=self.language.code))
return context
class LanguageTeamAdminNewMembersJSON(PootleJSONMixin, PootleLanguageAdminFormView):
form_class = LanguageTeamNewMemberSearchForm
def get_context_data(self, **kwargs):
context = super(
LanguageTeamAdminNewMembersJSON, self).get_context_data(**kwargs)
form = context["form"]
return (
dict(items=form.search())
if form.is_valid()
else dict(items=[]))
def get_form_kwargs(self):
kwargs = super(LanguageTeamAdminNewMembersJSON, self).get_form_kwargs()
kwargs["data"] = self.request.POST
return kwargs
def form_valid(self, form):
return self.render_to_response(
self.get_context_data(form=form))
def form_invalid(self, form):
raise Http400(form.errors)
| 11,376
|
Python
|
.py
| 284
| 31.450704
| 84
| 0.644404
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,435
|
0001_initial.py
|
translate_pootle/pootle/apps/pootle_language/migrations/0001_initial.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
import pootle.core.mixins.treeitem
class Migration(migrations.Migration):
dependencies = [
('pootle_app', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='Language',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('code', models.CharField(help_text='ISO 639 language code for the language, possibly followed by an underscore (_) and an ISO 3166 country code. <a href="http://www.w3.org/International/articles/language-tags/">More information</a>', unique=True, max_length=50, verbose_name='Code', db_index=True)),
('fullname', models.CharField(max_length=255, verbose_name='Full Name')),
('specialchars', models.CharField(help_text='Enter any special characters that users might find difficult to type', max_length=255, verbose_name='Special Characters', blank=True)),
('nplurals', models.SmallIntegerField(default=0, help_text='For more information, visit <a href="http://docs.translatehouse.org/projects/localization-guide/en/latest/l10n/pluralforms.html">our page</a> on plural forms.', verbose_name='Number of Plurals', choices=[(0, 'Unknown'), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)])),
('pluralequation', models.CharField(help_text='For more information, visit <a href="http://docs.translatehouse.org/projects/localization-guide/en/latest/l10n/pluralforms.html">our page</a> on plural forms.', max_length=255, verbose_name='Plural Equation', blank=True)),
('directory', models.OneToOneField(editable=False, to='pootle_app.Directory', on_delete=models.CASCADE)),
],
options={
'ordering': ['code'],
'db_table': 'pootle_app_language',
},
bases=(models.Model, pootle.core.mixins.treeitem.TreeItem),
),
]
| 2,056
|
Python
|
.py
| 27
| 65.481481
| 346
| 0.652668
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,436
|
0003_ensure_unique_special_chars.py
|
translate_pootle/pootle/apps/pootle_language/migrations/0003_ensure_unique_special_chars.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import logging
from django.db import migrations, models
logger = logging.getLogger(__name__)
def remove_duplicate_special_characters(apps, schema_editor):
Language = apps.get_model("pootle_language", "Language")
for language in Language.objects.exclude(specialchars__exact=u""):
special_chars = []
for special_char in language.specialchars:
if special_char in special_chars:
continue
special_chars.append(special_char)
if len(special_chars) < language.specialchars:
logger.info("Removed duplicate specialchars for %s" % language.code)
language.specialchars = u"".join(special_chars)
language.save()
class Migration(migrations.Migration):
dependencies = [
('pootle_language', '0002_case_insensitive_schema'),
]
operations = [
migrations.RunPython(remove_duplicate_special_characters),
]
| 992
|
Python
|
.py
| 24
| 34.416667
| 80
| 0.685804
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,437
|
0002_case_insensitive_schema.py
|
translate_pootle/pootle/apps/pootle_language/migrations/0002_case_insensitive_schema.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import migrations, models
from pootle.core.utils.db import set_mysql_collation_for_column
def make_lang_codes_ci(apps, schema_editor):
cursor = schema_editor.connection.cursor()
set_mysql_collation_for_column(
apps,
cursor,
"pootle_language.Language",
"code",
"utf8_general_ci",
"varchar(50)")
class Migration(migrations.Migration):
dependencies = [
('pootle_language', '0001_initial'),
]
operations = [
migrations.RunPython(make_lang_codes_ci),
]
| 623
|
Python
|
.py
| 20
| 25.35
| 63
| 0.662185
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,438
|
models.py
|
translate_pootle/pootle/apps/staticpages/models.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.conf import settings
from django.core.exceptions import ValidationError
from django.db import models
from django.db.models import Q
from django.db.models.aggregates import Max
from django.urls import reverse
from django.utils.timezone import now
from pootle.core.markup import MarkupField, get_markup_filter_display_name
from pootle.i18n.gettext import ugettext_lazy as _
from .managers import PageManager
ANN_TYPE = u'announcements'
ANN_VPATH = ANN_TYPE + u'/'
class AbstractPage(models.Model):
active = models.BooleanField(
_('Active'),
default=False,
help_text=_('Whether this page is active or not.'),
)
virtual_path = models.CharField(
_("Virtual Path"),
max_length=100,
default='',
unique=True,
help_text='/pages/',
)
# TODO: make title and body localizable fields
title = models.CharField(_("Title"), max_length=100)
body = MarkupField(
# Translators: Content that will be used to display this static page
_("Display Content"),
blank=True,
help_text=_('Allowed markup: %s', get_markup_filter_display_name()),
)
url = models.URLField(
_("Redirect to URL"),
blank=True,
help_text=_('If set, this page will redirect to this URL'),
)
modified_on = models.DateTimeField(
default=now,
editable=False,
)
objects = PageManager()
class Meta(object):
abstract = True
def __unicode__(self):
return self.virtual_path
def save(self, **kwargs):
# Update the `modified_on` timestamp only when specific fields change.
if self.pk is None or self.has_changes():
self.modified_on = now()
super(AbstractPage, self).save(**kwargs)
def get_absolute_url(self):
if self.url:
return self.url
return reverse('pootle-staticpages-display', args=[self.virtual_path])
@staticmethod
def max_pk():
"""Returns the sum of all the highest PKs for each submodel."""
return reduce(
lambda x, y: x + y,
[int(p.objects.aggregate(Max('pk')).values()[0] or 0)
for p in AbstractPage.__subclasses__()],
)
def clean(self):
"""Fail validation if:
- URL and body are blank
- Current virtual path exists in other page models
"""
if not self.url and not self.body:
# Translators: 'URL' and 'content' refer to form fields.
raise ValidationError(_('URL or content must be provided.'))
pages = [p.objects.filter(Q(virtual_path=self.virtual_path),
~Q(pk=self.pk),).exists() for p in
AbstractPage.__subclasses__()]
if True in pages:
raise ValidationError(_(u'Virtual path already in use.'))
def has_changes(self):
old_page = self.__class__.objects.get(pk=self.pk)
return any((getattr(old_page, field) != getattr(self, field))
for field in ('title', 'body', 'url'))
class LegalPage(AbstractPage):
display_name = _('Legal Page')
def localized_title(self):
return _(self.title)
def get_edit_url(self):
return reverse('pootle-staticpages-edit', args=['legal', self.pk])
class StaticPage(AbstractPage):
display_name = _('Regular Page')
@classmethod
def get_announcement_for(cls, pootle_path, user=None):
"""Return the announcement for the specified pootle path and user."""
virtual_path = ANN_VPATH + pootle_path.strip('/')
try:
return cls.objects.live(user).get(virtual_path=virtual_path)
except StaticPage.DoesNotExist:
return None
def get_edit_url(self):
page_type = 'static'
if self.virtual_path.startswith(ANN_VPATH):
page_type = ANN_TYPE
return reverse('pootle-staticpages-edit', args=[page_type, self.pk])
class Agreement(models.Model):
"""Tracks who agreed a specific legal document and when."""
user = models.ForeignKey(
settings.AUTH_USER_MODEL,
db_index=False,
on_delete=models.CASCADE)
document = models.ForeignKey(LegalPage, on_delete=models.CASCADE)
agreed_on = models.DateTimeField(
default=now,
editable=False,
)
class Meta(object):
unique_together = ('user', 'document',)
def __unicode__(self):
return u'%s (%s@%s)' % (self.document, self.user, self.agreed_on)
def save(self, **kwargs):
# When updating always explicitly renew agreement date
if self.pk:
self.agreed_on = now()
super(Agreement, self).save(**kwargs)
| 5,004
|
Python
|
.py
| 129
| 31.310078
| 78
| 0.63766
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,439
|
urls.py
|
translate_pootle/pootle/apps/staticpages/urls.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.conf.urls import include, url
from .views import (AdminTemplateView, PageCreateView, PageDeleteView,
PageUpdateView, display_page, legal_agreement,
preview_content)
page_patterns = [
url(r'^legal/agreement/$',
legal_agreement,
name='pootle-staticpages-legal-agreement'),
url(r'^(?P<virtual_path>.+)/$',
display_page,
name='pootle-staticpages-display'),
]
admin_patterns = [
url(r'^$',
AdminTemplateView.as_view(),
name='pootle-staticpages'),
url(r'^(?P<page_type>[^/]+)/add/?$',
PageCreateView.as_view(),
name='pootle-staticpages-create'),
url(r'^(?P<page_type>[^/]+)/(?P<pk>\d+)/?$',
PageUpdateView.as_view(),
name='pootle-staticpages-edit'),
url(r'^(?P<page_type>[^/]+)/(?P<pk>\d+)/delete/?$',
PageDeleteView.as_view(),
name='pootle-staticpages-delete'),
]
xhr_patterns = [
url(r'^preview/?$',
preview_content,
name='pootle-xhr-preview'),
]
urlpatterns = [
url(r'^pages/',
include(page_patterns)),
url(r'^xhr/',
include(xhr_patterns)),
]
| 1,441
|
Python
|
.py
| 44
| 26.886364
| 77
| 0.619322
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,440
|
forms.py
|
translate_pootle/pootle/apps/staticpages/forms.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django import forms
from django.urls import reverse
from django.utils.safestring import mark_safe
from pootle.i18n.gettext import ugettext_lazy as _
from .models import Agreement
def agreement_form_factory(pages, user):
"""Factory that builds an agreement form.
:param pages: Legal pages that need to be accepted by users.
:param user: User bound to the agreement form.
:return: An `AgreementForm` class with `pages` as required checkboxes.
"""
class AgreementForm(forms.Form):
def __init__(self, *args, **kwargs):
kwargs.setdefault('label_suffix', '')
super(AgreementForm, self).__init__(*args, **kwargs)
self._pages = pages
self._user = user
for page in self._pages:
self.add_page_field(page)
def save(self, **kwargs):
"""Saves user agreements."""
for page in self._pages:
agreement = Agreement.objects.get_or_create(
user=self._user, document=page,
)[0]
agreement.save()
def legal_fields(self):
"""Returns any fields added by legal pages."""
return [field for field in self
if field.name.startswith('legal_')]
def add_page_field(self, page):
"""Adds `page` as a required field to this form."""
url = page.url and page.url or \
reverse('pootle-staticpages-display', args=[page.virtual_path])
label_params = {
'url': url,
'classes': 'js-agreement-popup',
'title': page.title,
}
label = mark_safe(_('I have read and accept: <a href="%(url)s" '
'class="%(classes)s">%(title)s</a>',
label_params))
field_name = 'legal_%d' % page.pk
self.fields[field_name] = forms.BooleanField(label=label,
required=True)
self.fields[field_name].widget.attrs['class'] = 'js-legalfield'
return AgreementForm
| 2,435
|
Python
|
.py
| 54
| 33.592593
| 79
| 0.574989
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,441
|
views.py
|
translate_pootle/pootle/apps/staticpages/views.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.core.exceptions import ObjectDoesNotExist
from django.http import Http404
from django.shortcuts import redirect, render
from django.template.loader import get_template
from django.urls import reverse_lazy
from django.views.generic import (CreateView, DeleteView, TemplateView,
UpdateView)
from pootle.core.http import JsonResponse, JsonResponseBadRequest
from pootle.core.markup.filters import apply_markup_filter
from pootle.core.views.mixins import SuperuserRequiredMixin
from pootle.i18n.gettext import ugettext_lazy as _
from pootle_misc.util import ajax_required
from .forms import agreement_form_factory
from .models import ANN_TYPE, ANN_VPATH, AbstractPage, LegalPage, StaticPage
class PageModelMixin(object):
"""Mixin used to set the view's page model according to the
`page_type` argument caught in a url pattern.
"""
def dispatch(self, request, *args, **kwargs):
self.page_type = kwargs.get('page_type', None)
self.model = {
'legal': LegalPage,
'static': StaticPage,
ANN_TYPE: StaticPage,
}.get(self.page_type)
if self.model is None:
raise Http404
return super(PageModelMixin, self).dispatch(request, *args, **kwargs)
def get_context_data(self, **kwargs):
ctx = super(PageModelMixin, self).get_context_data(**kwargs)
ctx.update({
'has_page_model': True,
'page_display_name': self.model.display_name,
})
return ctx
def get_form_kwargs(self):
kwargs = super(PageModelMixin, self).get_form_kwargs()
kwargs.update({'label_suffix': ''})
return kwargs
def get_form(self, form_class=None):
form = super(PageModelMixin, self).get_form(form_class)
if self.page_type == ANN_TYPE:
form.fields['virtual_path'].help_text = u'/pages/' + ANN_VPATH
return form
def form_valid(self, form):
if (self.page_type == ANN_TYPE and not
form.cleaned_data['virtual_path'].startswith(ANN_VPATH)):
orig_vpath = form.cleaned_data['virtual_path']
form.instance.virtual_path = ANN_VPATH + orig_vpath
return super(PageModelMixin, self).form_valid(form)
class AdminCtxMixin(object):
def get_context_data(self, **kwargs):
ctx = super(AdminCtxMixin, self).get_context_data(**kwargs)
ctx.update({
'page': 'admin-pages',
})
return ctx
class AdminTemplateView(SuperuserRequiredMixin, AdminCtxMixin, TemplateView):
template_name = 'admin/staticpages/page_list.html'
def get_context_data(self, **kwargs):
legal_pages = LegalPage.objects.all()
static_pages = StaticPage.objects.exclude(
virtual_path__startswith=ANN_VPATH,
)
announcements = StaticPage.objects.filter(
virtual_path__startswith=ANN_VPATH,
)
ctx = super(AdminTemplateView, self).get_context_data(**kwargs)
ctx.update({
'legalpages': legal_pages,
'staticpages': static_pages,
ANN_TYPE: announcements,
})
return ctx
class PageCreateView(SuperuserRequiredMixin, AdminCtxMixin, PageModelMixin,
CreateView):
fields = ('title', 'virtual_path', 'active', 'url', 'body')
success_url = reverse_lazy('pootle-staticpages')
template_name = 'admin/staticpages/page_create.html'
def get_initial(self):
initial = super(PageModelMixin, self).get_initial()
initial_args = {
'title': _('Page Title'),
}
if self.page_type != ANN_TYPE:
next_page_number = AbstractPage.max_pk() + 1
initial_args['virtual_path'] = 'page-%d' % next_page_number
initial.update(initial_args)
return initial
def get_form(self, form_class=None):
form = super(PageCreateView, self).get_form(form_class)
if self.page_type == ANN_TYPE:
del form.fields['url']
# Translators: 'projects' must not be translated.
msg = _(u'projects/<project_code> or <language_code> or '
u'<language_code>/<project_code>')
form.fields['virtual_path'].widget.attrs['placeholder'] = msg
form.fields['virtual_path'].widget.attrs['size'] = 100
return form
class PageUpdateView(SuperuserRequiredMixin, AdminCtxMixin, PageModelMixin,
UpdateView):
fields = ('title', 'virtual_path', 'active', 'url', 'body')
success_url = reverse_lazy('pootle-staticpages')
template_name = 'admin/staticpages/page_update.html'
def get_context_data(self, **kwargs):
ctx = super(PageUpdateView, self).get_context_data(**kwargs)
ctx.update({
'show_delete': True,
'page_type': self.page_type,
})
return ctx
def get_form_kwargs(self):
kwargs = super(PageUpdateView, self).get_form_kwargs()
if self.page_type == ANN_TYPE:
orig_vpath = self.object.virtual_path
self.object.virtual_path = orig_vpath.replace(ANN_VPATH, '')
kwargs.update({'instance': self.object})
return kwargs
class PageDeleteView(SuperuserRequiredMixin, PageModelMixin, DeleteView):
success_url = reverse_lazy('pootle-staticpages')
def display_page(request, virtual_path):
"""Displays an active page defined in `virtual_path`."""
page = None
for page_model in AbstractPage.__subclasses__():
try:
page = page_model.objects.live(
request.user).get(virtual_path=virtual_path,)
except ObjectDoesNotExist:
pass
if page is None:
raise Http404
if page.url:
return redirect(page.url)
template_name = 'staticpages/page_display.html'
if request.is_ajax():
template_name = 'staticpages/_body.html'
ctx = {
'page': page,
}
return render(request, template_name, ctx)
def _get_rendered_agreement(request, form):
template = get_template('staticpages/agreement.html')
return template.render(context={'form': form}, request=request)
@ajax_required
def legal_agreement(request):
"""Displays the pending documents to be agreed by the current user."""
pending_pages = LegalPage.objects.pending_user_agreement(request.user)
form_class = agreement_form_factory(pending_pages, request.user)
if request.method == 'POST':
form = form_class(request.POST)
if form.is_valid():
form.save()
return JsonResponse({})
rendered_form = _get_rendered_agreement(request, form)
return JsonResponseBadRequest({'form': rendered_form})
rendered_form = _get_rendered_agreement(request, form_class())
return JsonResponse({'form': rendered_form})
@ajax_required
def preview_content(request):
"""Returns content rendered based on the configured markup settings."""
if 'text' not in request.POST:
return JsonResponseBadRequest({
'msg': _('Text is missing'),
})
return JsonResponse({
'rendered': apply_markup_filter(request.POST['text']),
})
| 7,513
|
Python
|
.py
| 174
| 35.114943
| 77
| 0.655675
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,442
|
managers.py
|
translate_pootle/pootle/apps/staticpages/managers.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.db.models import Manager
class PageManager(Manager):
def live(self, user=None, **kwargs):
"""Filters active (live) pages.
:param user: Current active user. If omitted or the user doesn't
have administration privileges, only active pages will be
returned.
"""
if user is not None and user.is_superuser:
return self.get_queryset()
return self.get_queryset().filter(active=True)
def has_pending_agreement(self, user):
agreements = self.pending_user_agreement(user)
return len(list(agreements)) > 0
def pending_user_agreement(self, user, **kwargs):
"""Filters active pages where the given `user` has pending
agreements.
"""
# FIXME: This should be a method exclusive to a LegalPage manager
return self.raw('''
SELECT DISTINCT staticpages_legalpage.id
FROM staticpages_legalpage
WHERE (staticpages_legalpage.active = %s
AND NOT (staticpages_legalpage.id IN
(SELECT A.document_id
FROM staticpages_legalpage AS LP
INNER JOIN staticpages_agreement AS A
ON LP.id = A.document_id
WHERE A.user_id = %s AND
A.agreed_on > LP.modified_on)))
''', [True, user.id])
| 1,735
|
Python
|
.py
| 38
| 34.157895
| 77
| 0.599763
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,443
|
staticpages.py
|
translate_pootle/pootle/apps/staticpages/templatetags/staticpages.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django import template
from django.urls import reverse
from ..models import LegalPage
register = template.Library()
class LegalPageNode(template.Node):
def __init__(self, context_name):
self.context_name = context_name
def render(self, context):
lps = LegalPage.objects.live().all()
context[self.context_name] = lps
return ''
@register.tag
def get_legalpages(parser, token):
"""
Retrieves all active LegalPage objects.
Populates the template context with them in a variable
whose name is defined by the ``as`` clause.
Syntax::
{% get_legalpages as context_name %}
"""
bits = token.split_contents()
syntax_message = ("%(tag_name)s expects a syntax of %(tag_name)s "
"as context_name" %
dict(tag_name=bits[0]))
if len(bits) == 3:
if bits[1] != 'as':
raise template.TemplateSyntaxError(syntax_message)
context_name = bits[2]
return LegalPageNode(context_name)
else:
raise template.TemplateSyntaxError(syntax_message)
@register.tag
def staticpage_url(parser, token):
"""Returns the internal URL for a static page based on its virtual path.
Syntax::
{% staticpage_url 'virtual/path' %}
"""
bits = token.split_contents()
syntax_message = ("%(tag_name)s expects a syntax of %(tag_name)s "
"'virtual/path'" %
dict(tag_name=bits[0]))
quote_message = "%s tag's argument should be in quotes" % bits[0]
if len(bits) == 2:
virtual_path = bits[1]
if (not (virtual_path[0] == virtual_path[-1] and
virtual_path[0] in ('"', "'"))):
raise template.TemplateSyntaxError(quote_message)
return StaticPageURLNode(virtual_path[1:-1])
raise template.TemplateSyntaxError(syntax_message)
class StaticPageURLNode(template.Node):
def __init__(self, virtual_path):
self.virtual_path = virtual_path
def render(self, context):
return reverse('pootle-staticpages-display', args=[self.virtual_path])
| 2,412
|
Python
|
.py
| 61
| 32.540984
| 78
| 0.650732
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,444
|
0003_remove_extra_indeces.py
|
translate_pootle/pootle/apps/staticpages/migrations/0003_remove_extra_indeces.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.7 on 2017-06-02 16:56
from __future__ import unicode_literals
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('staticpages', '0002_change_url_field_help_text'),
]
operations = [
migrations.AlterField(
model_name='agreement',
name='user',
field=models.ForeignKey(db_index=False, on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL),
),
]
| 606
|
Python
|
.py
| 17
| 29.882353
| 126
| 0.679795
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,445
|
0002_change_url_field_help_text.py
|
translate_pootle/pootle/apps/staticpages/migrations/0002_change_url_field_help_text.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
class Migration(migrations.Migration):
dependencies = [
('staticpages', '0001_initial'),
]
operations = [
migrations.AlterField(
model_name='legalpage',
name='url',
field=models.URLField(help_text='If set, this page will redirect to this URL', verbose_name='Redirect to URL', blank=True),
preserve_default=True,
),
migrations.AlterField(
model_name='staticpage',
name='url',
field=models.URLField(help_text='If set, this page will redirect to this URL', verbose_name='Redirect to URL', blank=True),
preserve_default=True,
),
]
| 789
|
Python
|
.py
| 21
| 29.095238
| 135
| 0.614679
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,446
|
0001_initial.py
|
translate_pootle/pootle/apps/staticpages/migrations/0001_initial.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
import pootle.core.markup.fields
import django.utils.timezone
from django.conf import settings
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='LegalPage',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('active', models.BooleanField(default=False, help_text='Whether this page is active or not.', verbose_name='Active')),
('virtual_path', models.CharField(default='', help_text='/pages/', unique=True, max_length=100, verbose_name='Virtual Path')),
('title', models.CharField(max_length=100, verbose_name='Title')),
('body', pootle.core.markup.fields.MarkupField(help_text='Allowed markup: HTML', verbose_name='Display Content', blank=True)),
('url', models.URLField(help_text='If set, any references to this page will redirect to this URL', verbose_name='Redirect to URL', blank=True)),
('modified_on', models.DateTimeField(default=django.utils.timezone.now, editable=False)),
],
options={
'abstract': False,
},
bases=(models.Model,),
),
migrations.CreateModel(
name='StaticPage',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('active', models.BooleanField(default=False, help_text='Whether this page is active or not.', verbose_name='Active')),
('virtual_path', models.CharField(default='', help_text='/pages/', unique=True, max_length=100, verbose_name='Virtual Path')),
('title', models.CharField(max_length=100, verbose_name='Title')),
('body', pootle.core.markup.fields.MarkupField(help_text='Allowed markup: HTML', verbose_name='Display Content', blank=True)),
('url', models.URLField(help_text='If set, any references to this page will redirect to this URL', verbose_name='Redirect to URL', blank=True)),
('modified_on', models.DateTimeField(default=django.utils.timezone.now, editable=False)),
],
options={
'abstract': False,
},
bases=(models.Model,),
),
migrations.CreateModel(
name='Agreement',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('agreed_on', models.DateTimeField(default=django.utils.timezone.now, editable=False)),
('document', models.ForeignKey(to='staticpages.LegalPage', on_delete=models.CASCADE)),
('user', models.ForeignKey(to=settings.AUTH_USER_MODEL, on_delete=models.CASCADE)),
],
options={
},
bases=(models.Model,),
),
migrations.AlterUniqueTogether(
name='agreement',
unique_together=set([('user', 'document')]),
),
]
| 3,311
|
Python
|
.py
| 60
| 43.3
| 160
| 0.606593
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,447
|
models.py
|
translate_pootle/pootle/apps/pootle_score/models.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.conf import settings
from django.db import models
from .abstracts import AbstractUserScore
class UserStoreScore(AbstractUserScore):
class Meta(AbstractUserScore.Meta):
db_table = "pootle_user_store_score"
unique_together = ["date", "store", "user"]
user = models.ForeignKey(
settings.AUTH_USER_MODEL,
null=False,
related_name='store_scores',
db_index=True,
on_delete=models.CASCADE)
store = models.ForeignKey(
"pootle_store.Store",
on_delete=models.CASCADE,
db_index=True,
related_name="user_scores")
@property
def context(self):
return self.store
class UserTPScore(AbstractUserScore):
class Meta(AbstractUserScore.Meta):
db_table = "pootle_user_tp_score"
unique_together = ["date", "tp", "user"]
tp = models.ForeignKey(
"pootle_translationproject.TranslationProject",
on_delete=models.CASCADE,
db_index=True,
related_name="user_scores")
@property
def context(self):
return self.tp
| 1,370
|
Python
|
.py
| 40
| 28.225
| 77
| 0.682612
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,448
|
getters.py
|
translate_pootle/pootle/apps/pootle_score/getters.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.contrib.auth import get_user_model
from pootle.core.delegate import crud, display, score_updater, scores
from pootle.core.plugin import getter
from pootle_language.models import Language
from pootle_project.models import Project, ProjectSet
from pootle_store.models import Store
from pootle_translationproject.models import TranslationProject
from .display import TopScoreDisplay
from .models import UserStoreScore, UserTPScore
from .updater import (
StoreScoreUpdater, TPScoreUpdater, UserScoreUpdater, UserStoreScoreCRUD,
UserTPScoreCRUD)
from .utils import (
LanguageScores, ProjectScores, ProjectSetScores, Scores, TPScores,
UserScores)
User = get_user_model()
CRUD = {
UserStoreScore: UserStoreScoreCRUD(),
UserTPScore: UserTPScoreCRUD()}
@getter(crud, sender=(UserStoreScore, UserTPScore))
def data_crud_getter(**kwargs):
return CRUD[kwargs["sender"]]
@getter(display, sender=Scores)
def get_scores_display(**kwargs_):
return TopScoreDisplay
@getter(scores, sender=Language)
def get_language_scores(**kwargs_):
return LanguageScores
@getter(scores, sender=Project)
def get_project_scores(**kwargs_):
return ProjectScores
@getter(scores, sender=ProjectSet)
def get_projectset_scores(**kwargs_):
return ProjectSetScores
@getter(scores, sender=TranslationProject)
def get_tp_scores(**kwargs_):
return TPScores
@getter(scores, sender=User)
def get_user_scores(**kwargs_):
return UserScores
@getter(score_updater, sender=Store)
def score_updater_getter(**kwargs_):
return StoreScoreUpdater
@getter(score_updater, sender=TranslationProject)
def tp_score_updater_getter(**kwargs_):
return TPScoreUpdater
@getter(score_updater, sender=get_user_model())
def users_score_updater_getter(**kwargs_):
return UserScoreUpdater
| 2,095
|
Python
|
.py
| 56
| 34.803571
| 77
| 0.794834
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,449
|
abstracts.py
|
translate_pootle/pootle/apps/pootle_score/abstracts.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.conf import settings
from django.db import models
class AbstractUserScore(models.Model):
class Meta(object):
abstract = True
user = models.ForeignKey(
settings.AUTH_USER_MODEL,
null=False,
related_name='scores',
db_index=True,
on_delete=models.CASCADE)
date = models.DateField(
null=False,
blank=False,
auto_now=False,
db_index=False)
score = models.FloatField(
null=False,
blank=False,
default=0,
db_index=True)
reviewed = models.IntegerField(
null=False,
blank=False,
default=0,
db_index=True)
suggested = models.IntegerField(
null=False,
blank=False,
default=0,
db_index=True)
translated = models.IntegerField(
null=False,
blank=False,
default=0,
db_index=True)
def __str__(self):
return (
"%s(%s) %s score: %s, suggested: %s, translated: %s, reviewed: %s"
% (self.user.username,
self.context.pootle_path,
self.date,
self.score,
self.suggested,
self.translated,
self.reviewed))
| 1,536
|
Python
|
.py
| 53
| 21.037736
| 78
| 0.593771
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,450
|
apps.py
|
translate_pootle/pootle/apps/pootle_score/apps.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import importlib
from django.apps import AppConfig
class PootleScoreConfig(AppConfig):
name = "pootle_score"
verbose_name = "Pootle Score"
version = "0.1.2"
def ready(self):
importlib.import_module("pootle_score.getters")
importlib.import_module("pootle_score.providers")
importlib.import_module("pootle_score.receivers")
| 643
|
Python
|
.py
| 17
| 34.117647
| 77
| 0.737097
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,451
|
display.py
|
translate_pootle/pootle/apps/pootle_score/display.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from accounts.proxy import DisplayUser
from pootle.i18n import formatter
class TopScoreDisplay(object):
def __init__(self, top_scores, language=None, formatter=None):
self.top_scores = top_scores
self.language = language
self.formatter = formatter
def format_score(self, score):
if self.formatter:
return self.formatter(score)
return score
def __iter__(self):
for score in self.top_scores:
score_data = dict(
user=DisplayUser(
score["user__username"],
score["user__full_name"],
score["user__email"]),
total_score=score["score__sum"],
public_total_score=formatter.number(
int(round(score["score__sum"]))))
for k in ["translated", "reviewed", "suggested"]:
score_data[k] = formatter.number(
int(round(score["%s__sum" % k])))
yield self.format_score(score_data)
| 1,312
|
Python
|
.py
| 32
| 31.3125
| 77
| 0.598901
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,452
|
receivers.py
|
translate_pootle/pootle/apps/pootle_score/receivers.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.contrib.auth import get_user_model
from django.db.models.signals import post_save
from django.dispatch import receiver
from pootle.core.delegate import crud, score_updater
from pootle.core.signals import create, update, update_scores
from pootle.core.utils.timezone import localdate
from pootle_statistics.models import Submission
from pootle_store.models import Store, Suggestion
from pootle_translationproject.models import TranslationProject
from .models import UserStoreScore, UserTPScore
@receiver(update, sender=UserStoreScore)
def handle_store_score_update(**kwargs):
crud.get(UserStoreScore).update(**kwargs)
@receiver(create, sender=UserStoreScore)
def handle_user_store_score_create(**kwargs):
crud.get(UserStoreScore).create(**kwargs)
@receiver(update, sender=UserTPScore)
def handle_user_tp_score_update(**kwargs):
crud.get(UserTPScore).update(**kwargs)
@receiver(create, sender=UserTPScore)
def handle_user_tp_score_create(**kwargs):
crud.get(UserTPScore).create(**kwargs)
@receiver(update_scores, sender=get_user_model())
def update_user_scores_handler(**kwargs):
score_updater.get(get_user_model())().update(
users=kwargs.get("users"),
date=kwargs.get("date"))
@receiver(update_scores, sender=TranslationProject)
def update_tp_scores_handler(**kwargs):
tp = kwargs["instance"]
score_updater.get(tp.__class__)(tp).update(
users=kwargs.get("users"),
date=kwargs.get("date"))
@receiver(update_scores, sender=Store)
def update_store_scores_handler(**kwargs):
store = kwargs["instance"]
score_updater.get(store.__class__)(store).update(
users=kwargs.get("users"),
date=kwargs.get("date"))
@receiver(post_save, sender=UserStoreScore)
def handle_store_score_updated(**kwargs):
tp = kwargs["instance"].store.translation_project
update_scores.send(
tp.__class__,
instance=tp,
users=[kwargs["instance"].user_id],
date=kwargs["instance"].date)
@receiver(post_save, sender=Suggestion)
def handle_suggestion_change(**kwargs):
suggestion = kwargs["instance"]
is_system_user = (
(suggestion.is_pending
and (suggestion.user_id
== get_user_model().objects.get_system_user().id))
or (not suggestion.is_pending
and (suggestion.reviewer_id
== get_user_model().objects.get_system_user().id)))
if is_system_user:
return
change_date = (
suggestion.review_time
if not suggestion.is_pending
else suggestion.creation_time)
update_scores.send(
suggestion.unit.store.__class__,
instance=suggestion.unit.store,
users=[
suggestion.user_id
if suggestion.is_pending
else suggestion.reviewer_id],
date=localdate(change_date))
@receiver(post_save, sender=Submission)
def handle_submission_added(**kwargs):
submission = kwargs["instance"]
is_system_user = (
submission.submitter
== get_user_model().objects.get_system_user())
if is_system_user:
return
update_scores.send(
submission.unit.store.__class__,
instance=submission.unit.store,
users=[submission.submitter_id],
date=localdate(submission.creation_time))
| 3,586
|
Python
|
.py
| 91
| 33.934066
| 77
| 0.708525
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,453
|
utils.py
|
translate_pootle/pootle/apps/pootle_score/utils.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from datetime import date, datetime, timedelta
import pytz
from django.contrib.auth import get_user_model
from django.db.models import Sum
from django.utils.functional import cached_property
from pootle.core.decorators import persistent_property
from pootle.core.delegate import display, revision, scores
from pootle.core.utils.timezone import localdate, make_aware
from pootle_app.models import Directory
from pootle_language.models import Language
from .apps import PootleScoreConfig
from .models import UserTPScore
User = get_user_model()
def to_datetime(possible_dt):
if possible_dt is None:
return
if isinstance(possible_dt, datetime):
return possible_dt
if isinstance(possible_dt, date):
return make_aware(
datetime.combine(
possible_dt,
datetime.min.time())).astimezone(
pytz.timezone("UTC"))
class Scores(object):
ns = "pootle.score"
sw_version = PootleScoreConfig.version
def __init__(self, context):
self.context = context
@property
def revision(self):
return revision.get(Directory)(
self.context.directory).get(key="stats")
@property
def score_model(self):
return UserTPScore.objects.exclude(
user__username__in=User.objects.META_USERS)
def get_daterange(self, days):
now = localdate()
return now - timedelta(days), now
def scores_within_days(self, days):
return self.score_model.filter(
date__range=self.get_daterange(days))
def get_scores(self, days):
return self.filter_scores(self.scores_within_days(days))
def get_top_scorers(self, days=30):
"""Returns users with the top scores.
:param days: period of days to account for scores.
"""
return self.get_scores(days).order_by("user__username").values(
"user__username", "user__email", "user__full_name").annotate(
Sum("score"),
Sum("suggested"),
Sum("reviewed"),
Sum("translated")).filter(
score__sum__gt=0).order_by("-score__sum")
def filter_scores(self, qs):
return qs
@persistent_property
def top_scorers(self):
return tuple(self.get_top_scorers())
def display(self, offset=0, limit=5, language=None, formatter=None):
scorers = self.top_scorers
if offset or limit:
scorers = list(scorers)
if offset:
scorers = scorers[offset:]
if limit:
scorers = scorers[:limit]
return display.get(Scores)(
top_scores=scorers,
formatter=formatter,
language=language)
class LanguageScores(Scores):
ns = "pootle.score.language"
@cached_property
def cache_key(self):
return (
"%s.%s.%s"
% (self.context.code,
localdate(),
self.revision))
def filter_scores(self, qs):
return qs.filter(tp__language_id=self.context.id)
class ProjectScores(Scores):
ns = "pootle.score.project"
@cached_property
def cache_key(self):
return (
"%s.%s.%s"
% (self.context.code,
localdate(),
self.revision))
def filter_scores(self, qs):
return qs.filter(tp__project_id=self.context.id)
class ProjectSetScores(Scores):
ns = "pootle.score.projects"
@cached_property
def cache_key(self):
return (
"%s.%s"
% (localdate(),
self.revision))
class TPScores(Scores):
ns = "pootle.score.tp"
@cached_property
def cache_key(self):
return (
"%s/%s.%s.%s"
% (self.context.language.code,
self.context.project.code,
localdate(),
self.revision))
def filter_scores(self, qs):
return qs.filter(tp_id=self.context.id)
class UserScores(Scores):
ns = "pootle.score.user"
@cached_property
def cache_key(self):
return (
"%s.%s.%s"
% (self.context.id,
localdate(),
self.revision))
@property
def revision(self):
return revision.get(Directory)(
Directory.objects.projects).get(key="stats")
@property
def score_model(self):
return self.context.scores
@property
def public_score(self):
return self.context.public_score
@persistent_property
def top_language(self):
return self.get_top_language()
def get_top_language_within(self, days):
top_lang = self.get_scores_by_language(
days).order_by("score__sum").first()
if top_lang:
return Language.objects.get(id=top_lang["tp__language"])
def get_scores_by_language(self, days):
"""Languages that the user has contributed to in the last `days`,
and the summary score
"""
return self.get_scores(days).order_by(
"tp__language").values("tp__language").annotate(Sum("score"))
def get_language_top_scores(self, language):
return scores.get(language.__class__)(language).top_scorers
def get_top_language(self, days=30):
"""Returns the top language the user has contributed to and its
position.
"Top language" is defined as the language with the highest
aggregate score delta within the last `days` days.
:param days: period of days to account for scores.
:return: Tuple of `(position, Language)`. If there's no delta in
the score for the given period for any of the languages,
`(-1, None)` is returned.
"""
language = self.get_top_language_within(days)
if language:
# this only gets scores for the last 30 days as that is cached
language_scores = self.get_language_top_scores(language)
for index, user_score in enumerate(language_scores):
if user_score['user__username'] == self.context.username:
return index + 1, language
return -1, language
| 6,475
|
Python
|
.py
| 175
| 28.434286
| 77
| 0.62192
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,454
|
__init__.py
|
translate_pootle/pootle/apps/pootle_score/__init__.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
default_app_config = 'pootle_score.apps.PootleScoreConfig'
| 335
|
Python
|
.py
| 8
| 40.75
| 77
| 0.766871
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,455
|
updater.py
|
translate_pootle/pootle/apps/pootle_score/updater.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from datetime import timedelta
from django.contrib.auth import get_user_model
from django.db.models import Sum
from django.utils.functional import cached_property
from pootle.core.bulk import BulkCRUD
from pootle.core.contextmanagers import bulk_operations, keep_data
from pootle.core.delegate import event_score, log, score_updater
from pootle.core.signals import create, update, update_scores
from pootle.core.utils.timezone import localdate
from pootle_log.utils import LogEvent
from pootle_score.models import UserStoreScore, UserTPScore
from pootle_translationproject.models import TranslationProject
from .utils import to_datetime
class UserRelatedScoreCRUD(BulkCRUD):
def post_create(self, **kwargs):
if "objects" in kwargs and kwargs["objects"] is not None:
self.update_scores(kwargs["objects"])
def post_update(self, **kwargs):
if "objects" in kwargs and kwargs["objects"] is not None:
self.update_scores(kwargs["objects"])
class UserStoreScoreCRUD(UserRelatedScoreCRUD):
model = UserStoreScore
def select_for_update(self, qs):
return qs.select_related("store", "store__translation_project")
def update_scores(self, objects):
tps = {}
if not isinstance(objects, list):
scores = objects.select_related(
"user", "store", "store__translation_project")
else:
scores = objects
for score in scores:
tp = score.store.translation_project
tps[tp.id] = tps.get(tp.id, dict(tp=tp, stores=[], users=[]))
tps[tp.id]["stores"].append(score.store)
tps[tp.id]["users"].append(score.user)
for tp in tps.values():
update_scores.send(
tp["tp"].__class__,
instance=tp["tp"],
stores=tp["stores"],
users=tp["users"])
class UserTPScoreCRUD(UserRelatedScoreCRUD):
model = UserTPScore
def select_for_update(self, qs):
return qs.select_related("tp")
def update_scores(self, objects):
users = (
set(user
for user
in objects.values_list("user_id", flat=True))
if not isinstance(objects, list)
else set(x.user_id for x in objects))
update_scores.send(
get_user_model(),
users=users)
class ScoreUpdater(object):
event_class = LogEvent
related_object = None
def __init__(self, context, *args, **kwargs):
self.context = context
@cached_property
def logs(self):
return log.get(self.context.__class__)(self.context)
@cached_property
def scoring(self):
return event_score.gather(self.event_class)
def set_scores(self, calculated_scores, existing=None):
calculated_scores = list(self.iterate_scores(calculated_scores))
score_dict = {
(score[0], score[1]): score[2]
for score
in calculated_scores}
updates = {}
if existing:
scores = existing
else:
scores = self.find_existing_scores(calculated_scores) or []
for score in scores:
id, date, user, score, reviewed, suggested, translated = score
newscore = score_dict.get((date, user), None)
if newscore is None:
# delete ?
continue
oldscore = dict(
score=score,
reviewed=reviewed,
translated=translated,
suggested=suggested)
for k in ["score", "suggested", "reviewed", "translated"]:
_newscore = round(newscore.get(k, 0), 2)
if round(oldscore[k], 2) != _newscore:
updates[id] = updates.get(id, {})
updates[id][k] = _newscore
del score_dict[(date, user)]
if updates:
update.send(
self.score_model,
updates=updates)
if score_dict:
self.create_scores(score_dict)
def filter_users(self, qs, users):
field = "user_id"
if not users:
return qs
return (
qs.filter(**{field: list(users).pop()})
if len(users) == 1
else qs.filter(**{"%s__in" % field: users}))
def find_existing_scores(self, scores):
existing_scores = self.score_model.objects.none()
users = set()
tstamps = set()
for timestamp, user, user_scores in scores:
users.add(user)
tstamps.add(timestamp)
if not users and not tstamps:
return
existing_scores = self.score_model.objects.filter(
user__in=users)
existing_scores = existing_scores.filter(
date__in=tstamps)
existing_scores = existing_scores.filter(
**{self.related_field: self.context.pk})
return existing_scores.values_list(
"id",
"date",
"user_id",
"score",
"reviewed",
"suggested",
"translated").iterator()
def new_scores(self, scores):
for (timestamp, user), user_scores in scores.items():
created = self.score_model(
date=timestamp,
user_id=user,
**user_scores)
if self.related_object:
setattr(created, self.related_object, self.context)
yield created
def create_scores(self, scores):
created = list(self.new_scores(scores))
create.send(
self.score_model,
objects=created)
return created
def update(self, users=None, existing=None, date=None):
if date is not None:
start = date
end = date + timedelta(days=1)
else:
start = end = None
return self.set_scores(
self.calculate(users=users, start=start, end=end),
existing=existing)
def get_tp_scores(self):
tp_scores = self.tp_score_model.objects.order_by("tp_id").values_list(
"tp_id",
"id",
"date",
"user_id",
"score",
"reviewed",
"suggested",
"translated")
scores = {}
for tp_score in tp_scores.iterator():
tp = tp_score[0]
scores[tp] = scores.get(tp, [])
scores[tp].append(tp_score[1:])
return scores
def get_store_scores(self, tp):
store_scores = self.store_score_model.objects.filter(
store__translation_project_id=tp.id).order_by("store_id").values_list(
"store_id",
"id",
"date",
"user_id",
"score",
"reviewed",
"suggested",
"translated")
scores = {}
for store_score in store_scores.iterator():
store = store_score[0]
scores[store] = scores.get(store, [])
scores[store].append(store_score[1:])
return scores
class StoreScoreUpdater(ScoreUpdater):
score_model = UserStoreScore
related_field = "store_id"
related_object = "store"
def __init__(self, *args, **kwargs):
self.user = kwargs.get('user')
super(StoreScoreUpdater, self).__init__(*args, **kwargs)
@property
def store(self):
return self.context
def score_event(self, event, calculated_scores):
if event.action not in self.scoring:
return
scores = self.scoring[event.action](event).get_score()
if not scores or not any(x > 0 for x in scores.values()):
return
event_date = localdate(event.timestamp)
calculated_scores[event_date] = (
calculated_scores.get(event_date, {}))
calculated_scores[event_date][event.user.id] = (
calculated_scores[event_date].get(event.user.id, {}))
for k, score in scores.items():
if not score:
continue
calculated_scores[event_date][event.user.id][k] = (
calculated_scores[event_date][event.user.id].get(k, 0)
+ score)
def calculate(self, start=None, end=None, users=None):
calculated_scores = {}
scored_events = self.logs.get_events(
users=users,
start=to_datetime(start),
end=to_datetime(end),
include_meta=False,
ordered=False,
only=dict(
suggestion=(
"unit__unit_source__source_wordcount",
"user_id",
"reviewer_id",
"state_id",),
submission=(
"unit__unit_source__source_wordcount",
"unit__unit_source__created_by_id",
"unit_id",
"submitter__id",
"old_value",
"new_value",
"creation_time",
"revision",
"field")),
event_sources=("suggestion", "submission"))
for event in scored_events:
self.score_event(event, calculated_scores)
return calculated_scores
def iterate_scores(self, scores):
for timestamp, date_scores in scores.items():
for user, user_scores in date_scores.items():
yield timestamp, user, user_scores
class TPScoreUpdater(ScoreUpdater):
related_field = "tp_id"
score_model = UserTPScore
store_score_model = UserStoreScore
user_score_model = get_user_model()
related_object = "tp"
@property
def tp(self):
return self.context
def iterate_scores(self, scores):
score_values = scores.values(
"date",
"user_id",
"score",
"translated",
"reviewed",
"suggested")
for score in score_values.iterator():
yield (
score.pop("date"),
score.pop("user_id"),
score)
def calculate(self, start=None, end=None, users=None):
qs = self.filter_users(self.store_score_model.objects, users)
qs = qs.filter(store__translation_project=self.tp)
return qs.order_by(
"date", "user").values_list(
"date", "user").annotate(
score=Sum("score"),
translated=Sum("translated"),
reviewed=Sum("reviewed"),
suggested=Sum("suggested"))
def clear(self, users=None):
tp_scores = self.score_model.objects.all()
store_scores = self.store_score_model.objects.all()
user_scores = self.user_score_model.objects.all()
if users:
tp_scores = tp_scores.filter(user_id__in=users)
store_scores = store_scores.filter(user_id__in=users)
user_scores = user_scores.filter(id__in=users)
if self.tp:
tp_scores = tp_scores.filter(tp=self.tp)
store_scores = store_scores.filter(
store__translation_project=self.tp)
tp_scores.delete()
store_scores.delete()
user_scores.update(score=0)
user_score_updater = score_updater.get(get_user_model())(users=users)
user_score_updater.update(users=users)
def refresh_scores(self, users=None, existing=None, existing_tps=None):
suppress_tp_scores = keep_data(
signals=(update_scores, ),
suppress=(TranslationProject, ))
existing = existing or self.get_store_scores(self.tp)
with bulk_operations(UserTPScore):
with suppress_tp_scores:
with bulk_operations(UserStoreScore):
for store in self.tp.stores.iterator():
score_updater.get(store.__class__)(store).update(
users=users,
existing=existing.get(store.id))
self.update(users=users, existing=existing_tps)
class UserScoreUpdater(ScoreUpdater):
tp_score_model = UserTPScore
store_score_model = UserStoreScore
score_model = get_user_model()
def __init__(self, users=None, **kwargs):
self.users = users
def calculate(self, start=localdate(), end=None, **kwargs):
scores = self.filter_users(
self.tp_score_model.objects.filter(
date__gte=(localdate() - timedelta(days=30))),
kwargs.get("users"))
return scores.order_by("user").values_list(
"user").annotate(score=Sum("score"))
def set_scores(self, calculated_scores, existing=None):
update.send(
self.score_model,
updates={
user: dict(score=score)
for user, score
in calculated_scores.iterator()})
def clear(self):
tp_scores = self.tp_score_model.objects.all()
store_scores = self.store_score_model.objects.all()
scores = self.score_model.objects.all()
if self.users:
tp_scores = tp_scores.filter(user_id__in=self.users)
store_scores = store_scores.filter(user_id__in=self.users)
scores = scores.filter(id__in=self.users)
tp_scores.delete()
store_scores.delete()
scores.update(score=0)
def refresh_scores(self, users=None, **kwargs):
suppress_user_scores = keep_data(
signals=(update_scores, ),
suppress=(get_user_model(), ))
tp_scores = self.get_tp_scores()
with bulk_operations(get_user_model()):
with suppress_user_scores:
for tp in TranslationProject.objects.all():
score_updater.get(tp.__class__)(tp).refresh_scores(
users=users,
existing_tps=tp_scores.get(tp.id))
self.update(users=users)
| 14,302
|
Python
|
.py
| 360
| 28.519444
| 82
| 0.568642
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,456
|
providers.py
|
translate_pootle/pootle/apps/pootle_score/providers.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from pootle.core.delegate import event_score
from pootle.core.plugin import provider
from pootle_log.utils import LogEvent
from . import scores
@provider(event_score, sender=LogEvent)
def event_log_score_provider(**kwargs_):
return dict(
suggestion_created=scores.SuggestionCreatedScore,
suggestion_accepted=scores.SuggestionAcceptedScore,
suggestion_rejected=scores.SuggestionRejectedScore,
target_updated=scores.TargetUpdatedScore,
state_updated=scores.StateUpdatedScore,
comment_updated=scores.CommentUpdatedScore)
| 849
|
Python
|
.py
| 20
| 38.65
| 77
| 0.780606
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,457
|
scores.py
|
translate_pootle/pootle/apps/pootle_score/scores.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.conf import settings
from pootle_store.constants import FUZZY, TRANSLATED, UNTRANSLATED
class EventScore(object):
score_setting = 0
score = 0
reviewed = 0
translated = 0
suggested = 0
def __init__(self, event):
self.event = event
@property
def unit(self):
return self.event.unit
@property
def score(self):
return (
self.score_setting
* self.unit.unit_source.source_wordcount)
def get_score(self):
return dict(
score=self.score,
translated=self.translated,
reviewed=self.reviewed,
suggested=self.suggested)
class BaseSuggestionScore(EventScore):
@property
def suggestion(self):
return self.event.value
class SuggestionReviewScore(BaseSuggestionScore):
@property
def reviewed(self):
return self.suggestion.unit.unit_source.source_wordcount
class SuggestionCreatedScore(BaseSuggestionScore):
score_setting = settings.POOTLE_SCORES['suggestion_add']
@property
def suggested(self):
return self.suggestion.unit.unit_source.source_wordcount
class SuggestionAcceptedScore(SuggestionReviewScore):
score_setting = settings.POOTLE_SCORES['suggestion_accept']
class SuggestionRejectedScore(SuggestionReviewScore):
score_setting = settings.POOTLE_SCORES['suggestion_reject']
class TargetUpdatedScore(EventScore):
score_setting = settings.POOTLE_SCORES['target_updated']
@property
def translated(self):
return self.unit.unit_source.source_wordcount
class SubmissionEventScore(EventScore):
@property
def submission(self):
return self.event.value
class StateUpdatedScore(SubmissionEventScore):
@property
def state_fuzzied(self):
return (
self.submission.old_value == TRANSLATED
and self.submission.new_value == FUZZY)
@property
def state_unfuzzied(self):
return (
self.submission.old_value == FUZZY
and self.submission.new_value == TRANSLATED)
@property
def translated(self):
return (
self.unit.unit_source.source_wordcount
if (self.submission.old_value == UNTRANSLATED
and self.submission.new_value == TRANSLATED)
else 0)
@property
def is_review(self):
return self.state_fuzzied or self.state_unfuzzied
@property
def reviewed(self):
return (
self.unit.unit_source.source_wordcount
if self.is_review
else 0)
@property
def score_setting(self):
if self.translated:
return settings.POOTLE_SCORES['state_translated']
elif self.state_fuzzied:
return settings.POOTLE_SCORES['state_fuzzy']
elif self.state_unfuzzied:
return settings.POOTLE_SCORES['state_unfuzzy']
class CommentUpdatedScore(SubmissionEventScore):
score_setting = settings.POOTLE_SCORES['comment_updated']
| 3,304
|
Python
|
.py
| 94
| 28.095745
| 77
| 0.690514
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,458
|
0003_add_pootle_user_store_score.py
|
translate_pootle/pootle/apps/pootle_score/migrations/0003_add_pootle_user_store_score.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.5 on 2017-03-14 19:45
from __future__ import unicode_literals
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('pootle_store', '0045_remove_suggestion_tmp_state'),
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
('pootle_score', '0002_set_user_scores'),
]
operations = [
migrations.CreateModel(
name='UserStoreScore',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('date', models.DateField(db_index=True)),
('score', models.FloatField(db_index=True)),
('reviewed', models.IntegerField(db_index=True, default=0)),
('suggested', models.IntegerField(db_index=True, default=0)),
('translated', models.IntegerField(db_index=True, default=0)),
('store', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='user_scores', to='pootle_store.Store')),
('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='store_scores', to=settings.AUTH_USER_MODEL)),
],
options={
'abstract': False,
'db_table': 'pootle_user_store_score',
},
),
migrations.AlterUniqueTogether(
name='userstorescore',
unique_together=set([('date', 'store', 'user')]),
),
]
| 1,645
|
Python
|
.py
| 35
| 36.828571
| 147
| 0.609969
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,459
|
0005_remove_extra_indeces.py
|
translate_pootle/pootle/apps/pootle_score/migrations/0005_remove_extra_indeces.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.7 on 2017-06-02 16:08
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('pootle_score', '0004_zero_default_score'),
]
operations = [
migrations.AlterField(
model_name='userstorescore',
name='date',
field=models.DateField(),
),
migrations.AlterField(
model_name='usertpscore',
name='date',
field=models.DateField(),
),
]
| 592
|
Python
|
.py
| 20
| 21.95
| 52
| 0.590829
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,460
|
0002_set_user_scores.py
|
translate_pootle/pootle/apps/pootle_score/migrations/0002_set_user_scores.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.4 on 2017-01-02 07:04
from __future__ import unicode_literals
from django.db import migrations
from django.db.models import functions, Case, IntegerField, Sum, When
class TranslationActionCodes(object):
NEW = 0 # 'TA' unit translated
EDITED = 1 # 'TE' unit edited after someone else
EDITED_OWN = 2 # 'TX' unit edited after themselves
DELETED = 3 # 'TD' translation deleted by admin
REVIEWED = 4 # 'R' translation reviewed
MARKED_FUZZY = 5 # 'TF' translation’s fuzzy flag is set by admin
EDIT_PENALTY = 6 # 'XE' translation penalty [when translation deleted]
REVIEW_PENALTY = 7 # 'XR' translation penalty [when review canceled]
SUGG_ADDED = 8 # 'S' suggestion added
# 'SA' suggestion accepted (counted towards the suggestion author)
SUGG_ACCEPTED = 9
# 'SR' suggestion rejected (counted towards the suggestion author)
SUGG_REJECTED = 10
# 'RA' suggestion accepted (counted towards the reviewer)
SUGG_REVIEWED_ACCEPTED = 11
# 'RR' suggestion rejected (counted towards the reviewer)
SUGG_REVIEWED_REJECTED = 12
def set_user_scores(apps, schema_editor):
from accounts.models import User
UserTPScore = apps.get_model("pootle_score.UserTPScore")
scorelogs = apps.get_model("pootle_statistics.ScoreLog").objects.exclude(
user__username__in=User.objects.META_USERS)
scorelogs = scorelogs.annotate(
day=functions.TruncDay("creation_time")).values(
"day", "user", "submission__translation_project").annotate(
score=Sum("score_delta"),
suggested=Sum(
Case(
When(
action_code=TranslationActionCodes.SUGG_ADDED,
then='wordcount'),
default=0,
output_field=IntegerField())),
translated=Sum(
Case(
When(
translated_wordcount__isnull=False,
then='translated_wordcount'),
default=0,
output_field=IntegerField())),
reviewed=Sum(
Case(
When(
action_code__in=[
TranslationActionCodes.SUGG_REVIEWED_ACCEPTED,
TranslationActionCodes.REVIEWED,
TranslationActionCodes.EDITED],
translated_wordcount__isnull=True,
then='wordcount'),
default=0,
output_field=IntegerField())))
UserTPScore.objects.bulk_create(
UserTPScore(
date=score["day"],
user_id=score["user"],
tp_id=score["submission__translation_project"],
score=score["score"],
reviewed=score["reviewed"],
suggested=score["suggested"],
translated=score["translated"])
for score in scorelogs.iterator())
class Migration(migrations.Migration):
dependencies = [
('pootle_score', '0001_initial'),
('pootle_statistics', '0005_index_ordering')
]
operations = [
migrations.RunPython(set_user_scores),
]
| 3,384
|
Python
|
.py
| 75
| 32.146667
| 78
| 0.572598
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,461
|
0001_initial.py
|
translate_pootle/pootle/apps/pootle_score/migrations/0001_initial.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.4 on 2017-01-02 15:30
from __future__ import unicode_literals
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
('pootle_translationproject', '0006_relink_or_drop_orphan_translationprojects'),
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='UserTPScore',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('date', models.DateField(db_index=True)),
('score', models.FloatField(db_index=True)),
('reviewed', models.IntegerField(db_index=True, default=0)),
('suggested', models.IntegerField(db_index=True, default=0)),
('translated', models.IntegerField(db_index=True, default=0)),
('tp', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='user_scores', to='pootle_translationproject.TranslationProject')),
('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='scores', to=settings.AUTH_USER_MODEL)),
],
options={
'abstract': False,
'db_table': 'pootle_user_tp_score',
},
),
migrations.AlterUniqueTogether(
name='usertpscore',
unique_together=set([('date', 'tp', 'user')]),
),
]
| 1,647
|
Python
|
.py
| 35
| 36.971429
| 166
| 0.618929
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,462
|
0004_zero_default_score.py
|
translate_pootle/pootle/apps/pootle_score/migrations/0004_zero_default_score.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.5 on 2017-03-17 17:38
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('pootle_score', '0003_add_pootle_user_store_score'),
]
operations = [
migrations.AlterField(
model_name='userstorescore',
name='score',
field=models.FloatField(db_index=True, default=0),
),
migrations.AlterField(
model_name='usertpscore',
name='score',
field=models.FloatField(db_index=True, default=0),
),
]
| 653
|
Python
|
.py
| 20
| 25
| 62
| 0.611465
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,463
|
signals.py
|
translate_pootle/pootle/apps/pootle_translationproject/signals.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.dispatch import Signal
tp_inited_async = Signal(
providing_args=["instance", "response_url", ],
use_caching=True)
tp_init_failed_async = Signal(
providing_args=["instance", ],
use_caching=True)
| 500
|
Python
|
.py
| 14
| 33.357143
| 77
| 0.73499
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,464
|
models.py
|
translate_pootle/pootle/apps/pootle_translationproject/models.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import logging
import posixpath
from pathlib import PurePosixPath
from django.contrib.contenttypes.fields import GenericRelation
from django.db import models
from django.urls import reverse
from django.utils.functional import cached_property
from pootle.core.delegate import data_tool
from pootle.core.mixins import CachedTreeItem
from pootle.core.url_helpers import get_editor_filter, split_pootle_path
from pootle_app.models.directory import Directory
from pootle_checks.constants import EXCLUDED_FILTERS
from pootle_language.models import Language
from pootle_project.models import Project
from pootle_revision.models import Revision
from staticpages.models import StaticPage
logger = logging.getLogger(__name__)
class TranslationProjectManager(models.Manager):
def get_terminology_project(self, language_id):
# FIXME: the code below currently uses the same approach to determine
# the 'terminology' kind of a project as 'Project.is_terminology()',
# which means it checks the value of 'checkstyle' field
# (see pootle_project/models.py:240).
#
# This should probably be replaced in the future with a dedicated
# project property.
return self.get(language=language_id,
project__checkstyle='terminology')
def live(self):
"""Filters translation projects that have non-obsolete directories."""
return self.filter(directory__obsolete=False)
def for_user(self, user, select_related=None):
"""Filters translation projects for a specific user.
- Admins always get all translation projects.
- Regular users only get enabled translation projects
accessible to them.
:param user: The user for whom the translation projects need to be
retrieved for.
:return: A filtered queryset with `TranslationProject`s for `user`.
"""
qs = self.live()
if select_related is not None:
qs = qs.select_related(*select_related)
if user.is_superuser:
return qs
return qs.filter(
project__disabled=False,
project__code__in=Project.accessible_by_user(user))
def get_for_user(self, user, project_code, language_code,
select_related=None):
"""Gets a `language_code`/`project_code` translation project
for a specific `user`.
- Admins can get the translation project even
if its project is disabled.
- Regular users only get a translation project
if its project isn't disabled and it is accessible to them.
:param user: The user for whom the translation project needs
to be retrieved.
:param project_code: The code of a project for the TP to retrieve.
:param language_code: The code of the language fro the TP to retrieve.
:return: The `TranslationProject` matching the params, raises
otherwise.
"""
return self.for_user(
user, select_related).get(
project__code=project_code,
language__code=language_code)
class TranslationProject(models.Model, CachedTreeItem):
language = models.ForeignKey(
Language, db_index=False, on_delete=models.CASCADE)
project = models.ForeignKey(
Project, db_index=True, on_delete=models.CASCADE)
directory = models.OneToOneField(
Directory, db_index=True, editable=False, on_delete=models.CASCADE)
pootle_path = models.CharField(max_length=255, null=False, unique=True,
db_index=True, editable=False)
creation_time = models.DateTimeField(auto_now_add=True, db_index=True,
editable=False, null=True)
revisions = GenericRelation(Revision)
objects = TranslationProjectManager()
class Meta(object):
unique_together = (
('language', 'project'),
('project', 'language'))
db_table = 'pootle_app_translationproject'
# disabled objects are hidden for related objects too
base_manager_name = 'objects'
@cached_property
def code(self):
return u'-'.join([self.language.code, self.project.code])
@cached_property
def data_tool(self):
return data_tool.get(self.__class__)(self)
# # # # # # # # # # # # # # Properties # # # # # # # # # # # # # # # # # #
@property
def name(self):
# TODO: See if `self.fullname` can be removed
return self.fullname
@property
def fullname(self):
return "%s [%s]" % (self.project.fullname, self.language.name)
@property
def checker(self):
from translate.filters import checks
checkerclasses = [
checks.projectcheckers.get(
self.project.checkstyle,
checks.StandardChecker)]
return checks.TeeChecker(checkerclasses=checkerclasses,
excludefilters=EXCLUDED_FILTERS,
errorhandler=self.filtererrorhandler,
languagecode=self.language.code)
@property
def disabled(self):
return self.project.disabled
@cached_property
def templates_tp(self):
return self.project.get_template_translationproject()
@property
def is_template_project(self):
return self == self.templates_tp
# # # # # # # # # # # # # # Methods # # # # # # # # # # # # # # # # # # #
def __unicode__(self):
return self.pootle_path
def __init__(self, *args, **kwargs):
super(TranslationProject, self).__init__(*args, **kwargs)
def save(self, *args, **kwargs):
self.directory = (
self.language.directory.get_or_make_subdir(self.project.code))
self.pootle_path = self.directory.pootle_path
super(TranslationProject, self).save(*args, **kwargs)
if self.directory.tp_id != self.pk:
self.directory.tp = self
self.directory.save()
def delete(self, *args, **kwargs):
directory = self.directory
super(TranslationProject, self).delete(*args, **kwargs)
directory.delete()
def get_absolute_url(self):
return reverse(
'pootle-tp-browse',
args=split_pootle_path(self.pootle_path)[:-1])
def get_translate_url(self, **kwargs):
return u''.join(
[reverse("pootle-tp-translate",
args=split_pootle_path(self.pootle_path)[:-1]),
get_editor_filter(**kwargs)])
def get_announcement(self, user=None):
"""Return the related announcement, if any."""
return StaticPage.get_announcement_for(self.pootle_path, user)
def filtererrorhandler(self, functionname, str1, str2, e):
logger.error(
u"Error in filter %s: %r, %r, %s",
functionname,
str1,
str2, e)
return False
def is_accessible_by(self, user):
"""Returns `True` if the current translation project is accessible
by `user`.
"""
if user.is_superuser:
return True
return self.project.code in Project.accessible_by_user(user)
def can_be_inited_from_templates(self):
"""Returns `True` if the current translation project hasn't been
saved yet and can be initialized from templates.
"""
# This method checks if the current translation project directory
# doesn't exist. So it won't work if the translation project is already
# saved the database because the translation project directory is
# auto-created in `save()` method.
return (
not self.is_template_project
and self.templates_tp is not None)
def create_parent_dirs(self, pootle_path):
parent = self.directory
dirs_to_create = []
for path in PurePosixPath(pootle_path).parents:
path = posixpath.join(str(path), "")
if path == self.pootle_path:
break
dirs_to_create.append(path)
for path in reversed(dirs_to_create):
parent, __ = Directory.objects.get_or_create(
pootle_path=path,
parent=parent,
tp=self,
name=posixpath.basename(path.rstrip("/")))
return parent
def init_store_from_template(self, template_store):
"""Initialize a new file for `self` using `template_store`.
"""
pootle_path = posixpath.join(
self.pootle_path.rstrip("/"),
template_store.tp_path.lstrip("/"))
pootle_path = ".".join(
[posixpath.splitext(pootle_path)[0],
template_store.filetype.extension.name])
name = posixpath.basename(pootle_path)
if self.project.is_gnustyle:
# gnu-style layout
# use language code instead of template name
name = ".".join(
[self.language.code,
template_store.filetype.extension.name])
dirname = posixpath.dirname(pootle_path)
pootle_path = posixpath.join(dirname, name)
if not self.stores.filter(pootle_path=pootle_path).exists():
return self.stores.create(
parent=self.create_parent_dirs(pootle_path),
pootle_path=pootle_path,
name=name)
def init_from_templates(self):
"""Initializes the current translation project files using
the templates TP ones.
"""
template_stores = self.templates_tp.stores.live().select_related(
"filetype__template_extension",
"filetype__extension").order_by("creation_time")
for template_store in template_stores.iterator():
new_store = self.init_store_from_template(template_store)
if new_store:
new_store.update(
new_store.deserialize(template_store.serialize()))
# # # TreeItem
def get_children(self):
return self.directory.children
def get_parents(self):
return [self.project]
| 10,473
|
Python
|
.py
| 237
| 34.540084
| 79
| 0.630571
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,465
|
getters.py
|
translate_pootle/pootle/apps/pootle_translationproject/getters.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from pootle.core.delegate import paths, tp_tool
from pootle.core.plugin import getter
from pootle_project.models import Project
from .models import TranslationProject
from .utils import TPPaths, TPTool
@getter(paths, sender=TranslationProject)
def tp_paths_getter(**kwargs_):
return TPPaths
@getter(tp_tool, sender=Project)
def tp_tool_getter(**kwargs_):
return TPTool
| 658
|
Python
|
.py
| 18
| 34.777778
| 77
| 0.787066
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,466
|
urls.py
|
translate_pootle/pootle/apps/pootle_translationproject/urls.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.conf.urls import url
from .views import (
TPBrowseStoreView, TPBrowseView, TPPathsJSON, TPTranslateStoreView,
TPTranslateView, admin_permissions)
urlpatterns = [
# Admin views
url(r'^(?P<language_code>[^/]*)/(?P<project_code>[^/]*)'
r'/admin/permissions/',
admin_permissions,
name='pootle-tp-admin-permissions'),
url(r'^(?P<language_code>[^/]*)/(?P<project_code>[^/]*)'
r'/paths/',
TPPathsJSON.as_view(),
name='pootle-tp-paths'),
# Translation
url(r'^(?P<language_code>[^/]*)/(?P<project_code>[^/]*)/'
r'translate/(?P<dir_path>(.*/)*)?$',
TPTranslateView.as_view(),
name='pootle-tp-translate'),
url(r'^(?P<language_code>[^/]*)/(?P<project_code>[^/]*)/'
r'translate/(?P<dir_path>(.*/)*)(?P<filename>.*\.*)$',
TPTranslateStoreView.as_view(),
name='pootle-tp-store-translate'),
# Browser
url(r'^(?P<language_code>[^/]*)/(?P<project_code>[^/]*)/'
r'(?P<dir_path>(.*/)*)?$',
TPBrowseView.as_view(),
name='pootle-tp-browse'),
url(r'^(?P<language_code>[^/]*)/(?P<project_code>[^/]*)/'
r'(?P<dir_path>(.*/)*)(?P<filename>.*\.*)?$',
TPBrowseStoreView.as_view(),
name='pootle-tp-store-browse')
]
| 1,568
|
Python
|
.py
| 40
| 33.325
| 77
| 0.589744
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,467
|
apps.py
|
translate_pootle/pootle/apps/pootle_translationproject/apps.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
"""
Pootle App Config
See https://docs.djangoproject.com/en/1.10/ref/applications/
"""
import importlib
from django.apps import AppConfig
class PootleTPConfig(AppConfig):
name = "pootle_translationproject"
verbose_name = "PootleTranslationProject"
version = "0.1.4"
def ready(self):
importlib.import_module("pootle_translationproject.receivers")
importlib.import_module("pootle_translationproject.getters")
| 720
|
Python
|
.py
| 20
| 33.1
| 77
| 0.760807
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,468
|
receivers.py
|
translate_pootle/pootle/apps/pootle_translationproject/receivers.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.contrib.auth import get_user_model
from django.db.models import Q
from django.dispatch import receiver
from django.template.loader import render_to_string
from pootle.core.mail import send_mail
from pootle.core.url_helpers import urljoin
from pootle.i18n.gettext import ugettext_lazy as _
from .models import TranslationProject
from .signals import tp_init_failed_async, tp_inited_async
def get_recipients(project):
User = get_user_model()
return list(set(User.objects.filter(
Q(permissionset__positive_permissions__codename="administrate",
permissionset__directory__pootle_path=project.pootle_path) |
Q(is_superuser=True)).values_list("email", flat=True)))
@receiver(tp_inited_async, sender=TranslationProject)
def tp_inited_async_handler(**kwargs):
instance = kwargs["instance"]
response_url = kwargs["response_url"]
ctx = {"tp": instance,
"url": urljoin(response_url, instance.get_absolute_url())}
message = render_to_string(
'projects/admin/email/translation_project_created.txt', context=ctx)
subject = _(u"Translation project (%s) created" % instance)
recipients = get_recipients(instance.project)
send_mail(subject, message, from_email=None,
recipient_list=[], fail_silently=True, bcc=recipients)
@receiver(tp_init_failed_async, sender=TranslationProject)
def tp_init_failed_async_handler(**kwargs):
instance = kwargs["instance"]
ctx = {"tp": instance}
message = render_to_string(
'projects/admin/email/translation_project_creation_failed.txt',
context=ctx)
subject = _(u"Translation project (%s) creation failed" % instance)
recipients = get_recipients(instance.project)
send_mail(subject, message, from_email=None,
recipient_list=[], fail_silently=True, bcc=recipients)
| 2,125
|
Python
|
.py
| 45
| 42.688889
| 77
| 0.735266
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,469
|
utils.py
|
translate_pootle/pootle/apps/pootle_translationproject/utils.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.contrib.auth import get_user_model
from pootle.core.contextmanagers import keep_data
from pootle.core.models import Revision
from pootle.core.paths import Paths
from pootle.core.signals import create, update_checks
from pootle_statistics.models import SubmissionTypes
from pootle_store.constants import OBSOLETE, SOURCE_WINS
from pootle_store.diff import StoreDiff
from pootle_store.models import QualityCheck
from .apps import PootleTPConfig
from .contextmanagers import update_tp_after
User = get_user_model()
class TPPaths(Paths):
ns = "pootle.tp"
sw_version = PootleTPConfig.version
@property
def store_qs(self):
return self.context.stores.all()
class TPTool(object):
def __init__(self, project):
self.project = project
def __getitem__(self, language_code):
"""Access to Project TPs by language_code"""
return self.tp_qs.get(language__code=language_code)
@property
def tp_qs(self):
"""Queryset of translation_projects"""
return self.get_tps(self.project)
def get_tps(self, project):
return project.translationproject_set
def check_no_tp(self, language, project=None):
"""Check a TP doesn't exist already for a given language.
"""
if self.get_tp(language, project):
raise ValueError(
"TranslationProject '%s' already exists"
% self.get_path(
language.code,
project and project.code or None))
def check_tp(self, tp):
"""Check if a TP is part of our Project"""
if tp.project != self.project:
raise ValueError(
"TP '%s' is not part of project '%s'"
% (tp, self.project.code))
def clone(self, tp, language, project=None):
"""Clone a TP to a given language. Raises Exception if an existing TP
exists for that Language.
"""
if not project:
self.check_tp(tp)
self.check_no_tp(language, project)
new_tp = self.create_tp(language, project)
new_tp.directory.tp = new_tp
new_tp.directory.translationproject = new_tp
with update_tp_after(new_tp):
self.clone_children(
tp.directory,
new_tp.directory)
return new_tp
def clone_children(self, source_dir, target_parent):
"""Clone a source Directory's children to a given target Directory.
"""
source_stores = source_dir.child_stores.live().select_related(
"data", "filetype", "filetype__extension")
for store in source_stores:
store.parent = source_dir
self.clone_store(store, target_parent)
for subdir in source_dir.child_dirs.live():
subdir.parent = source_dir
self.clone_directory(subdir, target_parent)
def clone_directory(self, source_dir, target_parent):
"""Clone a source Directory and its children to a given target
Directory. Raises Exception if the target exists already.
"""
target_dir = target_parent.child_dirs.create(
name=source_dir.name, tp=target_parent.translation_project)
target_dir.parent = target_parent
self.clone_children(
source_dir,
target_dir)
return target_dir
def clone_store(self, store, target_dir):
"""Clone given Store to target Directory"""
cloned = target_dir.child_stores.create(
name=store.name,
translation_project=target_dir.translation_project)
with keep_data(signals=(update_checks, )):
cloned.update(cloned.deserialize(store.serialize()))
cloned.state = store.state
cloned.filetype = store.filetype
cloned.save()
self.clone_checks(store, cloned)
return cloned
def clone_checks(self, source_store, target_store):
"""Clone checks from source store to target store."""
fields = ('unit__unitid_hash', 'category', 'name',
'false_positive', 'message')
checks = QualityCheck.objects.filter(
unit__store=source_store,
unit__state__gt=OBSOLETE,
).values(*fields)
unitid_hashes = [x['unit__unitid_hash'] for x in checks]
units = target_store.units.filter(unitid_hash__in=unitid_hashes)
unit_map = {
x['unitid_hash']: x['id']
for x in units.values('id', 'unitid_hash')}
cloned_checks = []
for check in checks:
cloned_checks.append(QualityCheck(
unit_id=unit_map[check['unit__unitid_hash']],
category=check['category'],
name=check['name'],
false_positive=check['false_positive'],
message=check['message']))
create.send(QualityCheck, objects=cloned_checks)
def create_tp(self, language, project=None):
"""Create a TP for a given language"""
tp_qs = (
self.get_tps(project)
if project
else self.tp_qs)
return tp_qs.create(language=language)
def get(self, language_code, default=None):
"""Given a language code, returns the relevant TP.
If the TP doesn't exist returns a `default` or `None`.
"""
try:
return self[language_code]
except self.tp_qs.model.DoesNotExist:
return default
def get_path(self, language_code, project_code=None):
"""Returns the pootle_path of a TP for a given language_code"""
return (
"/%s/%s/"
% (language_code,
(project_code
and project_code
or self.project.code)))
def get_tp(self, language, project=None):
"""Given a language return the related TP"""
tp_qs = (
self.get_tps(project)
if project
else self.tp_qs)
try:
return tp_qs.select_related(
"directory",
"directory__parent").get(language=language)
except tp_qs.model.DoesNotExist:
pass
def move(self, tp, language, project=None):
"""Re-assign a tp to a different language"""
if not project:
self.check_tp(tp)
if not project and (tp.language == language):
return
self.check_no_tp(language, project)
pootle_path = self.get_path(
language.code,
project and project.code or None)
directory = tp.directory
if project:
tp.project = project
tp.language = language
tp.pootle_path = pootle_path
with update_tp_after(tp):
tp.save()
self.set_parents(
directory,
self.get_tp(language, project).directory,
project=project)
directory.delete()
def set_parents(self, directory, parent, project=None):
"""Recursively sets the parent for children of a directory"""
if not project:
self.check_tp(directory.translation_project)
self.check_tp(parent.translation_project)
for store in directory.child_stores.all():
store.parent = parent
store.save()
for subdir in directory.child_dirs.all():
subdir.parent = parent
subdir.save()
self.set_parents(subdir, subdir, project)
def update_children(self, source_dir, target_dir):
"""Update a target Directory and its children from a given
source Directory
"""
stores = []
dirs = []
source_stores = source_dir.child_stores.select_related(
"filetype__extension",
"filetype__template_extension")
for store in source_stores:
store.parent = source_dir
stores.append(store.name)
try:
self.update_store(
store,
target_dir.child_stores.select_related(
"filetype__extension",
"filetype__template_extension").get(name=store.name))
except target_dir.child_stores.model.DoesNotExist:
self.clone_store(store, target_dir)
for subdir in source_dir.child_dirs.live():
subdir.parent = source_dir
dirs.append(subdir.name)
try:
self.update_children(
subdir,
target_dir.child_dirs.get(name=subdir.name))
except target_dir.child_dirs.model.DoesNotExist:
self.clone_directory(subdir, target_dir)
for store in target_dir.child_stores.exclude(name__in=stores):
store.makeobsolete()
def update_from_tp(self, source, target):
"""Update one TP from another"""
self.check_tp(source)
self.check_tp(target)
with update_tp_after(target):
self.update_children(
source.directory, target.directory)
def update_store(self, source, target):
"""Update a target Store from a given source Store"""
source_revision = target.data.max_unit_revision + 1
differ = StoreDiff(target, source, source_revision)
diff = differ.diff()
if diff is None:
return
system = User.objects.get_system_user()
update_revision = Revision.incr()
return target.updater.update_from_diff(
source,
source_revision,
diff,
update_revision,
system,
SubmissionTypes.SYSTEM,
SOURCE_WINS,
True)
| 10,011
|
Python
|
.py
| 248
| 29.939516
| 77
| 0.599692
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,470
|
__init__.py
|
translate_pootle/pootle/apps/pootle_translationproject/__init__.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
default_app_config = 'pootle_translationproject.apps.PootleTPConfig'
| 345
|
Python
|
.py
| 8
| 42
| 77
| 0.77381
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,471
|
contextmanagers.py
|
translate_pootle/pootle/apps/pootle_translationproject/contextmanagers.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from contextlib import contextmanager
from django.contrib.auth import get_user_model
from django.dispatch import receiver
from pootle.core.contextmanagers import bulk_operations, keep_data
from pootle.core.signals import (
update_checks, update_data, update_revisions, update_scores)
from pootle_app.models import Directory
from pootle_data.models import StoreChecksData, StoreData, TPChecksData, TPData
from pootle_score.models import UserStoreScore, UserTPScore
from pootle_store.models import QualityCheck, Store
class Updated(object):
data = None
checks = None
tp_data = False
revisions = None
score_stores = None
score_users = None
tp_scores = False
def _handle_update_stores(sender, updated):
@receiver(update_data, sender=sender.__class__)
def update_tp_data_handler(**kwargs):
updated.tp_data = True
update_data.disconnect(
update_tp_data_handler,
sender=sender.__class__)
@receiver(update_scores, sender=sender.__class__)
def update_tp_scores_handler(**kwargs):
updated.tp_scores = True
update_scores.disconnect(
update_tp_scores_handler,
sender=sender.__class__)
if updated.checks:
with keep_data(suppress=(Store, ), signals=(update_data, )):
@receiver(update_data, sender=Store)
def extra_update_data_handler_(**kwargs):
updated.data = updated.data or {}
updated.data[kwargs["instance"].id] = kwargs["instance"]
with bulk_operations(QualityCheck):
for to_check in updated.checks.values():
store = to_check["store"]
units = (
[unit for unit in to_check["units"]]
if to_check["units"]
else None)
update_checks.send(
store.__class__,
instance=store,
units=units)
if updated.data:
stores = updated.data.values()
for store in stores:
update_data.send(
Store,
instance=store)
if updated.score_stores:
for store in updated.score_stores.values():
update_scores.send(
store.__class__,
instance=store,
users=updated.score_users)
def _update_stores(sender, updated):
# call signals for stores
bulk_stores = bulk_operations(
models=(
UserStoreScore,
StoreData,
StoreChecksData))
with keep_data(suppress=(sender.__class__, )):
with bulk_stores:
_handle_update_stores(sender, updated)
def _callback_handler(sender, updated, **kwargs):
bulk_tps = bulk_operations(
models=(
get_user_model(),
UserTPScore,
TPData,
TPChecksData))
with keep_data(signals=(update_revisions, )):
@receiver(update_revisions)
def update_revisions_handler(**kwargs):
if updated.revisions is None:
updated.revisions = set()
instance = kwargs.get("instance")
if isinstance(instance, Store):
updated.revisions.add(kwargs["instance"].parent.pootle_path)
elif isinstance(instance, Directory):
updated.revisions.add(kwargs["instance"].pootle_path)
with bulk_tps:
_update_stores(sender, updated)
if updated.tp_data:
update_data.send(
sender.__class__,
instance=sender)
if updated.tp_scores:
update_scores.send(
sender.__class__,
instance=sender,
users=updated.score_users)
if updated.revisions:
update_revisions.send(
Directory,
paths=updated.revisions,
keys=["stats", "checks"])
@contextmanager
def update_tp_after(sender, **kwargs):
updated = Updated()
with keep_data():
@receiver(update_data, sender=Store)
def update_data_handler(**kwargs):
if updated.data is None:
updated.data = {}
updated.data[kwargs["instance"].id] = kwargs["instance"]
@receiver(update_checks)
def update_check_handler(**kwargs):
if updated.checks is None:
updated.checks = {}
units = None
if isinstance(kwargs.get("instance"), Store):
store = kwargs["instance"]
units = set(kwargs.get("units") or [])
else:
store = kwargs["instance"].store
units = set([kwargs["instance"].id])
updated.checks[store.id] = updated.checks.get(
store.id,
dict(store=store, units=set()))
if units is not None:
updated.checks[store.id]["units"] |= units
@receiver(update_scores, sender=Store)
def update_scores_handler(**kwargs):
if not updated.score_stores:
updated.score_stores = {}
if "instance" in kwargs:
updated.score_stores[kwargs["instance"].id] = kwargs["instance"]
if "users" in kwargs:
updated.score_users = (
(updated.score_users or set())
| set(kwargs["users"]))
yield
kwargs.get("callback", _callback_handler)(
sender, updated, **kwargs)
| 5,851
|
Python
|
.py
| 148
| 28.351351
| 80
| 0.5784
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,472
|
views.py
|
translate_pootle/pootle/apps/pootle_translationproject/views.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import functools
from django.conf import settings
from django.http import Http404
from django.shortcuts import get_object_or_404, redirect
from django.urls import resolve, reverse
from django.utils.functional import cached_property
from pootle.core.browser import (
get_parent, make_directory_item, make_store_item)
from pootle.core.decorators import (
get_path_obj, permission_required, persistent_property)
from pootle.core.helpers import get_sidebar_announcements_context
from pootle.core.views import PootleBrowseView, PootleTranslateView
from pootle.core.views.display import StatsDisplay
from pootle.core.views.paths import PootlePathsJSON
from pootle_app.models import Directory
from pootle_app.models.permissions import get_matching_permissions
from pootle_app.views.admin.permissions import admin_permissions as admin_perms
from pootle_language.models import Language
from pootle_store.models import Store
from .apps import PootleTPConfig
from .models import TranslationProject
class TPPathsJSON(PootlePathsJSON):
@cached_property
def context(self):
return get_object_or_404(
TranslationProject.objects.all(),
language__code=self.kwargs["language_code"],
project__code=self.kwargs["project_code"])
@get_path_obj
@permission_required('administrate')
def admin_permissions(request, translation_project):
ctx = {
'page': 'admin-permissions',
'browse_url': reverse('pootle-tp-browse', kwargs={
'language_code': translation_project.language.code,
'project_code': translation_project.project.code,
}),
'translate_url': reverse('pootle-tp-translate', kwargs={
'language_code': translation_project.language.code,
'project_code': translation_project.project.code,
}),
'translation_project': translation_project,
'project': translation_project.project,
'language': translation_project.language,
'directory': translation_project.directory,
}
return admin_perms(request, translation_project.directory,
'translation_projects/admin/permissions.html', ctx)
def redirect_to_tp_on_404(f):
@functools.wraps(f)
def method_wrapper(self, request, *args, **kwargs):
try:
request.permissions = get_matching_permissions(
request.user,
self.permission_context) or []
except Http404 as e:
# Test if lang code is not canonical but valid
lang = Language.get_canonical(kwargs['language_code'])
if lang is not None and lang.code != kwargs['language_code']:
kwargs["language_code"] = lang.code
return redirect(
resolve(request.path).view_name,
permanent=True,
**kwargs)
elif kwargs.get("dir_path", None) or kwargs.get("filename", None):
try:
TranslationProject.objects.get(
project__code=kwargs["project_code"],
language__code=kwargs["language_code"])
# the TP exists so redirect to it
return redirect(
reverse(
'pootle-tp-browse',
kwargs={
k: v
for k, v
in kwargs.items()
if k in [
"language_code",
"project_code"]}))
except TranslationProject.DoesNotExist:
pass
# if we get here - the TP does not exist
user_choice = self.request.COOKIES.get(
'user-choice', None)
if user_choice:
url = None
if user_choice == 'language':
url = reverse(
'pootle-language-browse',
args=[kwargs["language_code"]])
elif user_choice == "project":
url = reverse(
'pootle-project-browse',
args=[kwargs["project_code"], '', ''])
if url:
response = redirect(url)
response.delete_cookie('user-choice')
return response
raise e
return f(self, request, *args, **kwargs)
return method_wrapper
class TPMixin(object):
"""This Mixin is used by all TP views.
The context object may be a resource with the TP, ie a Directory or Store.
"""
ns = "pootle.tp"
sw_version = PootleTPConfig.version
@redirect_to_tp_on_404
def dispatch(self, request, *args, **kwargs):
return super(TPMixin, self).dispatch(request, *args, **kwargs)
@property
def ctx_path(self):
return self.tp.pootle_path
@property
def resource_path(self):
return self.object.pootle_path.replace(self.ctx_path, "")
@property
def dir_path(self):
return self.resource_path
@cached_property
def tp(self):
if not self.object.tp:
return self.object.translation_project
return self.object.tp
@cached_property
def project(self):
if self.tp.project.disabled and not self.request.user.is_superuser:
raise Http404
return self.tp.project
@cached_property
def language(self):
return self.tp.language
@cached_property
def sidebar_announcements(self):
return get_sidebar_announcements_context(
self.request,
(self.project, self.language, self.tp))
class TPDirectoryMixin(TPMixin):
model = Directory
browse_url_path = "pootle-tp-browse"
translate_url_path = "pootle-tp-translate"
@property
def object_related(self):
return [
"parent",
"tp",
"tp__language",
"tp__language__directory",
"tp__project"]
@cached_property
def object(self):
return get_object_or_404(
Directory.objects.select_related(*self.object_related),
pootle_path=self.path)
def get_object(self):
return self.object
@property
def url_kwargs(self):
return {
"language_code": self.language.code,
"project_code": self.project.code,
"dir_path": self.dir_path}
@cached_property
def vfolders_data_view(self):
if 'virtualfolder' not in settings.INSTALLED_APPS:
return
from virtualfolder.delegate import vfolders_data_view
return vfolders_data_view.get(self.object.__class__)(
self.object, self.request.user, self.has_admin_access)
class TPStoreMixin(TPMixin):
model = Store
browse_url_path = "pootle-tp-store-browse"
translate_url_path = "pootle-tp-store-translate"
is_store = True
panels = ()
@property
def permission_context(self):
return self.get_object().parent
@cached_property
def tp(self):
return self.object.translation_project
@property
def dir_path(self):
return self.resource_path.replace(self.object.name, "")
@property
def url_kwargs(self):
return {
"language_code": self.language.code,
"project_code": self.project.code,
"dir_path": self.dir_path,
"filename": self.object.name}
def get_object(self):
return self.object
@cached_property
def object(self):
path = (
"/%(language_code)s/%(project_code)s/%(dir_path)s%(filename)s"
% self.kwargs)
return get_object_or_404(
Store.objects.select_related(
"parent",
"data",
"data__last_submission",
"data__last_submission__unit",
"data__last_submission__unit__store",
"data__last_submission__unit__store__parent",
"data__last_created_unit",
"data__last_created_unit__store",
"translation_project__directory",
"translation_project__language",
"translation_project__language__directory",
"translation_project__project"),
pootle_path=path)
class TPBrowseBaseView(PootleBrowseView):
template_extends = 'translation_projects/base.html'
def get_context_data(self, *args, **kwargs):
upload_widget = self.get_upload_widget()
ctx = super(TPBrowseBaseView, self).get_context_data(*args, **kwargs)
ctx.update(upload_widget)
ctx.update(
{'parent': get_parent(self.object)})
return ctx
@property
def can_upload(self):
return (
"import_export" in settings.INSTALLED_APPS
and self.request.user.is_authenticated
and (self.request.user.is_superuser
or "translate" in self.request.permissions
or "administrate" in self.request.permissions))
def get_upload_widget(self):
ctx = {}
if self.can_upload:
from import_export.views import handle_upload_form
ctx.update(handle_upload_form(self.request, self.tp))
ctx.update(
{'display_download': True,
'has_sidebar': True})
return ctx
def post(self, *args, **kwargs):
return self.get(*args, **kwargs)
@property
def score_context(self):
return self.tp
class TPBrowseStoreView(TPStoreMixin, TPBrowseBaseView):
disabled_items = False
@property
def cache_key(self):
return ""
class TPBrowseView(TPDirectoryMixin, TPBrowseBaseView):
view_name = "tp"
panel_names = ('vfolders', 'children')
@property
def path(self):
kwargs = self.kwargs
kwargs["dir_path"] = kwargs.get("dir_path", "")
kwargs["filename"] = kwargs.get("filename", "")
return (
"/%(language_code)s/%(project_code)s/%(dir_path)s%(filename)s"
% kwargs)
@persistent_property
def object_children(self):
dirs_with_vfolders = []
if 'virtualfolder' in settings.INSTALLED_APPS:
stores = self.tp.stores
if self.object.tp_path != "/":
stores = stores.filter(
tp_path__startswith=self.object.tp_path)
vf_stores = stores.filter(
vfolders__isnull=False).exclude(parent=self.object)
dirs_with_vfolders = set(
[path.replace(self.object.pootle_path, "").split("/")[0]
for path
in vf_stores.values_list(
"pootle_path", flat=True)])
directories = [
make_directory_item(
child,
**(dict(sort="priority")
if child.name in dirs_with_vfolders
else {}))
for child in self.object.children
if isinstance(child, Directory)]
stores = [
make_store_item(child)
for child in self.object.children
if isinstance(child, Store)]
return self.add_child_stats(directories + stores)
@cached_property
def has_vfolders(self):
vfdata = self.vfolders_data_view
return bool(
vfdata
and vfdata.table_data
and vfdata.table_data.get("children"))
@cached_property
def stats(self):
stats_ob = (
self.object.tp
if self.object.tp_path == "/"
else self.object)
return StatsDisplay(
stats_ob,
stats=stats_ob.data_tool.get_stats(
user=self.request.user)).stats
class TPTranslateBaseView(PootleTranslateView):
translate_url_path = "pootle-tp-translate"
browse_url_path = "pootle-tp-browse"
template_extends = 'translation_projects/base.html'
@property
def pootle_path(self):
return "%s%s" % (self.ctx_path, self.resource_path)
class TPTranslateView(TPDirectoryMixin, TPTranslateBaseView):
@property
def request_path(self):
return "/%(language_code)s/%(project_code)s/%(dir_path)s" % self.kwargs
@cached_property
def display_vfolder_priority(self):
return self.vfolders_data_view.has_data
@property
def path(self):
return self.request_path
class TPTranslateStoreView(TPStoreMixin, TPTranslateBaseView):
pass
| 12,911
|
Python
|
.py
| 332
| 28.542169
| 79
| 0.600384
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,473
|
0005_remove_empty_translationprojects.py
|
translate_pootle/pootle/apps/pootle_translationproject/migrations/0005_remove_empty_translationprojects.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.9.11 on 2016-11-08 19:40
from __future__ import unicode_literals
from django.db import migrations
def drop_empty_translationprojects(apps, schema_editor):
"""Drop TPs with no directories."""
Directory = apps.get_model("pootle_app.Directory")
TP = apps.get_model("pootle_translationproject.TranslationProject")
for tp in TP.objects.all():
if not Directory.objects.filter(pootle_path=tp.pootle_path).exists():
tp.delete()
class Migration(migrations.Migration):
dependencies = [
('pootle_translationproject', '0004_add_reverse_tp_idx'),
('pootle_data', '0006_add_cascade_deletes'),
('pootle_app', '0015_add_tp_path_idx'),
]
operations = [
migrations.RunPython(drop_empty_translationprojects),
]
| 832
|
Python
|
.py
| 20
| 36
| 77
| 0.687811
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,474
|
0006_relink_or_drop_orphan_translationprojects.py
|
translate_pootle/pootle/apps/pootle_translationproject/migrations/0006_relink_or_drop_orphan_translationprojects.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.9.11 on 2016-11-08 21:27
from __future__ import unicode_literals
from django.db import migrations
def relink_or_drop_orphan_translationprojects(apps, schema_editor):
"""Relink or drop TPs with no project."""
Project = apps.get_model("pootle_project.Project")
TP = apps.get_model("pootle_translationproject.TranslationProject")
for proj_key in set(TP.objects.values_list("project_id", flat=True)):
if not Project.objects.filter(pk=proj_key).exists():
for tp in TP.objects.filter(project_id=proj_key):
proj_code = tp.pootle_path.split("/")[2]
projects = Project.objects.filter(code=proj_code)
if projects.exists():
tp.project = projects.first()
tp.save()
else:
tp.delete()
class Migration(migrations.Migration):
dependencies = [
('pootle_translationproject', '0005_remove_empty_translationprojects'),
('pootle_project', '0014_just_rename_label_for_choice'),
]
operations = [
migrations.RunPython(relink_or_drop_orphan_translationprojects),
]
| 1,197
|
Python
|
.py
| 26
| 37
| 79
| 0.640275
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,475
|
0002_remove_translationproject_disabled.py
|
translate_pootle/pootle/apps/pootle_translationproject/migrations/0002_remove_translationproject_disabled.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
from django.db.utils import OperationalError
from pootle_store.constants import OBSOLETE
def make_tp_directories_obsolete(apps, schema_editor):
TranslationProject = apps.get_model("pootle_translationproject",
"TranslationProject")
Directory = apps.get_model("pootle_app", "Directory")
Store = apps.get_model("pootle_store", "Store")
try:
tps = list(TranslationProject.objects.filter(disabled=True))
except OperationalError:
return
for tp in tps:
dir = tp.directory
directories = Directory.objects \
.filter(pootle_path__startswith=dir.pootle_path)
directories.update(obsolete=True)
stores = Store.objects.filter(pootle_path__startswith=dir.pootle_path)
for store in stores:
store.obsolete = True
store.save()
store.unit_set.update(state=OBSOLETE)
def set_tp_disabled(apps, schema_editor):
TranslationProject = apps.get_model("pootle_translationproject",
"TranslationProject")
for tp in TranslationProject.objects.filter(directory__obsolete=True):
tp.disabled = True
tp.directory.obsolete = False
tp.directory.save()
# subdirs, stores and units will be resurrected after
# `update_stores` is executed
class RemoveFieldIfExists(migrations.RemoveField):
def database_forwards(self, app_label, schema_editor, from_state, to_state):
try:
super(RemoveFieldIfExists, self).database_forwards(
app_label, schema_editor, from_state, to_state)
except OperationalError:
pass
class Migration(migrations.Migration):
dependencies = [
('pootle_translationproject', '0001_initial'),
('pootle_store', '0001_initial'),
]
operations = [
migrations.RunPython(make_tp_directories_obsolete, set_tp_disabled),
RemoveFieldIfExists(
model_name='translationproject',
name='disabled',
),
]
| 2,198
|
Python
|
.py
| 52
| 32.980769
| 80
| 0.653052
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,476
|
0004_add_reverse_tp_idx.py
|
translate_pootle/pootle/apps/pootle_translationproject/migrations/0004_add_reverse_tp_idx.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.9.11 on 2016-11-05 10:35
from __future__ import unicode_literals
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('pootle_translationproject', '0003_realpath_can_be_none'),
]
operations = [
migrations.AlterUniqueTogether(
name='translationproject',
unique_together=set([('project', 'language'), ('language', 'project')]),
),
]
| 485
|
Python
|
.py
| 14
| 28.714286
| 84
| 0.648069
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,477
|
0007_set_tp_base_manager_name.py
|
translate_pootle/pootle/apps/pootle_translationproject/migrations/0007_set_tp_base_manager_name.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.5 on 2017-01-20 07:49
from __future__ import unicode_literals
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('pootle_translationproject', '0006_relink_or_drop_orphan_translationprojects'),
]
operations = [
migrations.AlterModelOptions(
name='translationproject',
options={'base_manager_name': 'objects'},
),
]
| 473
|
Python
|
.py
| 14
| 27.857143
| 88
| 0.665198
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,478
|
0008_remove_extra_indeces.py
|
translate_pootle/pootle/apps/pootle_translationproject/migrations/0008_remove_extra_indeces.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.7 on 2017-06-02 16:23
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('pootle_translationproject', '0007_set_tp_base_manager_name'),
]
operations = [
migrations.AlterField(
model_name='translationproject',
name='language',
field=models.ForeignKey(db_index=False, on_delete=django.db.models.deletion.CASCADE, to='pootle_language.Language'),
),
]
| 600
|
Python
|
.py
| 16
| 31.4375
| 128
| 0.680484
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,479
|
0001_initial.py
|
translate_pootle/pootle/apps/pootle_translationproject/migrations/0001_initial.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
import pootle.core.mixins.treeitem
class Migration(migrations.Migration):
dependencies = [
('pootle_app', '0001_initial'),
('pootle_project', '0001_initial'),
('pootle_language', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='TranslationProject',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('real_path', models.FilePathField(editable=False)),
('pootle_path', models.CharField(unique=True, max_length=255, editable=False, db_index=True)),
('creation_time', models.DateTimeField(db_index=True, auto_now_add=True, null=True)),
('disabled', models.BooleanField(default=False)),
('directory', models.OneToOneField(editable=False, to='pootle_app.Directory', on_delete=models.CASCADE)),
('language', models.ForeignKey(to='pootle_language.Language', on_delete=models.CASCADE)),
('project', models.ForeignKey(to='pootle_project.Project', on_delete=models.CASCADE)),
],
options={
'db_table': 'pootle_app_translationproject',
},
bases=(models.Model, pootle.core.mixins.treeitem.CachedTreeItem),
),
migrations.AlterUniqueTogether(
name='translationproject',
unique_together=set([('language', 'project')]),
),
]
| 1,603
|
Python
|
.py
| 33
| 37.969697
| 121
| 0.61278
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,480
|
0009_remove_translationproject_real_path.py
|
translate_pootle/pootle/apps/pootle_translationproject/migrations/0009_remove_translationproject_real_path.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10.7 on 2017-08-28 07:53
from __future__ import unicode_literals
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('pootle_translationproject', '0008_remove_extra_indeces'),
]
operations = [
migrations.RemoveField(
model_name='translationproject',
name='real_path',
),
]
| 428
|
Python
|
.py
| 14
| 24.642857
| 67
| 0.647922
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,481
|
0003_realpath_can_be_none.py
|
translate_pootle/pootle/apps/pootle_translationproject/migrations/0003_realpath_can_be_none.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('pootle_translationproject', '0002_remove_translationproject_disabled'),
]
operations = [
migrations.AlterField(
model_name='translationproject',
name='real_path',
field=models.FilePathField(null=True, editable=False, blank=True),
),
]
| 479
|
Python
|
.py
| 14
| 27.428571
| 81
| 0.658696
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,482
|
signals.py
|
translate_pootle/pootle/apps/pootle_comment/signals.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.dispatch import Signal
comment_was_saved = Signal(providing_args=["comment"], use_caching=True)
| 386
|
Python
|
.py
| 9
| 41.555556
| 77
| 0.76738
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,483
|
models.py
|
translate_pootle/pootle/apps/pootle_comment/models.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django_comments.abstracts import CommentAbstractModel
class Comment(CommentAbstractModel):
"""Custom model to make it easier to change if required"""
| 437
|
Python
|
.py
| 10
| 42
| 77
| 0.778302
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,484
|
apps.py
|
translate_pootle/pootle/apps/pootle_comment/apps.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.apps import AppConfig
class PootleCommentConfig(AppConfig):
name = "pootle_comment"
verbose_name = "Pootle Comments"
| 416
|
Python
|
.py
| 11
| 35.727273
| 77
| 0.763092
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,485
|
__init__.py
|
translate_pootle/pootle/apps/pootle_comment/__init__.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
default_app_config = 'pootle_comment.apps.PootleCommentConfig'
def get_model():
from pootle_comment.models import Comment
return Comment
| 423
|
Python
|
.py
| 11
| 36.454545
| 77
| 0.767726
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,486
|
exceptions.py
|
translate_pootle/pootle/apps/pootle_comment/exceptions.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.forms import ValidationError
class CommentNotSaved(ValidationError):
pass
| 368
|
Python
|
.py
| 10
| 35.1
| 77
| 0.780282
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,487
|
forms.py
|
translate_pootle/pootle/apps/pootle_comment/forms.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import time
from datetime import datetime
from django.contrib.auth import get_user_model
from django.core.exceptions import ValidationError
from django.utils.functional import cached_property
from django_comments.forms import CommentForm as DjCommentForm
from pootle.core.utils.timezone import make_aware
from .delegate import comment_should_not_be_saved
from .exceptions import CommentNotSaved
from .signals import comment_was_saved
User = get_user_model()
class CommentForm(DjCommentForm):
@cached_property
def comment(self):
try:
return self.get_comment_object()
except ValueError as e:
raise ValidationError(e)
def clean(self):
super(CommentForm, self).clean()
should_not_save = comment_should_not_be_saved.get(
self.target_object.__class__,
instance=self.target_object,
comment=self.comment)
if should_not_save:
raise CommentNotSaved(dict(comment=should_not_save))
def save(self):
comment = self.comment
comment.submit_date = make_aware(datetime.now())
comment.save()
comment_was_saved.send(
sender=comment.__class__,
comment=comment)
class UnsecuredCommentForm(CommentForm):
"""This form does not check for security hash, and uses the view's
request.user
"""
def __init__(self, target_object, request_user, data=None, *args, **kwargs):
self.request_user = request_user
self.timestamp = str(int(time.time()))
mangled_fields = [
"name", "timestamp", "object_pk", "security_hash",
"content_type", "email"]
super(UnsecuredCommentForm, self).__init__(
target_object, data, *args, **kwargs)
for field in mangled_fields:
self.fields[field].required = False
def clean_email(self):
return self.request_user.email
def clean_name(self):
return self.request_user.display_name
def clean_content_type(self):
return str(self.target_object._meta)
def clean_object_pk(self):
return str(self.target_object._get_pk_val())
def clean_timestamp(self):
return self.timestamp
def clean_security_hash(self):
return self.initial_security_hash(self.timestamp)
def save(self):
comment = self.comment
comment.user = self.request_user
comment.submit_date = make_aware(datetime.now())
comment.save()
comment_was_saved.send(
sender=comment.__class__,
comment=comment)
| 2,867
|
Python
|
.py
| 74
| 31.662162
| 80
| 0.674847
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,488
|
delegate.py
|
translate_pootle/pootle/apps/pootle_comment/delegate.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from pootle.core.plugin.delegate import Getter
comment_should_not_be_saved = Getter(providing_args=["instance", "comment"])
| 402
|
Python
|
.py
| 9
| 43.333333
| 77
| 0.766667
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,489
|
0001_initial.py
|
translate_pootle/pootle/apps/pootle_comment/migrations/0001_initial.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import migrations, models
from django.conf import settings
class Migration(migrations.Migration):
dependencies = [
('contenttypes', '0002_remove_content_type_name'),
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
('sites', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='Comment',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('object_pk', models.TextField(verbose_name='object ID')),
('user_name', models.CharField(max_length=50, verbose_name="user's name", blank=True)),
('user_email', models.EmailField(max_length=254, verbose_name="user's email address", blank=True)),
('user_url', models.URLField(verbose_name="user's URL", blank=True)),
('comment', models.TextField(max_length=3000, verbose_name='comment')),
('submit_date', models.DateTimeField(default=None, verbose_name='date/time submitted', db_index=True)),
('ip_address', models.GenericIPAddressField(unpack_ipv4=True, null=True, verbose_name='IP address', blank=True)),
('is_public', models.BooleanField(default=True, help_text='Uncheck this box to make the comment effectively disappear from the site.', verbose_name='is public')),
('is_removed', models.BooleanField(default=False, help_text='Check this box if the comment is inappropriate. A "This comment has been removed" message will be displayed instead.', verbose_name='is removed')),
('content_type', models.ForeignKey(related_name='content_type_set_for_comment', verbose_name='content type', to='contenttypes.ContentType', on_delete=models.CASCADE)),
('site', models.ForeignKey(to='sites.Site', on_delete=models.CASCADE)),
('user', models.ForeignKey(related_name='comment_comments', verbose_name='user', blank=True, to=settings.AUTH_USER_MODEL, null=True, on_delete=models.CASCADE)),
],
options={
'ordering': ('submit_date',),
'abstract': False,
'verbose_name': 'comment',
'verbose_name_plural': 'comments',
'permissions': [('can_moderate', 'Can moderate comments')],
},
),
]
| 2,477
|
Python
|
.py
| 37
| 54.891892
| 224
| 0.628747
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,490
|
0002_use_abstract_module.py
|
translate_pootle/pootle/apps/pootle_comment/migrations/0002_use_abstract_module.py
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
from django.conf import settings
class Migration(migrations.Migration):
dependencies = [
('pootle_comment', '0001_initial'),
]
operations = [
migrations.AlterField(
model_name='comment',
name='user',
field=models.ForeignKey(related_name='comment_comments', on_delete=django.db.models.deletion.SET_NULL, verbose_name='user', blank=True, to=settings.AUTH_USER_MODEL, null=True),
),
]
| 601
|
Python
|
.py
| 16
| 31.5
| 188
| 0.677586
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,491
|
models.py
|
translate_pootle/pootle/apps/pootle_revision/models.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from .abstracts import AbstractRevision
class Revision(AbstractRevision):
class Meta(AbstractRevision.Meta):
db_table = "pootle_revision"
| 429
|
Python
|
.py
| 11
| 36.545455
| 77
| 0.763285
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,492
|
getters.py
|
translate_pootle/pootle/apps/pootle_revision/getters.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from pootle.core.delegate import crud, revision, revision_updater
from pootle.core.plugin import getter
from pootle_app.models import Directory
from pootle_language.models import Language
from pootle_project.models import Project, ProjectResource, ProjectSet
from pootle_store.models import Store, Unit
from pootle_translationproject.models import TranslationProject
from .models import Revision
from .utils import (
DirectoryRevision, DirectoryRevisionUpdater, LanguageRevision,
ProjectResourceRevision, ProjectRevision, ProjectRevisionUpdater,
ProjectSetRevision, RevisionCRUD, StoreRevisionUpdater, TPRevision,
UnitRevisionUpdater)
CRUD = {
Revision: RevisionCRUD()}
@getter(crud, sender=(Revision, ))
def data_crud_getter(**kwargs):
return CRUD[kwargs["sender"]]
@getter(revision, sender=Directory)
def directory_revision_getter(**kwargs):
return DirectoryRevision
@getter(revision, sender=Language)
def language_revision_getter(**kwargs):
return LanguageRevision
@getter(revision, sender=Project)
def project_revision_getter(**kwargs):
return ProjectRevision
@getter(revision, sender=ProjectResource)
def project_resource_revision_getter(**kwargs):
return ProjectResourceRevision
@getter(revision, sender=ProjectSet)
def project_set_revision_getter(**kwargs):
return ProjectSetRevision
@getter(revision, sender=TranslationProject)
def tp_revision_getter(**kwargs):
return TPRevision
@getter(revision_updater, sender=Directory)
def directory_revision_updater_getter(**kwargs):
return DirectoryRevisionUpdater
@getter(revision_updater, sender=Unit)
def units_revision_updater_getter(**kwargs):
return UnitRevisionUpdater
@getter(revision_updater, sender=Store)
def stores_revision_updater_getter(**kwargs):
return StoreRevisionUpdater
@getter(revision_updater, sender=Project)
def project_revision_updater_getter(**kwargs):
return ProjectRevisionUpdater
| 2,222
|
Python
|
.py
| 55
| 37.763636
| 77
| 0.814573
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,493
|
abstracts.py
|
translate_pootle/pootle/apps/pootle_revision/abstracts.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.contrib.contenttypes.fields import GenericForeignKey
from django.contrib.contenttypes.models import ContentType
from django.db import models
class AbstractRevision(models.Model):
content_type = models.ForeignKey(
ContentType,
blank=True,
null=True,
db_index=True,
verbose_name='content type',
related_name="content_type_set_for_%(class)s",
on_delete=models.CASCADE)
object_id = models.CharField(
'object ID',
max_length=255,
blank=True,
null=True)
content_object = GenericForeignKey(
ct_field="content_type",
fk_field="object_id")
key = models.CharField(
'Revision key',
max_length=255,
blank=True,
null=True,
db_index=True)
value = models.CharField(
'Revision hash or numeric marker',
max_length=255,
default="",
blank=False,
null=False)
class Meta(object):
abstract = True
ordering = ['pk']
index_together = ["object_id", "content_type", "key"]
unique_together = ["content_type", "object_id", "key"]
| 1,433
|
Python
|
.py
| 44
| 26.022727
| 77
| 0.646931
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,494
|
apps.py
|
translate_pootle/pootle/apps/pootle_revision/apps.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import importlib
from django.apps import AppConfig
class PootleRevisionConfig(AppConfig):
name = "pootle_revision"
verbose_name = "Pootle Revision"
def ready(self):
importlib.import_module("pootle_revision.getters")
importlib.import_module("pootle_revision.receivers")
| 578
|
Python
|
.py
| 15
| 35.266667
| 77
| 0.755835
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,495
|
receivers.py
|
translate_pootle/pootle/apps/pootle_revision/receivers.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.db.models.signals import post_save, pre_delete
from django.dispatch import receiver
from pootle.core.delegate import crud, revision_updater
from pootle.core.signals import create, update, update_revisions
from pootle_app.models import Directory
from pootle_data.models import StoreData
from pootle_project.models import Project
from pootle_store.models import Store
from pootle_translationproject.models import TranslationProject
from .models import Revision
@receiver(create, sender=Revision)
def handle_store_data_obj_create(**kwargs):
crud.get(Revision).create(**kwargs)
@receiver(update, sender=Revision)
def handle_store_data_obj_update(**kwargs):
crud.get(Revision).update(**kwargs)
@receiver(post_save, sender=StoreData)
def handle_storedata_save(**kwargs):
update_revisions.send(
Store,
instance=kwargs["instance"].store,
keys=["stats", "checks"])
@receiver(update_revisions, sender=Store)
def handle_store_revision_update(**kwargs):
revision_updater.get(Store)(
context=kwargs["instance"]).update(keys=kwargs.get("keys"))
@receiver(update_revisions, sender=Project)
def handle_project_revision_update(**kwargs):
revision_updater.get(Project)(
context=kwargs["instance"]).update(keys=kwargs.get("keys"))
@receiver(post_save, sender=Directory)
def handle_directory_save(**kwargs):
update_revisions.send(
Directory,
instance=(
kwargs["instance"].parent
if kwargs.get("created")
else kwargs["instance"]),
keys=["stats", "checks"])
@receiver(update_revisions, sender=Directory)
def handle_directory_revision_update(**kwargs):
updater = revision_updater.get(Directory)
if kwargs.get("instance"):
updater(context=kwargs["instance"]).update(
keys=kwargs.get("keys"))
else:
updater(
object_list=kwargs.get("object_list"),
paths=kwargs.get("paths")).update(
keys=kwargs.get("keys"))
@receiver(pre_delete, sender=Directory)
def handle_directory_delete(**kwargs):
update_revisions.send(
Directory,
instance=kwargs["instance"].parent,
keys=["stats", "checks"])
@receiver(pre_delete, sender=TranslationProject)
def handle_tp_delete(**kwargs):
update_revisions.send(
Directory,
instance=kwargs["instance"].directory,
keys=["stats", "checks"])
@receiver(post_save, sender=Project)
def handle_project_save(**kwargs):
update_revisions.send(
Project,
instance=kwargs["instance"],
keys=["stats", "checks"])
| 2,894
|
Python
|
.py
| 75
| 33.44
| 77
| 0.713877
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,496
|
utils.py
|
translate_pootle/pootle/apps/pootle_revision/utils.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
import uuid
from django.contrib.contenttypes.models import ContentType
from django.utils.functional import cached_property
from pootle.core.bulk import BulkCRUD
from pootle.core.signals import create, update
from pootle.core.url_helpers import split_pootle_path
from pootle_app.models import Directory
from pootle_translationproject.models import TranslationProject
from .models import Revision
class RevisionCRUD(BulkCRUD):
model = Revision
class RevisionContext(object):
def __init__(self, context):
self.context = context
@cached_property
def content_type_id(self):
return ContentType.objects.get_for_model(
self.context._meta.model).id
@property
def revision_context(self):
return self.context.revisions
def get(self, key=None):
"""get a revision from db or set one if not set"""
if not self.revision_context:
return ""
return self.revision_context.filter(
key=key).values_list("value", flat=True).first() or ""
def set(self, keys=None, value=None):
"""get a revision from db or set one if not set"""
self.revision_context.filter(key__in=keys).delete()
if value:
revisions = []
for k in keys:
revisions.append(
Revision(
content_type_id=self.content_type_id,
object_id=self.context.pk,
key=k,
value=value))
create.send(
Revision,
objects=revisions)
class DirectoryRevision(RevisionContext):
pass
class LanguageRevision(RevisionContext):
@property
def revision_context(self):
return self.context.directory.revisions
class ProjectRevision(RevisionContext):
pass
class ProjectResourceRevision(RevisionContext):
@property
def revision_context(self):
self.context.context.revisions
class ProjectSetRevision(RevisionContext):
@property
def revision_context(self):
first_project = self.context.children.first()
if not first_project:
return
return first_project.directory.parent.revisions
class TPRevision(RevisionContext):
pass
class RevisionUpdater(object):
def __init__(self, context=None, object_list=None, paths=None):
self.context = context
self.object_list = object_list
self.paths = paths
@property
def object_list_paths(self):
return set(
self.object_list.values_list(
self.related_pootle_path,
flat=True))
@property
def all_pootle_paths(self):
if self.context and not self.object_list:
return set([self.context_path])
elif self.object_list:
parents = self.object_list_paths
if self.context:
parents.add(self.context_path)
return parents
elif self.paths:
return self.paths
return []
@property
def parents(self):
"""calculate unit parents for cache update"""
return Directory.objects.filter(
pootle_path__in=self.get_parent_paths(self.all_pootle_paths))
def get_parent_paths(self, pootle_paths):
if set(pootle_paths) == set(["/"]):
return pootle_paths
paths = set(["/projects/"])
for pootle_path in pootle_paths:
lang_code, proj_code, dir_path, __ = split_pootle_path(pootle_path)
if proj_code:
paths.add("/projects/%s/" % proj_code)
if lang_code:
paths.add("/%s/" % lang_code)
if lang_code and proj_code:
paths.add("/%s/%s/" % (lang_code, proj_code))
dir_path_parts = dir_path.split("/")
for i, name in enumerate(dir_path_parts):
if not name:
continue
paths.add(
"/%s/%s/%s/"
% (lang_code,
proj_code,
"/".join(dir_path_parts[:i + 1])))
return paths
@property
def new_revision(self):
return uuid.uuid4().hex
@cached_property
def content_type_id(self):
return ContentType.objects.get_for_model(Directory).id
def get_revisions(self, parents, keys=None):
return Revision.objects.filter(
content_type_id=self.content_type_id,
key__in=keys or [""],
object_id__in=parents)
def update(self, keys=None):
parents = list(self.parents.values_list("id", flat=True))
revisions = self.get_revisions(parents, keys=keys)
missing_revisions = []
existing_ids = []
revision_map = {
'%s-%s' % (x['object_id'], x['key']): x['id']
for x in revisions.values("id", "object_id", "key")}
for parent in parents:
for key in keys or [""]:
id = '%s-%s' % (parent, key)
if id in revision_map:
existing_ids.append(revision_map[id])
else:
missing_revisions.append(dict(
object_id=parent,
key=key))
new_revision = self.new_revision
updates = {
id: dict(value=new_revision)
for id in existing_ids}
if updates:
update.send(
Revision,
updates=updates)
if missing_revisions:
create.send(
Revision,
objects=list(
self.create_missing_revisions(
missing_revisions, new_revision)))
def create_missing_revisions(self, missing_revisions, new_revision):
for revision in missing_revisions:
yield Revision(
content_type_id=self.content_type_id,
object_id=revision['object_id'],
key=revision['key'],
value=new_revision)
class UnitRevisionUpdater(RevisionUpdater):
related_pootle_path = "store__parent__pootle_path"
@property
def context_path(self):
return self.context.store.parent.pootle_path
class StoreRevisionUpdater(RevisionUpdater):
related_pootle_path = "parent__pootle_path"
@property
def context_path(self):
return self.context.parent.pootle_path
class DirectoryRevisionUpdater(RevisionUpdater):
related_pootle_path = "pootle_path"
@property
def context_path(self):
return self.context.pootle_path
class ProjectRevisionUpdater(RevisionUpdater):
related_pootle_path = "pootle_path"
@property
def context_path(self):
return self.context.pootle_path
def get_parent_paths(self, pootle_paths):
paths = set(["/projects/"])
projects = set()
for pootle_path in pootle_paths:
lang_code, proj_code, dir_path, __ = split_pootle_path(pootle_path)
paths.add("/projects/%s/" % proj_code)
projects.add(proj_code)
tps = TranslationProject.objects.filter(
project__code__in=projects).values_list("language__code", flat=True)
for lang_code in tps.iterator():
paths.add("/%s/" % lang_code)
return paths
| 7,623
|
Python
|
.py
| 201
| 27.975124
| 80
| 0.602117
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,497
|
__init__.py
|
translate_pootle/pootle/apps/pootle_revision/__init__.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
default_app_config = 'pootle_revision.apps.PootleRevisionConfig'
| 341
|
Python
|
.py
| 8
| 41.5
| 77
| 0.771084
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,498
|
0001_initial.py
|
translate_pootle/pootle/apps/pootle_revision/migrations/0001_initial.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.9.10 on 2016-10-22 05:26
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
('contenttypes', '0002_remove_content_type_name'),
]
operations = [
migrations.CreateModel(
name='Revision',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('object_id', models.CharField(blank=True, max_length=255, null=True, verbose_name='object ID')),
('key', models.CharField(blank=True, db_index=True, max_length=255, null=True, verbose_name='Revision key')),
('value', models.CharField(default='', max_length=255, verbose_name='Revision hash or numeric marker')),
('content_type', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='content_type_set_for_revision', to='contenttypes.ContentType', verbose_name='content type')),
],
options={
'ordering': ['pk'],
'abstract': False,
'db_table': 'pootle_revision',
},
),
migrations.AlterUniqueTogether(
name='revision',
unique_together=set([('content_type', 'object_id', 'key')]),
),
migrations.AlterIndexTogether(
name='revision',
index_together=set([('object_id', 'content_type', 'key')]),
),
]
| 1,632
|
Python
|
.py
| 35
| 36.542857
| 226
| 0.599623
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|
15,499
|
models.py
|
translate_pootle/pootle/apps/virtualfolder/models.py
|
# -*- coding: utf-8 -*-
#
# Copyright (C) Pootle contributors.
#
# This file is a part of the Pootle project. It is distributed under the GPL3
# or later license. See the LICENSE file for a copy of the license and the
# AUTHORS file for copyright and authorship information.
from django.core.exceptions import ValidationError
from django.db import models
from django.utils.functional import cached_property
from pootle.core.markup import MarkupField, get_markup_filter_display_name
from pootle.i18n.gettext import ugettext_lazy as _
from pootle_language.models import Language
from pootle_project.models import Project
from pootle_store.models import Store
from .delegate import path_matcher
class VirtualFolder(models.Model):
# any changes to the `name` field may require updating the schema
# see migration 0003_case_sensitive_schema.py
name = models.CharField(
_('Name'),
blank=False,
unique=True,
max_length=70)
title = models.CharField(
_('Title'),
blank=True,
null=True,
max_length=255)
filter_rules = models.TextField(
# Translators: This is a noun.
_('Filter'),
blank=False,
help_text=_('Filtering rules that tell which files this virtual '
'folder comprises.'),
)
priority = models.FloatField(
_('Priority'),
default=1,
help_text=_('Number specifying importance. Greater priority means it '
'is more important.'),
)
is_public = models.BooleanField(
_('Is public?'),
default=True,
help_text=_('Whether this virtual folder is public or not.'),
)
description = MarkupField(
_('Description'),
blank=True,
help_text=_('Use this to provide more information or instructions. '
'Allowed markup: %s', get_markup_filter_display_name()),
)
stores = models.ManyToManyField(
Store,
db_index=True,
related_name='vfolders')
all_projects = models.BooleanField(default=False)
projects = models.ManyToManyField(
Project,
db_index=True,
related_name='vfolders')
all_languages = models.BooleanField(default=False)
languages = models.ManyToManyField(
Language,
db_index=True,
related_name='vfolders')
@cached_property
def path_matcher(self):
return path_matcher.get(self.__class__)(self)
def __unicode__(self):
return self.name
def save(self, *args, **kwargs):
# Force validation of fields.
self.clean_fields()
self.name = self.name.lower()
super(VirtualFolder, self).save(*args, **kwargs)
def clean_fields(self):
"""Validate virtual folder fields."""
if self.priority <= 0:
raise ValidationError(u'Priority must be greater than zero.')
if not self.filter_rules:
raise ValidationError(u'Some filtering rule must be specified.')
| 3,012
|
Python
|
.py
| 83
| 29.313253
| 78
| 0.657182
|
translate/pootle
| 1,486
| 288
| 526
|
GPL-3.0
|
9/5/2024, 5:11:58 PM (Europe/Amsterdam)
|