class Task(CachingMixin, models.Model):
title = models.CharField(max_length=256)
description = models.TextField(default='')
deadline = models.DateTimeField(default=timezone.now)
objects = CachingManager()
teacher = CachingManager()
def __str__(self):
return self.title
class ImageBannerVariation(CachingMixin, ImageVariation):
banner = models.ForeignKey(ImageBanner, related_name='variation_set')
objects = CachingManager()
def get_media_subdirectory(self):
return 'uploads/image_banners'
class BannerInstance(BadgeInstance):
image = models.ForeignKey(BannerImage)
details_template = 'banners/details.html'
objects = CachingManager()
@property
def preview(self):
"""Return the HTML to preview this banner."""
return Markup('<img src="%s?from_affiliates" alt="%s">' %
(absolutify(self.image.image.url),
_locale(self.badge.name, self.image.locale)))
@property
def code(self):
"""Return the code to embed this banner.."""
return jingo.env.from_string(BANNER_TEMPLATE).render({
'url':
self.affiliate_link(),
'img':
absolutify(self.image.image.url, protocol=''),
'alt_text':
_locale(self.badge.name, self.image.locale)
})
def affiliate_link(self):
link = reverse('banners.link', kwargs={'banner_instance_id': self.pk})
return absolutify(link, protocol='')
class SnippetTemplateVariable(CachingMixin, models.Model):
"""
A variable for a template that an individual snippet can fill in with its
own content.
"""
TEXT = 0
IMAGE = 1
SMALLTEXT = 2
CHECKBOX = 3
BODY = 4
TYPE_CHOICES = ((BODY, 'Main Text'), (TEXT, 'Text'),
(SMALLTEXT, 'Small Text'), (IMAGE, 'Image'), (CHECKBOX,
'Checkbox'))
template = models.ForeignKey(SnippetTemplate, related_name='variable_set')
name = models.CharField(max_length=255)
type = models.IntegerField(choices=TYPE_CHOICES, default=TEXT)
description = models.TextField(blank=True, default='')
objects = models.Manager()
cached_objects = CachingManager()
def __unicode__(self):
return u'{0}: {1}'.format(self.template.name, self.name)
class Meta:
ordering = ('name', )
class Results(CachingMixin, models.Model):
id = models.AutoField(primary_key=True)
query_id = models.ForeignKey('Query',
db_column='query_id',
related_name='results',
db_index=True)
result_id = models.PositiveIntegerField(db_index=True)
rnacentral_id = models.CharField(max_length=13, null=True)
description = models.TextField(null=True)
bias = models.FloatField(null=True)
target_length = models.PositiveIntegerField(null=True)
query_length = models.PositiveIntegerField(null=True)
alignment = models.TextField(null=True)
score = models.FloatField(null=True)
e_value = models.FloatField(null=True)
alignment_length = models.PositiveIntegerField(null=True)
match_count = models.PositiveIntegerField(null=True)
gap_count = models.PositiveIntegerField(null=True)
nts_count1 = models.PositiveIntegerField(null=True)
nts_count2 = models.PositiveIntegerField(null=True)
identity = models.FloatField(null=True)
query_coverage = models.FloatField(null=True)
target_coverage = models.FloatField(null=True)
gaps = models.FloatField(null=True)
objects = CachingManager()
class Meta:
db_table = 'nhmmer_results'
class TextBanner(CachingMixin, Banner):
"""Banner displayed as a string of text with a link."""
objects = CachingManager()
def generate_banner_code(self, variation):
return u'<a href="{{href}}">{text}</a>'.format(text=variation.text)
def get_customize_url(self):
return reverse('banners.generator.text_banner.customize', kwargs={'pk': self.pk})
def preview_html(self, href, **kwargs):
kwargs['href'] = href
kwargs['banner'] = self
# Fetch localized variation.
locale = translation.get_language()
try:
kwargs['preview_text'] = self.variation_set.get(locale=locale).text
except TextBannerVariation.DoesNotExist:
pass
# Fallback to en-US if necessary.
if 'preview_text' not in kwargs and locale != 'en-us':
try:
kwargs['preview_text'] = self.variation_set.get(locale='en-us').text
except TextBannerVariation.DoesNotExist:
pass
return Markup(render_to_string('banners/previews/text_banner.html', kwargs))
@staticmethod
def get_variation_class():
return TextBannerVariation
class GrandCompany(CachingMixin, models.Model):
class Meta:
verbose_name_plural = u"grand companies"
RANKS = [
u"Recruit",
u"{0} Private Third Class",
u"{0} Private Second Class",
u"{0} Private First Class",
u"{0} Corporal",
u"{0} Sergeant Third Class",
u"{0} Sergeant Second Class",
u"{0} Sergeant First Class",
u"Chief {0} Sergeant",
u"Second {0} Lieutenant",
]
name = models.CharField(max_length=50)
slug = models.SlugField(max_length=50, unique=True)
short = models.CharField(max_length=10)
objects = models.Manager()
cached = CachingManager()
def __unicode__(self):
return self.name
class MagnateFund(CachingMixin, models.Model):
name = models.CharField(_('name'), max_length=200)
description = models.TextField(_('description'), default="")
is_active = models.BooleanField(_('is active'), default=True)
objects = CachingManager()
def __unicode__(self):
return 'Fund: %s' % (self.name)
def is_visible(self, user):
"""
Checks if the user can see the fund on his fund page.
In the future can depend on the status of the user.
"""
return self.is_active
def statistics_as_html(self):
if not self.is_active:
return ""
from forum_modules.magnate.settings import MAGNATE_FUND_TEMPLATES
if self.pk in MAGNATE_FUND_TEMPLATES:
return MAGNATE_FUND_TEMPLATES[self.pk].value
else:
return ""
class BaseModel(CachingMixin, models.Model): """ Base class WITH Cache Machine caching """ objects = CachingManager() class Meta: abstract = True
class Module(CachingMixin, AutoSlugModel):
objects = CachingManager()
class Meta:
verbose_name = _('module')
verbose_name_plural = _('modules')
ordering = ['workshopmodule__order']
class Stop(CachingMixin, models.Model):
"""
"null=True" for some fields is a temporary solution for this import
error: "null value in column "what_searched" violates not-null constraint"
"""
stop_id = models.IntegerField(primary_key=True, default=1)
date = models.DateTimeField(null=True)
purpose = models.PositiveSmallIntegerField(choices=PURPOSE_CHOICES, default=UNKNOWN_PURPOSE)
stop_date_text = models.CharField(max_length=20, blank=True, default='')
stop_time_text = models.CharField(max_length=20, blank=True, default='')
stop_location = models.CharField(max_length=1024)
duration_text = models.CharField(max_length=20, blank=True, null=True)
stop_reason = models.CharField(max_length=64)
search_conducted = models.CharField(max_length=1, choices=YN_CHOICES, blank=True)
search_reason = models.CharField(max_length=64, blank=True)
seized = models.CharField(max_length=1, choices=YN_CHOICES, blank=True)
gender = models.CharField(max_length=1, choices=GENDER_CHOICES, blank=True)
date_of_birth_text = models.CharField(max_length=20, blank=True, null=True)
ethnicity = models.CharField(max_length=20, choices=ETHNICITY_CHOICES, blank=True)
officer_id = models.CharField(max_length=15, blank=True, default=None)
agency_description = models.CharField(max_length=100)
agency = models.ForeignKey('Agency', null=True, related_name='stops')
age = models.PositiveSmallIntegerField(default=0)
objects = CachingManager()
def __str__(self):
return 'Stop %d at %s at %s' % (
self.stop_id, self.date, self.stop_location
)
class UserProfile(models.Model, CachingMixin):
"""Additional fields required for a user."""
user = models.OneToOneField(User, primary_key=True)
locale = LocaleField(blank=False, default='en-us')
# Profile info
full_name = models.CharField(max_length=255, blank=False)
nickname = models.CharField(max_length=255, blank=True)
country = CountryField(blank=False)
# Mailing address
address1 = models.CharField(max_length=255, blank=True)
address2 = models.CharField(max_length=255, blank=True)
city = models.CharField(max_length=255, blank=True)
mailing_country = CountryField(blank=True)
state = models.CharField(max_length=255, blank=True)
postal_code = models.CharField(max_length=255, blank=True)
objects = CachingManager()
@property
def display_name(self):
return self.nickname or self.full_name
@property
def region(self):
return regions.get_region(self.country)
class ChemicalComponent(CachingMixin, models.Model):
"""List of all possible nucleotide modifications."""
id = models.CharField(max_length=8, primary_key=True)
description = models.CharField(max_length=500)
one_letter_code = models.CharField(max_length=1)
ccd_id = models.CharField(max_length=3,
default='') # Chemical Component Dictionary id
source = models.CharField(max_length=10,
default='') # Modomics, PDBe, others
modomics_short_name = models.CharField(max_length=20,
default='') # m2A for 2A
objects = CachingManager()
class Meta:
db_table = 'rnc_chemical_components'
def get_pdb_url(self):
"""
Get a link to PDB Chemical Component Dictionary from PDB entries and
Modomics entries that are mapped to PDB.
"""
pdb_url = 'http://www.ebi.ac.uk/pdbe-srv/pdbechem/chemicalCompound/show/{id}'
if self.source == 'PDB':
return pdb_url.format(id=self.id)
elif self.source == 'Modomics' and self.ccd_id:
return pdb_url.format(id=self.ccd_id)
else:
return None
def get_modomics_url(self):
"""Get a link to Modomics modifications."""
return 'http://modomics.genesilico.pl/modifications/%s' % self.modomics_short_name if self.source == 'Modomics' else None
class SnippetTemplate(CachingMixin, models.Model):
"""
A template for the body of a snippet. Can have multiple variables that the
snippet will fill in.
"""
name = models.CharField(max_length=255, unique=True)
code = models.TextField()
created = models.DateTimeField(auto_now_add=True)
modified = models.DateTimeField(auto_now=True)
objects = models.Manager()
cached_objects = CachingManager()
def render(self, ctx):
ctx.setdefault('snippet_id', 0)
# Check if template is in cache, and cache it if it's not.
cache_key = hashlib.sha1(self.code).hexdigest()
template = template_cache.get(cache_key)
if not template:
template = jingo.env.from_string(self.code)
template_cache[cache_key] = template
return template.render(ctx)
def __unicode__(self):
return self.name
class Solution(CachingMixin, models.Model):
class SolutionStatus:
Todo = 0
Checking = 1
Done = 2
Expired = 3
SolutionStatusChoices = ((SolutionStatus.Todo, 'Не выполнено'),
(SolutionStatus.Checking, 'На проверке'),
(SolutionStatus.Done, 'Проверенно'),
(SolutionStatus.Expired, 'Просрочено'))
task = models.ForeignKey(Task,
related_name='solutions',
on_delete=models.CASCADE)
student = models.ForeignKey(Student,
related_name='solutions',
on_delete=models.CASCADE)
date_check = models.DateTimeField(blank=True, null=True)
date_loading = models.DateTimeField(blank=True, null=True)
mark = models.IntegerField(blank=True, null=True)
mark_ai = models.IntegerField(blank=True, null=True)
status = models.IntegerField(choices=SolutionStatusChoices,
default=SolutionStatus.Todo)
file_name = models.CharField(null=True, blank=True, max_length=256)
percent = models.IntegerField(null=True, blank=True)
img = models.ImageField(upload_to='solutions')
objects = CachingManager()
def __str__(self):
return '%s: %s' % (self.student.name, self.task.title)
class Banner(Badge):
"""Badge consisting of an image link."""
customize_view = 'banners.views.customize_banner'
objects = CachingManager()
def customize_url(self):
return reverse('banners.customize', kwargs={'banner_pk': self.pk})
class Track(CachingMixin, AutoSlugModel):
workshops = models.ManyToManyField(
Workshop, through='TrackWorkshop', related_name='tracks', verbose_name=_('workshops'))
objects = CachingManager()
class Meta:
verbose_name = _('track')
verbose_name_plural = _('tracks')
class SearchBasis(CachingMixin, models.Model):
search_basis_id = models.IntegerField(primary_key=True)
search = models.ForeignKey(Search)
person = models.ForeignKey(Person)
stop = models.ForeignKey(Stop)
basis = models.CharField(max_length=4, choices=SEARCH_BASIS_CHOICES)
objects = CachingManager()
class Mount(CachingMixin, models.Model):
name = models.CharField(max_length=100, unique=True)
objects = models.Manager()
cached = CachingManager()
def __unicode__(self):
return self.name
class Category(CachingMixin, ModelBase):
"""Top-level category that contains sub-categories."""
name = models.CharField(max_length=255)
objects = CachingManager()
def __unicode__(self):
return self.name
class Vote(models.Model, CachingMixin):
"""A vote from a user for a specific video."""
user = models.ForeignKey(User)
video = models.ForeignKey(Video2013)
objects = CachingManager()
class Meta:
unique_together = ('user', 'video')
class EnsemblInsdcMapping(CachingMixin, models.Model):
assembly_id = models.ForeignKey(EnsemblAssembly, related_name='assembly', db_column='assembly_id')
insdc = models.CharField(max_length=255, db_index=True)
ensembl_name = models.CharField(max_length=255, db_index=True)
objects = CachingManager()
class Meta:
db_table = 'ensembl_insdc_mapping'
class Job(CachingMixin, models.Model):
name = models.CharField(max_length=50, unique=True)
code = models.CharField(max_length=3, blank=True)
objects = models.Manager()
cached = CachingManager()
def __unicode__(self):
return self.name
class Tool(CachingMixin, models.Model):
"""
A tool, making edits with some ids in the edit summaries
"""
objects = CachingManager()
Match = namedtuple('Match', 'uid user summary')
name = models.CharField(max_length=MAX_CHARFIELD_LENGTH)
shortid = models.CharField(max_length=32)
idregex = models.CharField(max_length=MAX_CHARFIELD_LENGTH)
idgroupid = models.IntegerField()
summaryregex = models.CharField(max_length=MAX_CHARFIELD_LENGTH)
summarygroupid = models.IntegerField()
userregex = models.CharField(max_length=MAX_CHARFIELD_LENGTH,
null=True,
blank=True)
usergroupid = models.IntegerField(null=True, blank=True)
url = models.URLField()
def __str__(self):
return self.name
def match(self, user, comment):
"""
Determines if an edit made with the supplied comment
came from that tool, based on string matching with
the supplied regular expressions.
:returns: a Match named tuple if there
is a match, None otherwise
"""
idre = re.compile(self.idregex)
idmatch = idre.match(comment)
summaryre = re.compile(self.summaryregex)
summarymatch = summaryre.match(comment)
if not idmatch:
return
uid = idmatch.group(self.idgroupid)
summary = ''
if summarymatch:
summary = summarymatch.group(self.summarygroupid)
realuser = user
if self.userregex:
userre = re.compile(self.userregex)
usermatch = userre.match(comment)
if usermatch:
realuser = usermatch.group(self.usergroupid)
return self.Match(uid=uid, user=realuser, summary=summary)
class Server(CachingMixin, models.Model):
name = models.CharField(max_length=50)
slug = models.SlugField(max_length=50, unique=True)
objects = models.Manager()
cached = CachingManager()
def __unicode__(self):
return self.name
class BankReceivingEntry(BaseJournalEntry):
"""
Holds information about receiving money for a Bank
:class:`~accounts.models.Account`. The :attr:`main_transaction` is linked
to the Bank :class:`~accounts.models.Account`.
Bank Receiving Entries debit the Bank :class:`~accounts.models.Account`
(via the :attr:`main_transaction`) while crediting all related
:class:`Transactions<Transaction>`.
.. attribute:: payor
The Person or Company making the payment.
.. attribute:: main_transaction
The :class:`Transaction` that links this :class:`BankSpendingEntry`
with it's Bank :class:`~accounts.models.Account`.
"""
payor = models.CharField(max_length=50)
main_transaction = models.OneToOneField('Transaction')
objects = CachingManager()
class Meta:
verbose_name_plural = "bank receiving entries"
def __unicode__(self):
return self.memo
def get_absolute_url(self):
"""Return the Entry's detail page."""
return reverse('entries.views.show_bank_entry',
kwargs={
'entry_id': str(self.id),
'journal_type': 'CR'
})
def get_edit_url(self):
"""Return the Entry's edit page."""
return reverse('entries.views.add_bank_entry',
args=['CR', str(self.id)])
def save(self, *args, **kwargs):
"""Set the date's of all related :class:`Transactions<Transaction>`."""
self.full_clean()
self.main_transaction.date = self.date
self.main_transaction.save(pull_date=False)
super(BankReceivingEntry, self).save(*args, **kwargs)
for transaction in self.transaction_set.all():
transaction.date = self.date
transaction.save()
@cached_method
def get_number(self):
"""Return the Entry's formatted number."""
return "CR#{0:06d}".format(self.id)
class Format(CachingMixin, models.Model):
id = models.BigAutoField(primary_key=True)
source_id = models.BigIntegerField()
root_server = models.ForeignKey(RootServer, on_delete=models.CASCADE)
type = models.CharField(max_length=7, null=True)
world_id = models.CharField(max_length=255, null=True)
if settings.CACHE_FORMATS:
objects = CachingManager()
@staticmethod
def import_from_bmlt_objects(root_server, bmlt_formats):
logger = logging.getLogger('django')
try:
format_ids = [int(fid) for fid in bmlt_formats.keys()]
Format.objects.filter(root_server=root_server).exclude(source_id__in=format_ids).delete()
except Exception as e:
message = 'Error deleting old formats: {}'.format(str(e))
logger.error(message)
ImportProblem.objects.create(root_server=root_server, message=message)
for bmlt_format in bmlt_formats.values():
bmlt_translated_formats = list(bmlt_format.values())
try:
bmlt_format = Format.validate_bmlt_object(root_server, bmlt_translated_formats[0])
except ImportException as e:
logger.warning('Error parsing format: {}'.format(str(e)))
ImportProblem.objects.create(root_server=root_server, message=str(e), data=str(e.bmlt_object))
continue
format = Format.objects.get_or_create(root_server=root_server, source_id=bmlt_format['source_id'])[0]
dirty = False
field_names = ('type', 'world_id')
changed_fields = []
for field_name in field_names:
if set_if_changed(format, field_name, bmlt_format[field_name]):
changed_fields.append(field_name)
dirty = True
if dirty:
format.save()
TranslatedFormat.import_from_bmlt_objects(root_server, bmlt_translated_formats)
@staticmethod
def validate_bmlt_object(root_server, bmlt):
return {
'source_id': get_int(bmlt, 'id'),
'type': bmlt.get('format_type_enum', None),
'world_id': bmlt.get('world_id', None),
}
def __str__(self):
return '({}:{})'.format(self.id, self.root_server)
class JournalEntry(BaseJournalEntry):
"""A concrete class of the :class:`BaseJournalEntry` model."""
objects = CachingManager()
def save(self, *args, **kwargs):
"""Save all related :class:`Transactions<Transaction>` after saving."""
self.full_clean()
super(JournalEntry, self).save(*args, **kwargs)
for transaction in self.transaction_set.all():
transaction.save()
class User(CachingMixin, models.Model):
name = models.CharField(max_length=30)
objects = CachingManager()
if django.VERSION[0] >= 2:
class Meta:
# Tell Django to use this manager when resolving foreign keys. (Django >= 2.0)
base_manager_name = 'objects'
class Person(CachingMixin, models.Model):
person_id = models.IntegerField(primary_key=True)
stop = models.ForeignKey(Stop)
type = models.CharField(max_length=2, choices=PERSON_TYPE_CHOICES)
age = models.PositiveSmallIntegerField()
gender = models.CharField(max_length=2, choices=GENDER_CHOICES)
ethnicity = models.CharField(max_length=2, choices=ETHNICITY_CHOICES)
race = models.CharField(max_length=2, choices=RACE_CHOICES)
objects = CachingManager()