class IDRule(VersionedModel, models.Model):
""" Mapping between an IDCommand output and a FormatVersion. """
uuid = UUIDField(editable=False,
unique=True,
version=4,
help_text=_("Unique identifier"))
command = models.ForeignKey(
"IDCommand",
to_field="uuid",
verbose_name=_("the related command"),
on_delete=models.CASCADE,
)
format = models.ForeignKey(
"FormatVersion",
to_field="uuid",
verbose_name=_("the related format"),
on_delete=models.CASCADE,
)
# Output from IDToolConfig.command to match on that gives the format
command_output = models.TextField(_("command output"))
class Meta:
verbose_name = _("Format identification rule")
def validate_unique(self, *args, **kwargs):
super(IDRule, self).validate_unique(*args, **kwargs)
qs = self.__class__._default_manager.filter(
command=self.command,
command_output=self.command_output,
enabled=1)
if not self._state.adding and self.pk is not None:
qs = qs.exclude(pk=self.pk)
if qs.exists():
raise ValidationError({
NON_FIELD_ERRORS: [
_("Unable to save, a rule with this output already exists for this command."
)
]
})
def __unicode__(self):
return _("Format identification rule %(uuid)s") % {"uuid": self.uuid}
def long_name(self):
return _("%(command)s with %(output)s is %(format)s") % {
"command": self.command,
"output": self.command_output,
"format": self.format,
}
class Dashboard(models.Model):
uuid = UUIDField(primary_key=True)
name = models.CharField(null=True, blank=True, max_length=1024)
layout = models.CharField(null=True, blank=True, max_length=1024)
user = models.ForeignKey(User, null=True, blank=True)
def __unicode__(self):
return self.name
class Meta:
unique_together = (('name', 'user'), )
db_table = 'dashboard'
class PackageDownloadTask(models.Model):
uuid = UUIDField(editable=False,
unique=True,
version=4,
help_text=_("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 = _("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
class CubeContent(models.Model):
"""
indexes sit on the values we will be filtering on
these indexes are relational to the dim tables from
which the aggregated data derives
"""
# index
id = UUIDField(version=4, primary_key=True)
# dim_client
client_id = models.CharField(max_length=36)
# dim_studio
content_provider = models.CharField(max_length=255)
# dim_assets
asset_role_type = models.CharField(max_length=255)
# ... TODO
mezzanine_delivery_date = models.DateField(null=True)
# dim_definition
definition = models.CharField(max_length=255)
# dim_language
language = models.CharField(max_length=3)
# dim_utc_date
date = models.DateField()
year = models.SmallIntegerField()
month = models.SmallIntegerField()
day = models.SmallIntegerField()
day_of_week = models.IntegerField()
day_name = models.CharField(max_length=9)
week_of_year = models.SmallIntegerField()
quarter = models.SmallIntegerField()
# fact agg
file_size = models.BigIntegerField(max_length=10)
duration_of_asset = models.IntegerField(max_length=10, default='')
title = models.CharField(max_length=255)
added_to_client = models.DateField(null=True)
created = models.DateTimeField(auto_created=True,
auto_now=True,
default=datetime.datetime.now())
class Meta:
app_label = 'cubes'
db_table = 'summary_content_daily'
class Parameter(models.Model):
"""
A Parameter is a representation of a tool parameter that will
potentially be exposed and configurable upon a tool's
configuration/launching step.
"""
INTEGER = "INTEGER"
STRING = "STRING"
BOOLEAN = "BOOLEAN"
FLOAT = "FLOAT"
GENOME_BUILD = "GENOME_BUILD"
ATTRIBUTE = "ATTRIBUTE"
FILE = "FILE"
STRING_TYPES = [FILE, ATTRIBUTE, GENOME_BUILD, STRING]
VALUE_TYPES = ((INTEGER, "int"), (STRING, "str"), (BOOLEAN, "bool"),
(FLOAT, "float"), (GENOME_BUILD, "genome build"),
(ATTRIBUTE, "attribute"), (FILE, "file"))
uuid = UUIDField(unique=True, auto=True)
name = models.TextField(max_length=100)
description = models.TextField(max_length=500)
is_user_adjustable = models.BooleanField(default=True)
value_type = models.CharField(choices=VALUE_TYPES, max_length=25)
default_value = models.TextField(max_length=100)
def __str__(self):
return "{}: {} - {}".format(self.value_type, self.name, self.uuid)
def get_galaxy_workflow_step(self):
try:
return GalaxyParameter.objects.get(
uuid=self.uuid).galaxy_workflow_step
except (GalaxyParameter.DoesNotExist,
GalaxyParameter.MultipleObjectsReturned):
return None
def cast_param_value_to_proper_type(self, parameter_value):
"""Parameter values from the Tool Launch Configuration are all
strings, but the invocation of Galaxy workflows expects these values
to be of a certain type."""
if self.value_type in self.STRING_TYPES:
return str(parameter_value)
elif self.value_type == self.BOOLEAN:
return bool(parameter_value)
elif self.value_type == self.INTEGER:
return int(parameter_value)
elif self.value_type == self.FLOAT:
return float(parameter_value)
else:
return parameter_value
class Reporter(models.Model):
user = models.OneToOneField(User, related_name='reporter', db_index=True)
email = models.CharField(max_length=200,
blank=False,
null=True,
db_index=True)
guid = UUIDField(db_index=True)
bugs_reported = ListField(null=True)
xp = models.CharField(max_length=20, null=True)
badges = ListField(null=True)
created_at = models.DateTimeField(auto_now_add=True,
default=datetime.datetime.now())
feedbacks = ListField(null=True)
class Project(models.Model):
projectid = UUIDField(primary_key=True)
path = models.CharField(max_length=90)
upload_date = models.CharField(max_length=15, blank=True)
project_name = models.CharField(max_length=90, blank=True)
project_desc = models.TextField(blank=True)
start_date = models.CharField(max_length=15, blank=True)
end_date = models.CharField(max_length=15, blank=True)
pi_last = models.CharField(max_length=45, blank=True)
pi_first = models.CharField(max_length=45, blank=True)
pi_affiliation = models.CharField(max_length=45, blank=True)
pi_email = models.EmailField(blank=True)
pi_phone = models.CharField(max_length=15, blank=True)
class PressAppearancePublication(models.Model):
uuid = UUIDField(primary_key=True)
name = models.TextField(verbose_name='Publication')
ranking = models.IntegerField(choices=PRESS_PUBLICATION_RANK, default=3)
def __str__(self):
return self.name
def count_posts(self):
return self.pressappearance_set.count()
class Meta:
ordering = ['ranking', 'name']
class UserProfile ( models.Model ):
'''
Extends Django user model: https://docs.djangoproject.com/en/dev/topics/auth/#storing-additional-information-about-users
'''
uuid = UUIDField( unique=True, auto=True )
user = models.OneToOneField( User )
affiliation = models.CharField( max_length=100, blank=True )
catch_all_project = models.ForeignKey( 'Project', blank=True, null=True )
is_public = models.BooleanField( default=False, blank=False, null=False )
def __unicode__(self):
return self.user.first_name + " " + self.user.last_name + " (" + self.affiliation + "): " + self.user.email
class SharedExhibitKey(TimeStampedModel,models.Model):
slug = UUIDField()
label = models.TextField(max_length=255, blank=True, null=True, help_text="An optional descriptive label")
exhibit = models.ForeignKey(Exhibit, related_name="shared_keys")
@models.permalink
def get_absolute_url(self):
return ('shared_exhibit_display', (), {
'slug': self.slug,
})
class Developer(models.Model):
user = models.OneToOneField(User, related_name='developer', db_index=True)
email = models.CharField(max_length=200,
blank=False,
null=True,
db_index=True)
guid = UUIDField(db_index=True)
xp = models.CharField(max_length=20, null=True)
badges = ListField(null=True)
created_at = models.DateTimeField(auto_now_add=True,
default=datetime.datetime.now())
active_bugs = ListField(null=True)
fixed_bugs = ListField(null=True)
class RedirectUrl(models.Model):
redirect_key = UUIDField(unique=True, auto=True)
target_url = models.ForeignKey(TrackableURL, related_name='redirect_urls')
user = models.ForeignKey(User,
verbose_name="django authentication user",
related_name='links')
def __unicode__(self):
return "%s %s %s" % (self.user.username, self.redirect_key,
self.target_url.url)
class Meta:
unique_together = ('target_url', 'user')
class NodeCollection(models.Model):
"""Base class for Investigation and Study
"""
uuid = UUIDField(unique=True, auto=True)
identifier = models.TextField(blank=True, null=True)
title = models.TextField(blank=True, null=True)
description = models.TextField(blank=True, null=True)
submission_date = models.DateField(blank=True, null=True)
release_date = models.DateField(blank=True, null=True)
def __init__(self, *args, **kwargs):
# change dates from empty string to None (to pass validation)
if "submission_date" in kwargs:
if kwargs["submission_date"] == "":
kwargs["submission_date"] = None
else:
kwargs["submission_date"] = self.normalize_date(
kwargs["submission_date"])
if "release_date" in kwargs:
if kwargs["release_date"] == "":
kwargs["release_date"] = None
else:
kwargs["release_date"] = self.normalize_date(
kwargs["release_date"])
super(NodeCollection, self).__init__(*args, **kwargs)
def __unicode__(self):
return (
unicode(self.identifier) +
(": " + unicode(self.title) if unicode(self.title) != "" else "") +
": " + unicode(self.id))
def normalize_date(self, dateString):
"""Normalizes date strings in dd/mm/yyyy format to yyyy-mm-dd.
Returns normalized date string if in expected unnormalized format or
unnormalized date string.
"""
logger.info("Converting date " + str(dateString) + " ...")
try:
# try reformatting incorrect date format used by Nature Scientific
# Data
return str(
datetime.strftime(datetime.strptime(dateString, "%d/%m/%Y"),
"%Y-%m-%d"))
except ValueError:
# ignore - date either in correct format or in format not supported
# (will cause a validation error handled separately)
logger.info("Failed to convert date " + str(dateString))
return dateString
class TripTip(models.Model):
class Meta:
app_label = 'city_viewer'
verbose_name = verbose_name_plural = _('旅行贴士')
ordering = ['weight']
id = UUIDField(primary_key=True)
title = models.CharField(_('主题名'), max_length=50)
content = tinymce_models.HTMLField(verbose_name=_('内容'))
in_area = models.ForeignKey(Area, verbose_name=_("所属城市"))
weight = models.SmallIntegerField()
def __unicode__(self):
return '%s[%s]' % (self.title, self.in_area)
class Service(models.Model):
id = UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
name = models.CharField(max_length=125, unique=True, db_index=True)
title = models.CharField(max_length=255)
description = models.TextField()
status = models.BooleanField(default=False)
objects = ServiceManager()
class Meta:
db_table = 'app_services'
ordering = ['title']
def __unicode__(self):
return self.title
class ConciergeUserLicenceRisk(models.Model):
uuid = UUIDField(primary_key=True)
user = models.ForeignKey(settings.AUTH_USER_MODEL)
provider = models.ForeignKey(
Provider,
help_text=
"Select any member of the banking licence, the licence owner will be discovered automatically"
)
maximum_balance = models.DecimalField(default=0,
decimal_places=3,
max_digits=19)
class Meta:
unique_together = ('user', 'provider')
class Api(models.Model):
key = UUIDField()
user = models.OneToOneField(User)
status = models.BooleanField(default=False)
last_access = models.DateTimeField(null=True, blank=True, editable=False)
last_ip = models.CharField(max_length=32, blank=True, null=True, default=None)
class Meta:
db_table = 'app_api'
def touch(self, ip):
self.last_ip = ip
self.last_access = now()
self.save()
class MetaModel(models.Model):
uuid = UUIDField(unique=True)
created_at = models.DateTimeField(editable=False, default=timezone.now)
updated_at = models.DateTimeField(editable=False, default=timezone.now)
class Meta:
abstract = True
def save(self, *args, **kwargs):
"""On save, update timestamps"""
if not self.id:
self.created_at = timezone.now()
self.updated_at = timezone.now()
super(MetaModel, self).save(*args, **kwargs)
class Topic(models.Model):
class Meta:
app_label = 'city_viewer'
verbose_name = verbose_name_plural = _('主题')
id = UUIDField(primary_key=True)
name = models.CharField(_('主题名'), max_length=50)
desc = models.CharField(_('描述'), max_length=255)
in_area = models.ForeignKey(Area, verbose_name=_("所属城市"))
weight = models.SmallIntegerField()
cover_pic = models.CharField(_('图片名'), max_length=100)
modified_at = ModificationDateTimeField()
def __unicode__(self):
return '%s[%s]' % (self.name, self.in_area)
class InputFile(models.Model):
"""
An Input file describes a file and allowed Refinery FileType(s) that we
will associate with a tool as its expected input(s)
"""
uuid = UUIDField(unique=True, auto=True)
name = models.TextField(max_length=100)
description = models.TextField(max_length=500)
allowed_filetypes = models.ManyToManyField(FileType)
def __str__(self):
return "{}: {} {}".format(
self.name, [f.name for f in self.allowed_filetypes.all()],
self.uuid)
class LinkMainframeAbonents(models.Model):
guid = UUIDField(primary_key=True, max_length=38)
guid_abonents = models.ForeignKey('general.Abonents',
db_column='guid_abonents')
guid_mainframe = models.ForeignKey('DiagramMainframe',
db_column='guid_mainframe')
class Meta:
db_table = 'link_mainframe_abonents'
verbose_name = u'Привязка абонента к диаграмме'
verbose_name_plural = u'Привязки абонентов к диаграммам'
def __unicode__(self):
return u'%s %s' % (self.guid_abonents.name,
self.guid_mainframe.backgroundurl)
class Protocol(models.Model):
'''
Study Protocol (ISA-Tab Spec 4.1.3.6)
'''
study = models.ForeignKey(Study)
uuid = UUIDField(unique=True, auto=True)
# workflow_uuid can be used to associate the protocol with a workflow
# TODO: should this be the analysis uuid? (problem: technically an analysis is the execution of a protocol)
workflow_uuid = UUIDField(unique=True, auto=True)
version = models.TextField(blank=True, null=True)
name = models.TextField(blank=True, null=True)
name_accession = models.TextField(blank=True, null=True)
name_source = models.TextField(blank=True, null=True)
type = models.TextField(blank=True, null=True)
type_accession = models.TextField(blank=True, null=True)
type_source = models.TextField(blank=True, null=True)
description = models.TextField(blank=True, null=True)
uri = models.TextField(blank=True, null=True)
# protocol parameters: via FK
# protocol components: via FK
def __unicode__(self):
return unicode(self.name) + ": " + unicode(self.type)
class BaseUUIDModel(TimeStampedModel):
"""
Base model for application.
Introduces tracking of creation and changes (for users and time).
Change id to UUID instead of INT.
"""
id = UUIDField(primary_key=True)
user_created = models.CharField(max_length=250, verbose_name='user created', editable=False, default="")
user_modified = models.CharField(max_length=250, verbose_name='user modified',editable=False, default="")
class Meta:
abstract = True
class FormatGroup(models.Model):
""" Group/classification for formats. Eg. image, video, audio. """
uuid = UUIDField(editable=False,
unique=True,
version=4,
help_text=_("Unique identifier"))
description = models.CharField(_('description'), max_length=128)
slug = AutoSlugField(_('slug'), populate_from='description')
class Meta:
verbose_name = _("Format group")
ordering = ['description']
def __unicode__(self):
return u"{}".format(self.description)
class Submission(models.Model):
"""A single response by a student for a given problem in a given course.
A student may have multiple submissions for the same problem. Submissions
should never be mutated. If the student makes another Submission, or if we
have to make corrective Submissions to fix bugs, those should be new
objects. We want to keep Submissions immutable both for audit purposes, and
because it makes caching trivial.
"""
MAXSIZE = 1024 * 100 # 100KB
uuid = UUIDField(version=1, db_index=True)
student_item = models.ForeignKey(StudentItem)
# Which attempt is this? Consecutive Submissions do not necessarily have
# increasing attempt_number entries -- e.g. re-scoring a buggy problem.
attempt_number = models.PositiveIntegerField()
# submitted_at is separate from created_at to support re-scoring and other
# processes that might create Submission objects for past user actions.
submitted_at = models.DateTimeField(default=now, db_index=True)
# When this row was created.
created_at = models.DateTimeField(editable=False,
default=now,
db_index=True)
# The answer (JSON-serialized)
raw_answer = models.TextField(blank=True)
def __repr__(self):
return repr(
dict(
uuid=self.uuid,
student_item=self.student_item,
attempt_number=self.attempt_number,
submitted_at=self.submitted_at,
created_at=self.created_at,
raw_answer=self.raw_answer,
))
def __unicode__(self):
return u"Submission {}".format(self.uuid)
class Meta:
ordering = ["-submitted_at", "-id"]
class DiagramMainframe(models.Model):
guid = UUIDField(primary_key=True, max_length=38)
backgroundurl = models.CharField(max_length=20)
refreshmentTimeMS = models.IntegerField(default=3000)
mainframeleft = models.IntegerField()
mainframetop = models.IntegerField()
mainframewidth = models.IntegerField()
mainframeheight = models.IntegerField()
class Meta:
db_table = 'diagram_mainframe'
verbose_name = u'Главная диаграмма'
verbose_name_plural = u'Главные диаграммы'
def __unicode__(self):
return self.backgroundurl
class UUIDModel(models.Model):
uuid = UUIDField(db_index=True, auto=True, primary_key=True)
class Meta:
abstract = True
def save(self, *args, **kwargs):
# Needs an primary key prior to saving the 'ManyToManyField' fields.
if not self.uuid:
self.uuid = self._meta.get_field("uuid").create_uuid()
# FIXME: Or ._meta.model?
super(UUIDModel, self).save(*args, **kwargs)
class Subscription(CreationModificationModel):
email = models.EmailField(unique=True)
uuid = UUIDField()
class Meta:
verbose_name = _(u"Inscrição")
verbose_name_plural = _(u"Inscrições")
ordering = ("-created", )
def __unicode__(self):
return self.email
def save(self, *args, **kwargs):
self.email = self.email.lower()
return super(Subscription, self).save(*args, **kwargs)
class DimensionMetadata(models.Model):
"""
DimensionMetadata
Dim to filter down on metadata within the reported data facts. This is a spinoff of the metadata fact.
This allows us to ingest our metadata items, then use the dim to filter down on other incoming events
"""
metadata_id = UUIDField(version=4, unique=True)
class Meta:
app_label = 'base'
db_table = 'dim_metadata'
@classmethod
def insert(cls, **kwargs):
return select_or_insert(cls, values={}, **kwargs)
class Posts(models.Model):
#create visibility let author choose when they make post
VISIBILITY=(("PRIVATE","Private"),("PUBLIC","Public"),("FRIENDS","Friends"),("FOAF","Friend of a Friend"))
post_id = UUIDField(primary_key=True, auto=True)
post_author = models.ForeignKey(Author)
post_title = models.CharField(max_length = 20)
post_text = models.CharField(max_length=200)
visibility = models.CharField(max_length = 10, choices = VISIBILITY,default="PUBLIC")
image = models.ImageField(upload_to='static/post_images/',blank = True)
mark_down = models.BooleanField(default=False)
publication_date = models.DateTimeField(auto_now_add=True)
content_type = models.CharField(max_length=200)
content_source = models.CharField(max_length=200)
def __unicode__(self): #For Python 2, use __str__ on Python 3
return self.post_title
def __init__(self, *args, **kwargs):
assert kwargs.get('primary_key', False) is True, "%ss must have primary_key=True." % self.__class__.__name__
UUIDField.__init__(self, *args, **kwargs)
