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)