def test_translated(self):
self.assertEqual('{"a": "b"}', json.dumps({'a': _l('b')}, cls=LazyEncoder))
# these are just here to improve branch coverage :-)
self.assertEqual('{"a": "b"}', json.dumps({'a': _('b')}, cls=LazyEncoder))
self.assertEqual('{"a": "2016-03-26T00:00:00"}',
json.dumps({'a': datetime(2016, 3, 26)}, cls=LazyEncoder))
def getIdpsByCategory(self, lang=None, exclude=None):
"""Returns a sequence of tuples of the form:
(category, [ idp1, idp2, ...])
where idpX is a dict { 'name': name, 'id': entityid }
The list of idps is sorted by name
"""
if not lang:
lang = get_language()
if exclude:
validcats = filter(lambda x: x[0] not in exclude, institution_categories)
else:
validcats = institution_categories
cats = map(lambda x: x[0], validcats)
categories = map(lambda x: {'id': x[0], 'name': _l(x[1])}, validcats)
idps = []
# if no valid categories are found, return all idp's
if not validcats:
catidps = self.getEntities()
return [('institutions', catidps)]
for category in cats:
catidps = sorted(self.getCategoryIdps(category))
idps.append(map(lambda x: {'name': x.getName(lang), 'url': x.getURL(lang), 'id': x.id}, catidps))
return zip(categories, idps)
def data_sharing(self, obj):
dsp = obj.get_data_sharing_page()
if dsp:
pvr = PageViewRestriction.objects.filter(page=dsp).first()
if pvr:
return pvr.password
else:
return None
else:
return mark_safe('<em>{}</em>'.format(_l('No data sharing')))
class SskExternalAttendee(CourseAttendee, AbstractCertificateInformationMixin,
InvoiceMixin):
class Meta:
verbose_name = _l(
'External participant for course with official certificate')
identifier = 'sskexternal'
display_name = _l('External')
display_name_plural = _l('Externals')
additional_admin_fields = (
('invoice_company', _('company')),
('payed', _('has payed')),
)
forms = [
'courses.forms.SskExternalDataForm',
'courses.forms.SskExternalAttendeeCertificateForm',
'courses.forms.SskExternalAttendeInvoiceForm',
'courses.forms.SskExternalAttendeeTermsAndConditionsForm'
]
class AssignedQCDetailsFilter(UnitTestCollectionFilter):
refs_tols = django_filters.filters.ChoiceFilter(
label=_l("References & Tolerances"),
choices=[
("both", _l("Both")),
("refs_tols_set", _l("Only Tests with Refs/Tols")),
("refs_tols_not_set", _l("Only Tests without Refs/Tols")),
],
required=True,
initial="both",
help_text=_l(
"Select whether you want to include tests with a Reference or Tolerance Set, Not Set, or Both"
),
)
class Meta:
model = models.UnitTestCollection
fields = ["unit__site", "unit", "frequency", "assigned_to", "active"]
class CommonSettingsForm(SettingsForm):
""" Configures common or generic settings that don't belong elsewhere. """
pipelines_disabled = forms.BooleanField(required=False,
label=_l("Pipelines are disabled upon creation?"))
recover_request_notification_url = forms.URLField(required=False,
label=_('Recovery request: URL to notify'))
recover_request_notification_auth_username = forms.CharField(required=False,
label=_('Recovery request notification: Username (optional)'))
recover_request_notification_auth_password = forms.CharField(required=False,
label=_('Recovery request notification: Password (optional)'))
class Quarto(models.Model):
class Meta:
verbose_name = _l('Quarto')
verbose_name_plural = _l('Quartos')
def __str__(self):
return str(self.numero)
numero = models.IntegerField(
verbose_name=_l('Número do quarto'),
validators=[MinValueValidator(1)]
)
status = models.ForeignKey(
StatusQuarto,
verbose_name=_l('Situação do quarto'),
on_delete=models.PROTECT
)
class Supplier(models.Model):
name = models.CharField(
verbose_name=_l("supplier"),
max_length=32,
unique=True,
help_text=_l("Enter a unique name for this supplier"),
)
address = models.TextField(
verbose_name=_l("address"),
blank=True,
)
phone_number = models.CharField(
verbose_name=_l("phone number"),
blank=True,
max_length=31,
help_text=_l("Company phone number"),
)
website = models.URLField(
verbose_name=_l("website"),
blank=True,
help_text=_l("Enter a URL for the company"),
)
notes = models.TextField(
verbose_name=_l("notes"),
max_length=255,
blank=True,
null=True,
help_text=_l('Additional comments about this supplier'),
)
class Meta:
ordering = ('name', )
def get_absolute_url(self):
return reverse("supplier_details", kwargs={"pk": self.pk})
def get_website_tag(self):
if self.website:
return format_html('<a href="%s" title="%s">%s</a>' % (
self.website,
_("Click to visit this suppliers website"),
self.website,
))
return ""
def __str__(self):
return self.name
def test_translated(self):
self.assertEqual('{"a": "b"}',
json.dumps({'a': _l('b')}, cls=LazyEncoder))
# these are just here to improve branch coverage :-)
self.assertEqual('{"a": "b"}',
json.dumps({'a': _('b')}, cls=LazyEncoder))
self.assertEqual(
'{"a": "2016-03-26T00:00:00"}',
json.dumps({'a': datetime(2016, 3, 26)}, cls=LazyEncoder))
class Event(models.Model):
""" Stores requests to modify packages that need admin approval.
Eg. delete AIP can be requested by a pipeline, but needs storage
administrator approval. Who made the request and why is also stored. """
package = models.ForeignKey('Package', to_field='uuid')
DELETE = 'DELETE'
RECOVER = 'RECOVER'
EVENT_TYPE_CHOICES = (
(DELETE, _l('delete')),
(RECOVER, _l('recover')),
)
event_type = models.CharField(max_length=8, choices=EVENT_TYPE_CHOICES)
event_reason = models.TextField()
pipeline = models.ForeignKey('Pipeline', to_field='uuid')
user_id = models.PositiveIntegerField()
user_email = models.EmailField(max_length=254)
SUBMITTED = 'SUBMIT'
APPROVED = 'APPROVE'
REJECTED = 'REJECT'
EVENT_STATUS_CHOICES = (
(SUBMITTED, _l('Submitted')),
(APPROVED, _l('Approved')),
(REJECTED, _l('Rejected')),
)
status = models.CharField(max_length=8, choices=EVENT_STATUS_CHOICES)
status_reason = models.TextField(null=True, blank=True)
admin_id = models.ForeignKey(settings.AUTH_USER_MODEL,
null=True,
blank=True)
status_time = models.DateTimeField(auto_now=True)
store_data = models.TextField(null=True, blank=True, editable=False)
class Meta:
verbose_name = _l("Event")
app_label = 'locations'
def __unicode__(self):
return _(u"%(event_status)s request to %(event_type)s %(package)s") % {
'event_status': self.get_status_display(),
'event_type': self.get_event_type_display(),
'package': self.package
}
class ProjectModelAdmin(ModelAdmin):
model = Project
menu_label = _l('Projects')
menu_icon = ' icon-fa-calendar'
list_display = ('title', 'active_since', 'expires_at', 'workgroup',
'public')
index_view_extra_js = ['js/admin/fix_admin_headers.js']
menu_order = 400
exclude_from_explorer = False
list_filter = (ProjectExpiredFilter, )
button_helper_class = ProjectButtonHelper
inspect_view_enabled = True
inspect_view_class = ProjectInspectView
inspect_template_name = 'userinput/admin/inspect_project.html'
def active_since(self, obj):
return obj.go_live_at
active_since.short_description = _l('active since')
def expires_at(self, obj):
return obj.expire_at
expires_at.short_description = _l('Will expire at')
def workgroup(self, obj):
try:
return "{}: {}".format(obj.get_workgroup().get_head().full_name(),
obj.get_workgroup_info())
except:
return "{}".format(
# obj.get_workgroup().get_head().full_name(),
obj.get_workgroup_info())
workgroup.short_description = _l('Workgroup')
def public(self, obj):
if obj.is_confidential:
return _l("No")
else:
return _l("Yes")
public.short_description = _l('public')
class SskStudentAttendee (
AbstractStudentAttendee, AbstractCertificateInformationMixin
):
class Meta:
verbose_name = _l( 'student for course with official certificate' )
identifier = 'sskstudent'
display_name =_l('Student')
display_name_plural =_l('Students')
forms = [
'courses.forms.RUBIDForm',
'courses.forms.SskStudentForm',
'courses.forms.SskStudentCertificateForm',
'courses.forms.SskStudentTermsAndConditionsForm'
]
additional_admin_fields = (
('student_course', _('student course')),
)
def clean_cep(self):
"""
Remove a máscara do campo
"""
cep = self.cleaned_data.get('cep')
if cep:
return cep.replace("-", "")
raise ValidationError(
_l('O campo de CEP é de preenchimento obrigatório.'))
class NotificationRelatedObject(BaseModel):
"""
Represents named object related to a notification. This object can be then referenced in notification template
fields.
Attributes:
name: String identificator of the object (for referencing in templates).
notification: Related notification.
content_object: The related object itself.
"""
name = models.CharField(max_length=200, verbose_name=_l('name'))
notification = models.ForeignKey(
Notification,
on_delete=models.CASCADE,
related_name='related_objects',
verbose_name=_l('notification'),
)
content_type = models.ForeignKey(ContentType, null=True, on_delete=models.SET_NULL, verbose_name=_l('content type'))
object_id = models.TextField(db_index=True, verbose_name=_l('object ID'))
content_object = GenericForeignKey('content_type', 'object_id')
class SingleButtonMixin(object):
action_text = _l('Save')
def __init__(self, *args, **kwargs):
super(SingleButtonMixin, self).__init__(*args, **kwargs)
self.helper = getattr(self, 'helper', FormHelper(self))
self.helper.layout.append(
FormActions(
Submit('action', self.action_text, css_class="btn-primary"),
)
)
class IDCardNoValidator(object):
"""
Czech id card number field validator.
"""
error_messages = {
'invalid_format': _l('Enter an ID card in the format XXXXXXXXX.'),
'invalid': _l('Enter a valid ID card number.'),
}
ID_CARD_NUMBER = re.compile(r'^\d{9}$')
def __call__(self, value):
value = force_text(value)
match = re.match(self.ID_CARD_NUMBER, value)
if not match:
raise ValidationError(self.error_messages[INVALID_FORMAT], code=INVALID_FORMAT)
elif value[0] == '0':
raise ValidationError(self.error_messages[INVALID], code=INVALID)
else:
return value
class CustomLoginForm(SingleButtonMixin, LoginForm):
action_text = _l('Sign In')
def __init__(self, *args, **kwargs):
super(CustomLoginForm, self).__init__(*args, **kwargs)
self.fields['login'].label = _('Login')
self.helper.form_class = 'login-form'
self.helper.layout = Layout(
PrependedText('login', '<i class="fa fa-user"></i>'),
PrependedText('password', '<i class="fa fa-key"></i>', type='password')
)
class PasswordResetSuccessView(View):
breadcrumb = _l("")
def get(self, request):
# TODO unfortunately the extra_context is omitted and not provided
return password_reset_done(request,
'registration/password_reset_done.html')
def post(self, request):
return password_reset_done(request,
'registration/password_reset_done.html')
class SEScheduleSiteFilter(q_admin.SiteFilter):
title = _l('Site')
parameter_name = "sitefilter"
def queryset(self, request, queryset):
if self.value():
return queryset.filter(unit_service_area__unit__site=self.value())
return queryset
class PublicationsMA(ModelAdmin):
model = PublicationSnippet
list_display = ('_title', 'year', 'journal', 'ag')
def _title(self, obj):
if obj.doi:
return mark_safe(
'<a href="https://doi.org/{doi}" target="_new">{title}</a>'.
format(doi=obj.doi, title=obj.title))
return obj.title
_title.short_description = _l('title')
_title.admin_order_field = 'title'
def ag(self, obj):
return mark_safe(
get_project_and_group(Project2PublicationRelation, obj))
ag.short_description = format_lazy('{}/{}', _l('Project'), _l('workgroup'))
class CourseInformationPageModelAdmin(ModelAdmin):
model = CourseInformationPage
menu_label = _l('courses')
menu_icon = 'fa-calendar'
exclude_from_explorer = True
list_display = ('_title', )
def _title(self, obj):
return obj.title_trans
_title.short_description = _('Title')
class SuccessView(LoginRequiredMixin, View):
breadcrumb = _l("")
def get(self, request):
try:
invite_list = request.session['invite_list']
request.session.pop('invite_list', None)
request.session.modified = True
except:
invite_list = []
return render(request, 'invite_users/successfully_invited.html', {'invite_list': invite_list})
class ProjectDetailTimelogView(LoginRequiredMixin, UserPassesTestMixin,
TemplateView):
template_name = 'project/project_timelog.html'
breadcrumb = _l("")
def dispatch(self, request, *args, **kwargs):
proj = get_r_object_or_404(self.request.user,
Project,
name_short=self.kwargs.get('project'))
if not request.user.is_authenticated:
return super(ProjectDetailTimelogView,
self).dispatch(request, *args, **kwargs)
elif proj.activity_only_for_managers and not proj.is_manager(
self.request.user):
return HttpResponseRedirect(
reverse_lazy('project:usertimelog',
kwargs={
'project': proj.name_short,
'username': self.request.user.username
}))
return super(ProjectDetailTimelogView,
self).dispatch(request, *args, **kwargs)
def get_context_data(self, **kwargs):
context = super(ProjectDetailTimelogView,
self).get_context_data(**kwargs)
context['project'] = get_r_object_or_404(
self.request.user, Project, name_short=self.kwargs.get('project'))
devs = context['project'].get_members()
context['logs'] = []
devs = serializers.serialize("json", devs, fields=('username'))
devs = json.loads(devs)
for dev in devs:
logs = Timelog.objects.filter(
user=dev['pk'],
issue__project=context['project']).order_by('-created_at')
total_time = timedelta(0)
for l in logs:
total_time += l.time
dev['fields']['total'] = total_time
dev['fields']['logs'] = logs[:5]
dev['fields']['ava_url'] = context['project'].get_members().filter(
username=dev['fields']['username']).first().avatar.url
context['developer'] = sorted(devs,
key=lambda dev: dev['fields']['total'],
reverse=True)
return context
def test_func(self):
return get_r_object_or_404(self.request.user,
Project,
name_short=self.kwargs.get('project'))
class ProjectUserTimelogView(LoginRequiredMixin, UserPassesTestMixin,
TemplateView):
template_name = 'project/project_timelog_detail.html'
breadcrumb = _l("")
def dispatch(self, request, *args, **kwargs):
proj = get_r_object_or_404(self.request.user,
Project,
name_short=self.kwargs.get('project'))
if not request.user.is_authenticated:
return super(ProjectUserTimelogView,
self).dispatch(request, *args, **kwargs)
elif (proj.activity_only_for_managers
and not proj.is_manager(request.user)
and request.user.username != self.kwargs.get('username')):
return HttpResponseRedirect(
reverse_lazy('project:usertimelog',
kwargs={
'project': proj.name_short,
'username': self.request.user.username
}))
return super(ProjectUserTimelogView,
self).dispatch(request, *args, **kwargs)
def get_context_data(self, **kwargs):
context = super(ProjectUserTimelogView,
self).get_context_data(**kwargs)
context['project'] = Project.objects.get(
name_short=self.kwargs.get('project'))
logs = Timelog.objects.filter(
user__username=kwargs['username'],
issue__project=context['project']).order_by('-created_at')
dev = context['project'].get_members().filter(
username=self.kwargs.get('username'))
if dev.count() != 1:
raise Http404
paginator = Paginator(logs, 20)
page = self.request.GET.get('page')
try:
logs = paginator.page(page)
except PageNotAnInteger:
logs = paginator.page(1)
except EmptyPage:
logs = paginator.page(paginator.num_pages)
context['logs'] = logs
context['ava_url'] = dev.first().avatar.url
context['user'] = kwargs['username']
return context
def test_func(self):
return get_r_object_or_404(self.request.user,
Project,
name_short=self.kwargs.get('project'))
class FundingMA(ModelAdmin):
model = FundingSnippet
list_display = ('_agency', '_title', 'ag')
def _agency(self, obj):
agency = obj.agency
if obj.project_number:
return mark_safe('{agency}<br />{num}'.format(
agency=agency, num=obj.project_number))
else:
return agency
_agency.admin_order_field = 'agency'
def _title(self, obj):
title = obj.title
if not title:
if obj.title_en:
title = obj.title_en
elif obj.title_de:
title = obj.title_de
if obj.project_url:
if obj.project_url.startswith(
'http://') or obj.project_url.startswith('https://'):
url = obj.project_url
else:
url = 'http://{}'.format(obj.project_url)
return mark_safe(
'<a href="{url}" target="_new">{title}</a>'.format(
url=url, title=title))
else:
return title
_title.short_description = _l('title')
def ag(self, obj):
return mark_safe(get_project_and_group(Project2FundingRelation, obj))
ag.short_description = format_lazy('{}/{}', _l('Project'), _l('workgroup'))
class Hours(models.Model):
service_event = models.ForeignKey(
ServiceEvent,
on_delete=models.CASCADE,
verbose_name=_l("service event"),
)
third_party = models.ForeignKey(
ThirdParty,
null=True,
blank=True,
on_delete=models.PROTECT,
verbose_name=_l("third party"),
)
user = models.ForeignKey(
User,
null=True,
blank=True,
on_delete=models.PROTECT,
verbose_name=_l("user"),
)
time = models.DurationField(
_l("time"),
help_text=_l('The time this person spent on this service event'),
)
class Meta:
verbose_name = _l("hours")
verbose_name_plural = _l("hours")
unique_together = (
'service_event',
'third_party',
'user',
)
default_permissions = ()
permissions = (("can_have_hours", _l("Can have hours")), )
def user_or_thirdparty(self):
return self.user or self.third_party
class PartUsed(models.Model):
service_event = models.ForeignKey(
sl_models.ServiceEvent,
verbose_name=_l("service event"),
help_text=_l("Select the Service Event the part was used in"),
on_delete=models.CASCADE,
)
part = models.ForeignKey(
Part,
verbose_name=_l("part"),
help_text=_l('Select the part used'),
on_delete=models.CASCADE,
)
from_storage = models.ForeignKey(
Storage,
verbose_name=_l("from storage"),
help_text=_l('Select which Storage the parts were taken from'),
null=True,
blank=True,
on_delete=models.SET_NULL,
)
quantity = models.IntegerField(
verbose_name=_l("quantity"),
help_text=_l('Select how many parts were used from this Storage'),
)
def add_back_to_storage(self):
if self.from_storage:
try:
psc = PartStorageCollection.objects.get(
part=self.part, storage=self.from_storage)
psc.quantity += self.quantity
psc.save()
except PartStorageCollection.DoesNotExist:
PartStorageCollection.objects.create(part=self.part,
storage=self.from_storage,
quantity=self.quantity)
def remove_from_storage(self):
if self.from_storage:
try:
psc = PartStorageCollection.objects.get(
part=self.part, storage=self.from_storage)
psc.quantity -= self.quantity
psc.save()
except PartStorageCollection.DoesNotExist:
pass
class Contact(models.Model):
supplier = models.ForeignKey(
Supplier,
verbose_name=_("supplier"),
on_delete=models.CASCADE,
)
first_name = models.CharField(
max_length=64,
verbose_name=_("first name"),
help_text=_l("Enter this persons first name"),
)
last_name = models.CharField(
max_length=64,
verbose_name=_("last name"),
help_text=_l("Enter this persons last name"),
)
email = models.EmailField(
verbose_name=_("email"),
help_text=_l("Enter this persons email address"),
)
phone_number = models.CharField(
verbose_name=_l("phone number"),
blank=True,
max_length=31,
help_text=_l("Contact phone number"),
)
class Meta:
verbose_name = _l('Contact')
verbose_name_plural = _l('Contacts')
unique_together = ('first_name', 'last_name', 'supplier')
def __str__(self):
return self.last_name + ', ' + self.first_name + ' (' + self.supplier.name + ')'
def get_full_name(self):
return str(self)
class RUBIONUserInstrumentFilter(RAIFilter,
metaclass=RUBIONUserInstrumentFilterMeta):
label = _l('Used instruments')
filter_id = 'user_instrument'
is_mutual_exclusive = False
help_text = _l('Filter users by their usage of instruments')
def __init__(self, qs, value=None):
super().__init__(qs, value)
if self.value is not None:
values = [int(val) for val in self.value]
self.value = values
def get_queryset(self):
"""
Filters the users by their instrument usage
"""
i2prfield = 'method2instrumentrelation_set__method__project2methodrelation_set__project_page'
i2prval = 'method2instrumentrelation__method__project2methodrelation__project_page'
instruments = InstrumentPage.objects.filter(pk__in=self.value)
project_pks = instruments.prefetch_related(i2prfield).values_list(
i2prval, flat=True).distinct()
# the paths for the projects
project_paths = Project.objects.filter(pk__in=project_pks,
locked=False).values_list(
'path', flat=True)
# In the tree, a project is 2 levels deeper than a workgroup, and one level is 4 digits in the
# path. Thus, project_path[0:-8] gives the workgroups
# use list(set(...)) to include only unique values
workgroup_paths = list(set([pp[0:-8] for pp in project_paths]))
# now make a Q-object from the paths
q = Q()
for wg in workgroup_paths:
q |= Q(path__startswith=wg)
return self.qs.filter(q)
class TranslationListSerializer(serializers.ListSerializer):
'A custom serializer to output translations in a nice dict'
many = True
default_error_messages = {
'not_a_dict':
_l('Expected a dictionary of items, but got a {input_type}.'),
}
def to_internal_value(self, data):
if not isinstance(data, dict):
message = self.error_messages['not_a_dict'].format(
input_type=type(data).__name__)
raise ValidationError(
{api_settings.NON_FIELD_ERRORS_KEY: [message]})
ret, errors = {}, {}
for language, translation in data.items():
try:
validated = self.child.run_validation(translation)
except ValidationError as exc:
errors[language] = exc.detail
else:
ret[language] = validated
errors[language] = {}
if any(errors.values()):
raise ValidationError(errors)
return ret
def get_attribute(self, instance):
''' Override get_attribute so it returns the whole translatable model and not just translations '''
return instance
def to_representation(self, instance):
''' Combine each translation in turn so the serializer has a full object '''
result = {}
stashed = get_cached_translation(instance)
for translation in getattr(instance, self.source).all():
set_cached_translation(instance, translation)
result[translation.language_code] = self.child.to_representation(
instance)
set_cached_translation(instance, stashed)
return result
def save(self, *args, **kwargs): #pragma: no cover
raise NotImplementedError('TranslationList must be nested')
@property
def data(self): #pragma: no cover
raise NotImplementedError('TranslationList must be nested')
@property
def errors(self): #pragma: no cover
raise NotImplementedError('TranslationList must be nested')
class ActiveDirectoryGroupMapAdmin(BaseQATrackAdmin):
list_display = ("get_ad_group", "get_groups", "account_qualifier")
list_filter = (
"groups",
"account_qualifier",
)
search_fields = ("ad_group", "groups__name")
def get_groups(self, obj):
return ', '.join(sorted(obj.groups.values_list("name", flat=True)))
get_groups.short_description = _l("QATrack+ Groups")
@mark_safe
def get_ad_group(self, obj):
if not obj.ad_group:
return '<em>' + _("Default Groups") + "</em>"
return escape(obj.ad_group)
get_ad_group.short_description = _l("Active Directory Group Name")
class PackageDownloadTask(models.Model):
uuid = UUIDField(editable=False,
unique=True,
version=4,
help_text=_l("Unique identifier"))
package = models.ForeignKey('Package', to_field='uuid')
downloads_attempted = models.IntegerField(default=0)
downloads_completed = models.IntegerField(default=0)
download_completion_time = models.DateTimeField(default=None,
null=True,
blank=True)
class Meta:
verbose_name = _l("Package Download Task")
app_label = 'locations'
def __unicode__(self):
return _(u'PackageDownloadTask ID: %(uuid)s for %(package)s') % {
'uuid': self.uuid,
'package': self.package
}
COMPLETE = 'complete'
INCOMPLETE = 'incomplete'
FAILED = 'failed'
def downloading_status(self):
"""
In order to determine the downloading status we need to check
for three possibilities:
1) The task involved no downloads. The downloads_attempted
DB row column should be 0. This would be unusual, however,
as there's no reason to make a task if not attempting
to download anything.
2) The task is downloading, but the downloading is not
yet complete. downloads_attempted is greater than 0, but
download_completion_time is not set.
3) The task finished downloading and completed successfully.
download_completion_time is set. downloads_attempted is
equal to downloads_completed.
4) The task finished downloading and completed unsuccessfully.
download_completion_time is set. downloads_attempted isn't
equal to downloads_completed.
"""
if self.downloads_attempted == 0:
return self.COMPLETE
elif self.download_completion_time is None:
return self.INCOMPLETE
elif self.downloads_attempted == self.downloads_completed:
return self.COMPLETE
else:
return self.FAILED
def bootstrap_paginator(page_obj, link = None, href = None, page_dist = 2):
control_last_page = page_obj.number + page_dist
if control_last_page > page_obj.paginator.num_pages:
control_last_page = page_obj.paginator.num_pages
first_page = page_obj.number - 1 - page_dist
if control_last_page - 1 - (page_dist * 2) < first_page:
first_page = control_last_page - 1 - (page_dist * 2)
if first_page < 0:
first_page = 0
last_page = first_page + (page_dist * 2) + 1
page_range = page_obj.paginator.page_range[first_page:last_page]
if not link and not href:
raise ImproperlyConfigured(_l("both arguments \"link\" and \"href\" shouldn't be None. Please provide a \"link\" or \"href\" argument."))
return {"page_obj": page_obj, "link": link, "href": href, "page_range": page_range}
(PURPOSE_SET_PASSWORD, 'set password'),
(PURPOSE_SET_EMAIL, 'set email'),
(PURPOSE_DELETE, 'delete'),
)
PURPOSE_DICT = dict(PURPOSE_CHOICES)
REGISTRATION_CHOICES = (
(REGISTRATION_WEBSITE, 'Via Website'),
(REGISTRATION_INBAND, 'In-Band Registration'),
(REGISTRATION_UNKNOWN, 'Unknown'),
)
REGISTRATION_DICT = dict(REGISTRATION_CHOICES)
PURPOSES = {
PURPOSE_REGISTER: {
'urlname': 'RegistrationConfirmation',
'subject': _l('Your new account on %(domain)s'),
'template': 'register/mail',
},
PURPOSE_SET_EMAIL: {
'urlname': 'ResetEmailConfirmation',
'subject': _l('Confirm the email address for your %(domain)s account'),
'template': 'reset/email-mail',
},
PURPOSE_SET_PASSWORD: {
'urlname': 'ResetPasswordConfirmation',
'subject': _l('Reset the password for your %(domain)s account'),
'template': 'reset/password-mail',
},
PURPOSE_DELETE: {
'urlname': 'DeleteConfirmation',
'subject': _l('Delete your account on %(domain)s'),
REGISTRATION_CHOICES = (
(REGISTRATION_WEBSITE, 'Via Website'),
(REGISTRATION_INBAND, 'In-Band Registration'),
(REGISTRATION_UNKNOWN, 'Unknown'),
)
REGISTRATION_DICT = dict(REGISTRATION_CHOICES)
PURPOSES = {
NEW_PURPOSE_REGISTER: {
'subject': _('Your new account on %(domain)s'),
},
NEW_PURPOSE_SET_PASSWORD: {
'subject': _('Reset the password for your %(domain)s account'),
},
NEW_PURPOSE_SET_EMAIL: {
'subject': _l('Confirm the email address for your %(domain)s account'),
},
NEW_PURPOSE_DELETE: {
'subject': _l('Delete your account on %(domain)s'),
},
}
log = logging.getLogger(__name__)
pgp_version = MIMENonMultipart('application', 'pgp-encrypted')
pgp_version.add_header('Content-Description', 'PGP/MIME version identification')
pgp_version.set_payload('Version: 1\n')
@python_2_unicode_compatible
class RegistrationUser(XmppBackendUser):
# NOTE: MySQL only allows a 255 character limit
