def __unicode__(self):
unr = UslugaNaRezerwacji.objects.filter(rezerwacja=self.rezerwacja)
if unr:
for i in range(0, len(unr)):
if unr[i] == self:
return _u('Usluga %d') % (i+1,)
return _u('Usluga na rezerwacji')
class Feedback(UUIDModel, TimeStampedModel):
HAPPY = 1
GOOD = 0
SAD = -1
SERVICE_CHOICES = ((HAPPY, _u("Happy")), (GOOD, _u("Good")), (SAD,
_u("Sad")))
user = models.ForeignKey(User,
related_name="user_feedbacks",
on_delete=models.CASCADE)
realty = models.ForeignKey(Realty,
related_name="realty_feedbacks",
on_delete=models.CASCADE)
service_rate = models.CharField(max_length=1,
choices=SERVICE_CHOICES,
default=GOOD)
rating = models.IntegerField(validators=[
MinValueValidator(1, message=_u("Minimun rate is 1")),
MaxValueValidator(5, message=_u("Maximum rate is 5")),
])
review = models.TextField(max_length=300)
def __str__(self):
return self.user.username + "-" + self.realty.name
def __unicode__(self):
pnr = PokojNaRezerwacji.objects.filter(rezerwacja=self.rezerwacja)
# Na wszelki wypadek jesli z jakiegos powodu jest 0
if pnr:
for i in range(0, len(pnr)):
if pnr[i] == self:
return _u('Pokoj %d') % (i+1,)
return _u('Pokoj na rezerwacji')
def update(self, request, *args, **kwargs):
task = self.get_object()
if task.state != Task.NEW:
raise NotAcceptable(_u("You can't edit task."))
if task.state == Task.DONE:
raise PermissionDenied(_u("Task Done"))
serializer = self.get_serializer(task, data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(_u("Task updated successfully!"))
def create_superuser(self, email, password, **extra_fields):
"""
Create and save a SuperUser with the given email and password.
"""
extra_fields.setdefault('is_staff', True)
extra_fields.setdefault('is_superuser', True)
extra_fields.setdefault('is_active', True)
if extra_fields.get('is_staff') is not True:
raise ValueError(_u('Superuser must have is_staff=True.'))
if extra_fields.get('is_superuser') is not True:
raise ValueError(_u('Superuser must have is_superuser=True.'))
return self.create_user(email, password, **extra_fields)
def load_or_create(cls, protein_name, user):
# extract Uniprot accession data from the measurement name, if present
accession_match = cls.accession_pattern.match(protein_name)
proteins = cls.objects.none()
if accession_match:
short_name = accession_match.group(1)
proteins = cls.objects.filter(short_name=short_name)
else:
proteins = cls.objects.filter(short_name=protein_name)
# force query to LIMIT 2
proteins = proteins[:2]
if len(proteins) > 1:
# fail if protein couldn't be uniquely matched
raise ValidationError(
_u('More than one match was found for protein name "%(type_name)s".'
) % {
'type_name': protein_name,
})
elif len(proteins) == 0:
# try to create a new protein
link = ProteinStrainLink()
if accession_match:
# if it looks like a UniProt ID, look up in UniProt
short_name = accession_match.group(1)
accession_id = protein_name
return cls._load_uniprot(short_name, accession_id)
elif link.check_ice(user.email, protein_name):
# if it is found in ICE, create based on ICE info
return cls._load_ice(link)
elif getattr(settings, 'REQUIRE_UNIPROT_ACCESSION_IDS', True):
raise ValidationError(
_u('Protein name "%(type_name)s" is not a valid UniProt accession id.'
) % {
'type_name': protein_name,
})
logger.info('Creating a new ProteinIdentifier for %(name)s' % {
'name': protein_name,
})
# not requiring accession ID or ICE entry; just create protein with arbitrary name
datasource = Datasource.objects.create(name=user.username,
url=user.email)
return cls.objects.create(
type_name=protein_name,
short_name=protein_name,
accession_id=protein_name,
type_source=datasource,
)
return proteins[0]
def load_or_create(cls, pubchem_cid):
match = cls.pubchem_pattern.match(pubchem_cid)
if match:
cid = match.group(1)
# try to find existing Metabolite record
try:
return cls.objects.get(pubchem_cid=cid)
except cls.DoesNotExist:
return cls._load_pubchem(cid)
except Exception:
logger.exception('Error loading Metabolite with cid %s', pubchem_cid)
raise ValidationError(_u('There was a problem looking up %s') % pubchem_cid)
raise ValidationError(
_u('Metabolite lookup failed: %s must match pattern "cid:0000"') % pubchem_cid
)
def load_or_create(cls, pubchem_cid):
match = cls.pubchem_pattern.match(pubchem_cid)
if match:
cid = match.group(1)
label = match.group(2)
# try to find existing Metabolite record
metabolite, created = cls.objects.get_or_create(
pubchem_cid=cid,
defaults={
"carbon_count": 0,
"charge": 0,
"molar_mass": 1,
"molecular_formula": "",
"provisional": True,
"type_group": MeasurementType.Group.METABOLITE,
"type_name": label or "Unknown Metabolite",
},
)
if created:
transaction.on_commit(
lambda: metabolite_load_pubchem.delay(metabolite.pk))
return metabolite
raise ValidationError(
_u('Metabolite lookup failed: {pubchem} must match pattern "cid:0000"'
).format(pubchem=pubchem_cid))
def _load_ice(cls, identifier, user):
try:
return cls.objects.get(type_name=identifier,
strainlink__isnull=False)
except cls.DoesNotExist:
# actually check ICE
link = GeneStrainLink()
if link.check_ice(user.email, identifier):
# save link if found in ICE
datasource = Datasource.objects.create(
name="ICE Registry", url=link.strain.registry_url)
gene = cls.objects.create(
type_name=identifier,
type_source=datasource,
gene_length=link.strain.part.bp_count,
)
link.gene = gene
link.save()
return gene
except Exception:
# fall through to raise ValidationError
pass
raise ValidationError(
_u('Could not load gene "{identifier}"').format(
identifier=identifier))
def _send_decision_email(instance):
""" Send an email to requesting user with the decision made about their request. """
context = {
'name': instance.user.username,
'api_management_url': urlunsplit(
(
'https' if settings.HTTPS == 'on' else 'http',
instance.site.domain,
reverse('api_admin:api-status'),
'',
'',
)
),
'authentication_docs_url': settings.AUTH_DOCUMENTATION_URL,
'api_docs_url': settings.API_DOCUMENTATION_URL,
'support_email_address': settings.API_ACCESS_FROM_EMAIL,
'platform_name': configuration_helpers.get_value('PLATFORM_NAME', settings.PLATFORM_NAME)
}
message = render_to_string(
'api_admin/api_access_request_email_{status}.txt'.format(status=instance.status),
context
)
try:
send_mail(
_u('API access request'),
message,
settings.API_ACCESS_FROM_EMAIL,
[instance.user.email],
fail_silently=False
)
instance.contacted = True
except SMTPException:
log.exception(u'Error sending API user notification email for request [%s].', instance.id)
def _send_new_pending_email(instance):
""" Send an email to settings.API_ACCESS_MANAGER_EMAIL with the contents of this API access request. """
context = {
'approval_url':
urlunsplit((
'https' if settings.HTTPS == 'on' else 'http',
instance.site.domain,
reverse('admin:api_admin_apiaccessrequest_change',
args=(instance.id, )),
'',
'',
)),
'api_request':
instance
}
message = render_to_string(
'api_admin/api_access_request_email_new_request.txt', context)
try:
send_mail(_u(u'API access request from {company}').format(
company=instance.company_name),
message,
settings.API_ACCESS_FROM_EMAIL,
[settings.API_ACCESS_MANAGER_EMAIL],
fail_silently=False)
except SMTPException:
log.exception(
u'Error sending API user notification email for request [%s].',
instance.id)
def logout(request, next_page = None):
if not request.user.is_anonymous:
user_email = request.user.email
user_id = request.user.id
else:
user_email = None
user_id = 0
logout_user(request)
if not user_email is None:
users = User.objects.all().exclude(email = user_email)
else:
users = User.objects.all()
notification = {
"type": "user_status",
"user_id": str(user_id),
"status": _u("Offline"),
"status_class": "",
"remove_class": "away"
}
notification = json.dumps(notification)
for u in users:
Group("user-%s" % u.id).send({'text': notification})
if next_page:
return redirect(next_page)
return redirect(reverse('users:login'))
def _load_pubchem(cls, pubchem_cid):
try:
base_url = 'https://pubchem.ncbi.nlm.nih.gov/rest/pug'
url = '%s/compound/cid/%s/JSON' % (base_url, pubchem_cid)
response = requests.post(url, data={'cid': pubchem_cid})
record = response.json()['PC_Compounds'][0]
properties = {
item['urn']['label']: list(item['value'].values())[0]
for item in record['props']
}
datasource = Datasource.objects.create(name='PubChem', url=url)
return cls.objects.create(
type_name=properties['IUPAC Name'],
short_name=pubchem_cid,
type_source=datasource,
charge=record.get('charge', 0),
carbon_count=len([a for a in record['atoms']['element'] if a == 6]),
molar_mass=properties['Molecular Weight'],
molecular_formula=properties['Molecular Formula'],
smiles=properties['SMILES'],
pubchem_cid=pubchem_cid,
)
except Exception:
logger.exception('Failed loading PubChem %s', pubchem_cid)
raise ValidationError(
_u('Could not load information on %s from PubChem') % pubchem_cid
)
class Transaction(UUIDModel, TimeStampedModel):
PAY_CASH = "c"
PAY_CREDIT = "r"
PAYMENT_CHOICES = (
(PAY_CASH, _u("Cash")),
(PAY_CREDIT, _u("Credit Card")),
)
reservation = models.OneToOneField(
Reservation, related_name="transaction", on_delete=models.CASCADE
)
payment_fees = models.DecimalField(max_digits=12, decimal_places=2, default=0)
paid = models.BooleanField(default=False)
payment_method = models.CharField(
max_length=1, choices=PAYMENT_CHOICES, default=PAY_CASH
)
total_amount = models.DecimalField(max_digits=12, decimal_places=2, default=0)
def _load_fallback(cls, identifier, user):
try:
return cls.objects.get(type_name=identifier, type_source__created__mod_by=user)
except cls.DoesNotExist:
datasource = Datasource.objects.create(name=user.username)
return cls.objects.create(type_name=identifier, type_source=datasource)
except Exception:
logger.exception('Failed to load GeneIdentifier "%s"', identifier)
raise ValidationError(_u('Could not load gene "%s"') % identifier)
def _select(self, obj):
from django.contrib.admin.views.main import IS_POPUP_VAR
if IS_POPUP_VAR in self.request.GET and self.request.GET[IS_POPUP_VAR] == '3':
return '<span class="fb_icon"> \
<button class="button fb_selectlink" onclick="OpenFile(\'' \
+ escapejs(obj.url) + \
'\');return false;">' + _u('Select') + '</button> \
</span>'
else:
return '-'
def _load_uniprot(cls, uniprot_id, accession_id):
try:
protein = cls._get_or_create_from_uniprot(uniprot_id, accession_id)
lookup_protein_in_uniprot.delay(protein.id)
return protein
except Exception:
logger.exception(f"Failed to create from UniProt {uniprot_id}")
raise ValidationError(
_u("Could not create Protein from {uniprot_id}").format(
uniprot_id=uniprot_id))
def create_user(self, email, password, **extra_fields):
"""
Create and save a User with the given email and password.
"""
if not email:
raise ValueError(_u('The Email must be set'))
email = self.normalize_email(email)
user = self.model(email=email, **extra_fields)
user.set_password(password)
user.save()
return user
def check_arguments_for_rescoring(course_id, problem_url):
"""
Do simple checks on the descriptor to confirm that it supports rescoring.
Confirms first that the problem_url is defined (since that's currently typed
in). An ItemNotFoundException is raised if the corresponding module
descriptor doesn't exist. NotImplementedError is raised if the
corresponding module doesn't support rescoring calls.
"""
descriptor = modulestore().get_instance(course_id, problem_url)
if not hasattr(descriptor, 'module_class') or not hasattr(descriptor.module_class, 'rescore_problem'):
msg = _u("Specified module does not support rescoring.")
raise NotImplementedError(msg)
class Task(TimeStampedModel, UUIDModel):
NEW = "n"
INPROGRESS = "p"
DONE = "d"
STATE_CHOICES = (
(NEW, _u("New")),
(INPROGRESS, _u("In Progress")),
(DONE, _u("Done")),
)
title = models.CharField(max_length=250)
description = models.TextField()
state = models.CharField(max_length=1, choices=STATE_CHOICES, default=NEW)
parent = models.ForeignKey("self",
related_name="linked",
on_delete=models.CASCADE,
blank=True,
null=True)
def __str__(self):
return self.title
def approve(self, moderated_by=None, reason=None):
crx = CrxFile(self.changed_object.crx)
try:
launch_url = crx.manifest["app"]["launch"]["web_url"]
except KeyError:
launch_url = None
if is_redundant_item(self.changed_object.__class__, self.changed_object, appid=crx.get_appid()):
return self.reject(reason=_u("Private key already exists."))
if launch_url and is_redundant_item(self.changed_object.__class__, self.changed_object, launch_url=launch_url):
return self.reject(reason=_u("Hosted application with the same URL already exists."))
pre_moderation.send(sender=self.content_object.__class__,
instance=self.changed_object,
status=MODERATION_STATUS_APPROVED)
self._moderate(MODERATION_STATUS_APPROVED, moderated_by, reason)
post_moderation.send(sender=self.content_object.__class__,
instance=self.content_object,
status=MODERATION_STATUS_APPROVED)
return _("Item approved: %s") % reason
def pokoje_verbose(self):
pv = ''
i = 0
for pnr in self.pokojnarezerwacji_set.all():
if 0 < i < self.pokojnarezerwacji_set.count() - 1:
pv += ', '
elif i == self.pokojnarezerwacji_set.count() - 1 and not i == 0:
pv += ' ' + _u('i') + ' '
pv += '%d (' % (pnr.pokoj.numer,)
pv += ungettext('%d osoba', '%d osoby', pnr.osob()) % (pnr.osob(),)
pv += ')'
i += 1
return pv
def _load_uniprot(cls, uniprot_id, accession_id):
try:
url = cls._uniprot_url(uniprot_id)
values = cls._load_uniprot_values(uniprot_id)
values.update(
accession_id=accession_id,
type_source=Datasource.objects.create(name="UniProt", url=url),
)
protein, created = cls.objects.update_or_create(
accession_code=uniprot_id, defaults=values)
return protein
except Exception:
logger.exception(f"Failed to create from UniProt {uniprot_id}")
raise ValidationError(
_u("Could not create Protein from {uniprot_id}").format(
uniprot_id=uniprot_id))
def login(request):
context = {}
context['title'] = _('Log In')
security = Security.objects.get(id=1)
context['deny_register'] = security.allow_register
if request.POST:
username = request.POST['email']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
if not security.maintence or user.is_staff:
login_user(request, user)
users = User.objects.all().exclude(email=username)
notification = {
"type": "user_status",
"user_id": str(user.id),
"status": _u("Online"),
"status_class": "active",
"remove_class": "away"
}
notification = json.dumps(notification)
for u in users:
Group("user-%s" % u.id).send({'text': notification})
next_url = request.GET.get('next', None)
if next_url:
return redirect(next_url)
return redirect(reverse("home"))
else:
messages.error(request,
_('System under maintenance. Try again later'))
else:
messages.error(request, _('E-mail or password are incorrect.'))
context["username"] = username
elif request.user.is_authenticated:
return redirect(reverse('home'))
return render(request, "users/login.html", context)
def login(request):
context = {}
context['title'] = _('Log In')
security = Security.objects.get(id = 1)
context['deny_register'] = security.allow_register
if request.POST:
username = request.POST['email']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
if not security.maintence or user.is_staff:
login_user(request, user)
users = User.objects.all().exclude(email = username)
notification = {
"type": "user_status",
"user_id": str(user.id),
"status": _u("Online"),
"status_class": "active",
"remove_class": "away"
}
notification = json.dumps(notification)
for u in users:
Group("user-%s" % u.id).send({'text': notification})
next_url = request.GET.get('next', None)
if next_url:
return redirect(next_url)
return redirect(reverse("home"))
else:
messages.error(request, _('System under maintenance. Try again later'))
else:
messages.error(request, _('E-mail or password are incorrect.'))
context["username"] = username
elif request.user.is_authenticated:
return redirect(reverse('home'))
return render(request, "users/login.html", context)
def auth_redirect(request):
from ..middleware import JsonResponse
if request.is_ajax():
# Will use viewmodel framework to display client-side alert.
return JsonResponse({
'view': 'alert_error',
'message': _u('Access to current url is denied')
})
# Borrowed from django.contrib.auth.decorators.user_passes_test()
path = request.build_absolute_uri()
resolved_login_url = resolve_url(settings.LOGIN_URL)
# If the login url is the same scheme and net location then just
# use the path as the "next" url.
login_scheme, login_netloc = urlparse(resolved_login_url)[:2]
current_scheme, current_netloc = urlparse(path)[:2]
if ((not login_scheme or login_scheme == current_scheme)
and (not login_netloc or login_netloc == current_netloc)):
path = request.get_full_path()
from django.contrib.auth.views import redirect_to_login
return redirect_to_login(path, resolved_login_url, REDIRECT_FIELD_NAME)
def _load_uniprot(cls, uniprot_id, accession_id):
url = 'http://www.uniprot.org/uniprot/%s.rdf' % uniprot_id
# define some RDF predicate terms
fullname_predicate = URIRef('http://purl.uniprot.org/core/fullName')
mass_predicate = URIRef('http://purl.uniprot.org/core/mass')
name_predicate = URIRef('http://purl.uniprot.org/core/recommendedName')
sequence_predicate = URIRef('http://purl.uniprot.org/core/sequence')
value_predicate = URIRef(
'http://www.w3.org/1999/02/22-rdf-syntax-ns#value')
# build the RDF graph
try:
graph = Graph()
graph.parse(url)
# find top-level references
subject = URIRef('http://purl.uniprot.org/uniprot/%s' % uniprot_id)
name_ref = graph.value(subject, name_predicate)
isoform = graph.value(subject, sequence_predicate)
# find values of interest
values = {'accession_id': accession_id}
name = graph.value(name_ref, fullname_predicate)
if name:
values.update(type_name=name.value)
sequence = graph.value(isoform, value_predicate)
if sequence:
values.update(length=len(sequence.value))
mass = graph.value(isoform, mass_predicate)
if mass:
values.update(mass=mass.value)
# build the ProteinIdentifier
datasource = Datasource.objects.create(name='UniProt', url=url)
values.update(type_source=datasource)
protein, created = cls.objects.update_or_create(
short_name=uniprot_id,
defaults=values,
)
return protein
except Exception:
logger.exception('Failed to read UniProt: %s', uniprot_id)
raise ValidationError(
_u('Could not load information on %s from UniProt') %
uniprot_id)
def process_request(self, request):
if not request.user.is_authenticated():
return
now = datetime.now()
if '_session_security' not in request.session:
return
delta = now - get_last_activity(request.session)
expire_seconds = EXPIRE_AFTER
if delta >= timedelta(seconds = expire_seconds):
log = Log()
log.user = str(request.user)
log.user_id = request.user.id
log.user_email = request.user.email
log.context = {'condition': 'session_expire'}
log.component = "user"
log.action = "logout"
log.resource = "system"
log.save()
users = User.objects.all().exclude(email = request.user.email)
notification = {
"type": "user_status",
"user_id": str(request.user.id),
"status": _u("Offline"),
"status_class": "",
"remove_class": "away"
}
notification = json.dumps(notification)
for u in users:
Group("user-%s" % u.id).send({'text': notification})
def process_request(self, request):
if not request.user.is_authenticated():
return
now = datetime.now()
if '_session_security' not in request.session:
return
delta = now - get_last_activity(request.session)
expire_seconds = EXPIRE_AFTER
if delta >= timedelta(seconds=expire_seconds):
log = Log()
log.user = str(request.user)
log.user_id = request.user.id
log.user_email = request.user.email
log.context = {'condition': 'session_expire'}
log.component = "user"
log.action = "logout"
log.resource = "system"
log.save()
users = User.objects.all().exclude(email=request.user.email)
notification = {
"type": "user_status",
"user_id": str(request.user.id),
"status": _u("Offline"),
"status_class": "",
"remove_class": "away"
}
notification = json.dumps(notification)
for u in users:
Group("user-%s" % u.id).send({'text': notification})
def _load_ice(cls, link):
# strain found in ICE, but may not yet be linked to EDD protein
existing = ProteinStrainLink.objects.filter(strain=link.strain)[:2]
if len(existing) == 1:
# existing link found, return the protein
return existing[0].protein
elif len(existing) == 0:
# no existing link found, create the protein and link
datasource = Datasource.objects.create(
name="Part Registry", url=link.strain.registry_url
)
protein = cls.objects.create(
type_name=link.strain.name,
type_source=datasource,
accession_id=link.strain.part.part_id,
)
link.protein = protein
link.save()
return protein
raise ValidationError(
_u("Multiple entries found for '{part_id}'.").format(
part_id=link.strain.part.part_id
)
)
def __str__(self):
# In django 1.7 we can't use lazy
return _u('Podcast Configuration')
def course_wiki_redirect(request, course_id):
"""
This redirects to whatever page on the wiki that the course designates
as it's home page. A course's wiki must be an article on the root (for
example, "/6.002x") to keep things simple.
"""
course = get_course_by_id(course_id)
course_slug = course_wiki_slug(course)
valid_slug = True
if not course_slug:
log.exception("This course is improperly configured. The slug cannot be empty.")
valid_slug = False
if re.match(r'^[-\w\.]+$', course_slug) is None:
log.exception("This course is improperly configured. The slug can only contain letters, numbers, periods or hyphens.")
valid_slug = False
if not valid_slug:
return redirect("wiki:get", path="")
# The wiki needs a Site object created. We make sure it exists here
try:
site = Site.objects.get_current()
except Site.DoesNotExist:
new_site = Site()
new_site.domain = settings.SITE_NAME
new_site.name = "edX"
new_site.save()
if str(new_site.id) != str(settings.SITE_ID):
raise ImproperlyConfigured("No site object was created and the SITE_ID doesn't match the newly created one. " + str(new_site.id) + "!=" + str(settings.SITE_ID))
try:
urlpath = URLPath.get_by_path(course_slug, select_related=True)
results = list(Article.objects.filter(id=urlpath.article.id))
if results:
article = results[0]
else:
article = None
except (NoRootURL, URLPath.DoesNotExist):
# We will create it in the next block
urlpath = None
article = None
if not article:
# create it
root = get_or_create_root()
if urlpath:
# Somehow we got a urlpath without an article. Just delete it and
# recerate it.
urlpath.delete()
urlpath = URLPath.create_article(
root,
course_slug,
title=course_slug,
content=cgi.escape(_u("This is the wiki for **{0}**'s _{1}_.").format(course.display_org_with_default, course.display_name_with_default)),
user_message=_u("Course page automatically created."),
user=None,
ip_address=None,
article_kwargs={'owner': None,
'group': None,
'group_read': True,
'group_write': True,
'other_read': True,
'other_write': True,
})
return redirect("wiki:get", path=urlpath.path)
def __str__(self):
return _u('Global Configuration')
def __str__(self):
return _u('Radiocom Configuration')
def __str__(self):
return _u('Calendar Configuration')
def __str__(self):
# In django 1.7 we can't use lazy
return _u('Podcast Configuration')
def __unicode__(self):
return _u('Calendar Configuration')
def run_init(self):
from lib6ko.run import Executer
from lib6ko.protocol import ScriptError
from lib6ko.transport import TransportException
#Make params dict
params = self.get_param_dict()
# Use the supported protocols
protocols = self.protocol_support.all()
# If there are no defined protocols, create them
if len(protocols) == 0:
for protocol in Protocol.objects.filter(mode__isnull=False):
ap_pro_sup = APProtocolSupport.objects.create(
ap = self,
protocol = protocol,
)
protocols = self.protocol_support.all()
executer = Executer(
protocol_classes=[ p.protocol for p in protocols if p.is_usable ],
)
# Go through all init sections
# Run sections ordered by section name
for init_section in self.architecture.initsection_set.order_by('section__name'):
try:
apinit = self.archinitresult_set.get(section=init_section)
apinit.status = -1
apinit.output = _u(u"Initialization has not finished")
apinit.save()
except ArchInitResult.DoesNotExist:
apinit = self.archinitresult_set.create(
section=init_section,
status=-1,
output=_u(u"Initialization has not finished"),
)
# Execute the section
try:
apinit.output = executer.execute_template(
init_section.compile_template(),
self,
params,
context_factory=Context,
)
apinit.status = 0
except TemplateSyntaxError as e:
# TemplateSyntaxError wraps the inner exception as provided
# in the __exit__ of contextlib, see
#http://docs.python.org/reference/datamodel.html#object.__exit__
exc_type, exc_value, trace_obj = e.exc_info
if exc_type is ScriptError:
apinit.output = exc_value.traceback
apinit.status = -1
else:
apinit.output = traceback.format_exc()
apinit.status = -1
except ScriptError as e:
apinit.output = "{0}\n{0.traceback}".format(e)
apinit.status = -1
except TransportException as e:
apinit.output = str(e)
apinit.status = -1
except Exception as e:
apinit.output = traceback.format_exc()
apinit.status = -1
apinit.save()
return
def table_view_header():
return "".join(["<th>%s</th>" % i for i in (_u(u'Name') + " ".join(['' for i in range(10)]), )
])
def __unicode__(self):
return _u('Global Configuration')
def __unicode__(self):
return _u('Radiocom Configuration')
def __str__(self):
return _u('Global Configuration')
def __unicode__(self):
return _u('Global Configuration')
def __str__(self):
return _u('Calendar Configuration')
def __unicode__(self):
ret = _('Numer: %(numer)d, rozmiar: %(rozmiar)d') % {'numer': self.numer, 'rozmiar': self.rozmiar, }
if not self.dostepnosc:
ret += ' (' + _u('Niedostepny!') + ')'
return ret
def __str__(self):
return _u('Radiocom Configuration')
def __unicode__(self):
return _u(u"Group: %s") % (self.name)
def __unicode__(self):
return _u('Calendar Configuration')
translation_module_2.ugettext_lazy('tm2_utest_lazy')
translation_module_2.ugettext_noop('tm2_utest_noop')
translation_module_2.pgettext('context', 'tm2_ptest')
translation_module_2.pgettext_lazy('context', 'tm2_ptest_lazy')
translation_module_2.ngettext('tm2_ntest', 'tm2_ntests', 42)
translation_module_2.ngettext_lazy('tm2_ntest_lazy', 'tm2_ntests_lazy', 42)
translation_module_2.ungettext('tm2_untest', 'tm2_untests', 42)
translation_module_2.ungettext_lazy('tm2_untest_lazy', 'tm2_untests_lazy', 42)
translation_module_2.npgettext('context', 'tm2_nptest', 'tm2_nptests', 42)
translation_module_2.npgettext_lazy('context', 'tm2_nptest_lazy',
'tm2_nptests_lazy', 42)
_('alias_test')
_l('alias_test_lazy')
_0x90('alias_test_noop')
_u('alias_utest')
_ul('alias_utest_lazy')
_u0x90('alias_utest_noop')
_p('context', 'alias_ptest')
_pl('context', 'alias_ptest_lazy')
_n('alias_ntest', 'alias_ntests', 42)
_nl('alias_ntest_lazy', 'alias_ntests_lazy', 42)
_un('alias_untest', 'alias_untests', 42)
_unl('alias_untest_lazy', 'alias_untests_lazy', 42)
_np('context', 'alias_nptest', 'alias_nptests', 42)
_npl('context', 'alias_nptest_lazy', 'alias_nptests_lazy', 42)
def gettext(message):
pass
