class Resource(Model): id = UUIDField(primary_key=True, blank=True) description = CharField(max_length=64) modified_by = ForeignKey( 'auth.User', name='modified_by', editable=False, related_name='+', on_delete=SET_NULL, null=True, blank=True, ) hidden = BooleanField( name='hidden', default=False, ) deleted = BooleanField( name='deleted', default=False, ) history = HistoricalRecords(history_id_field=UUIDField(default=uuid4), ) @property def _history_user(self): return self.modified_by @_history_user.setter def _history_user(self, value): self.modified_by = value def save(self, force_insert=False, force_update=False, using=None, update_fields=None): if not self.id: self.id = uuid4() self.changeReason = 'create' else: self.changeReason = 'update' current_user = get_current_user() if current_user: self.modified_by = current_user super(Resource, self).save(force_insert, force_update, using, update_fields) def delete(self, using=None, keep_parents=False): self.deleted = True self.hidden = True self.changeReason = 'delete' self.save()
class Event(Model): id = UUIDField(primary_key=True, default=uuid.uuid4, editable=False) secret_id = UUIDField(default=uuid.uuid4, editable=False) title = CharField(max_length=255) description = TextField() host = CharField(max_length=255) image = ImageField(upload_to='images/events/', null=True, blank=True) start_time = DateTimeField(null=True) end_time = DateTimeField(null=True) location = CharField(max_length=500) address = CharField(max_length=500, null=True, blank=True) CATEGORY_CHOICES = (('sports', 'Sports'), ('music', 'Music'), ('academic', 'Academic'), ('party', 'Party'), ('business', 'Business'), ('ceremony', 'Ceremony'), ('workshop', 'Workshop'), ('clubs', 'Clubs'), ('other', 'Other')) category = CharField(max_length=20, choices=CATEGORY_CHOICES) event_type = CharField(max_length=30, default=None, null=True, blank=True) event_url = TextField(null=True, blank=True) ticket_url = TextField(null=True, blank=True) is_submission = BooleanField(default=False) is_submission_email = BooleanField(default=False) is_published = BooleanField(default=False) is_published_email = BooleanField(default=False) submitter_email = EmailField(null=True) submitter_phone = PhoneNumberField(null=True, blank=True) objects = EventManager() def save_image_from_url(self, url): """Store image locally if an external URL is passed""" result = requests.get(url) filename = os.path.basename(url).split('?')[0] # Use tempfile.TemporaryFile for App Engine temp = tempfile.TemporaryFile() temp.write(result.content) temp.flush() self.image.save(filename, File(temp)) self.save() def get_absolute_image_url(self): """ Returns image URL. """ if self.image: return settings.MEDIA_URL + str(self.image)
class Message(Model): id = UUIDField(primary_key=True, default=uuid4, editable=False) creation_datetime = DateTimeField(now, auto_now_add=True, editable=False) channel = ForeignKey(Channel, on_delete=PROTECT) body = TextField() source = ForeignKey(User, on_delete=PROTECT) request_id = UUIDField(null=True, editable=False, unique=True) def __str__(self): s = "Message id: {id} creation_datetime time: {ct}".format( id=str(self.id), ct=self.creation_datetime) return s
def annotate_tree(self): """ Annotate the number of parent and child prefixes for each Prefix. The UUID being used is fake for purposes of satisfying the COALESCE condition. """ # The COALESCE needs a valid, non-zero, non-null UUID value to do the comparison. # The value itself has no meaning, so we just generate a random UUID for the query. FAKE_UUID = uuid.uuid4() from nautobot.ipam.models import Prefix return self.annotate( parents=Subquery( Prefix.objects.annotate(maybe_vrf=ExpressionWrapper( Coalesce(F("vrf_id"), FAKE_UUID), output_field=UUIDField(), )).filter( Q(prefix_length__lt=OuterRef("prefix_length")) & Q(network__lte=OuterRef("network")) & Q(broadcast__gte=OuterRef("broadcast")) & Q(maybe_vrf=ExpressionWrapper( Coalesce(OuterRef("vrf_id"), FAKE_UUID), output_field=UUIDField(), ))).order_by(). annotate( fake_group_by=Value(1) ) # This is an ORM hack to remove the unwanted GROUP BY clause .values("fake_group_by").annotate( count=Count("*")).values("count")[:1], output_field=IntegerField(), ), children=Subquery( Prefix.objects.annotate(maybe_vrf=ExpressionWrapper( Coalesce(F("vrf_id"), FAKE_UUID), output_field=UUIDField(), )).filter( Q(prefix_length__gt=OuterRef("prefix_length")) & Q(network__gte=OuterRef("network")) & Q(broadcast__lte=OuterRef("broadcast")) & Q(maybe_vrf=ExpressionWrapper( Coalesce(OuterRef("vrf_id"), FAKE_UUID), output_field=UUIDField(), ))).order_by(). annotate( fake_group_by=Value(1) ) # This is an ORM hack to remove the unwanted GROUP BY clause .values("fake_group_by").annotate( count=Count("*")).values("count")[:1], output_field=IntegerField(), ), )
class Profile(Model): ''' A Crates user has access to the media on this server. The user may also be allowed to connect his/her own crates server to this one. This is a one-to-one relationship used to extend the existing user model without much effort. ''' user = OneToOneField(User) has_api_access = BooleanField( default=False, help_text="Can this user crawl this server from their crates server?") api_key = UUIDField( unique=True, default=uuid4, help_text="Key used to identify user's crates server", ) #ip = GenericIPAddressField(help_text="IP address of the host") user_server_url = URLField( null=True, blank=True, help_text="API url of user's own crates server, if any", ) user_server_api_key = UUIDField( null=True, blank=True, help_text= "API key of user's own crates server, if user has given you API access", ) can_upload = BooleanField( default=False, help_text= "Is the user allowed to push files to this crates server? Not implemented yet." ) # some stats... (need revising and improvement) bytes_inbound = IntegerField(default=0, editable=False) bytes_outbound = IntegerField(default=0, editable=False) object_count = IntegerField(default=0, editable=False) bytes_available = IntegerField(default=0, editable=False) bytes_total = IntegerField(default=0, editable=False) objects_common = IntegerField( default=0, editable=False, help_text="Mutual CAS objects. Good for data backup")
class Reminder(Model): id = UUIDField(primary_key=True, default=uuid.uuid4, editable=False) member = ForeignKey(Member) reminder_subject = CharField(max_length=65) reminder_message = CharField(max_length=150) reminder_created_date = DateTimeField('reminder created on') reminder_send_date = DateTimeField('send reminder on', null=True, blank=True) reminder_sent_on_date = DateTimeField('reminder sent on', null=True, blank=True) member_reminded_on_date = DateTimeField('member reminded on', null=True, blank=True) def is_an_email(self): if (self.member.member_email): return True return False def is_an_SMS(self): if (self.member.member_phone): return True return False def __unicode__(self): return unicode(self.id)
class RSModel(SafeDeleteModel): updated_at = DateTimeField(auto_now=True) created_at = DateTimeField(auto_now_add=True) id = UUIDField(primary_key=True, default=uuid4, editable=False) class Meta: abstract = True
class Project(ActivatableCreateableModel): id = UUIDField(primary_key=True, default=uuid.uuid4, editable=False) project_name = CharField(max_length=100) client = ForeignKey('clients.Client', related_name='projects', on_delete=DO_NOTHING) lead_employee = ForeignKey('employees.Employee', related_name='projects', on_delete=DO_NOTHING) project_status = ForeignKey('ProjectStatus', related_name='projects', on_delete=DO_NOTHING) office = ForeignKey('employees.Office', related_name='projects', on_delete=DO_NOTHING) requires_afe = BooleanField() work_order = ForeignKey('WorkOrder', related_name='projects', on_delete=DO_NOTHING) project_type = ForeignKey('ProjectType', related_name='projects', on_delete=DO_NOTHING) def __str__(self): return self.project_name
class Submission(BaseModel): meeting_id = UUIDField() meeting_type = ForeignKey(ContentType, on_delete=CASCADE) meeting = GenericForeignKey('meeting_type', 'meeting_id') member = ForeignKey(Member, on_delete=CASCADE, related_name='submissions') status = PSIF( choices=SubmissionStatus.CHOICES, default=SubmissionStatus.OPEN) class Meta: unique_together = ['member', 'meeting_type', 'meeting_id'] def is_open(self): return self.status == SubmissionStatus.OPEN def get_question_category(self): if self.meeting_type.name == 'standup': return QuestionCategory.STANDUP elif self.meeting_type.name == 'checkin': return QuestionCategory.CHECKIN raise NotImplementedError('Unknown meeeting type!') def get_questions(self): return Question.objects.filter(category=self.get_question_category()) def close(self): self.status = SubmissionStatus.CLOSED self.save() def submit(self): self.status = SubmissionStatus.SUBMITTED self.save()
class Model(DjangoModel): id = UUIDField("ID", primary_key=True, editable=False, default=uuid4) created_at = DateTimeField(auto_now_add=True) updated_at = DateTimeField(auto_now=True) class Meta: abstract = True
class School(LogicalDeleteModel): id = UUIDField(primary_key=True, default=uuid4, editable=False) name = models.CharField(max_length=255) code = models.CharField(max_length=5, unique=True) def __str__(self): return f"{self.code}-{self.name}"
class Test(Model): name = CharField(max_length=20) owner = ForeignKey(settings.AUTH_USER_MODEL, null=True, blank=True, on_delete=CASCADE) public = BooleanField(default=False) date = DateField(null=True, blank=True) datetime = DateTimeField(null=True, blank=True) permission = ForeignKey('auth.Permission', null=True, blank=True, on_delete=CASCADE) # We can’t use the exact names `float` or `decimal` as database column name # since it fails on MySQL. a_float = FloatField(null=True, blank=True) a_decimal = DecimalField(null=True, blank=True, max_digits=5, decimal_places=2) bin = BinaryField(null=True, blank=True) ip = GenericIPAddressField(null=True, blank=True) duration = DurationField(null=True, blank=True) uuid = UUIDField(null=True, blank=True) class Meta(object): ordering = ('name', )
class Rule(Model): """Stores a rule's content and associated permissions.""" id = UUIDField(primary_key=True, default=uuid.uuid4, editable=False) created = DateTimeField(auto_now_add=True, editable=False) modified = DateTimeField(auto_now=True, editable=False) # The rule creator is the first user to POST the rule to the system. rule_creator = ForeignKey(to=User, on_delete=SET_NULL, null=True, blank=True, related_name="created_rules") # Simple Properties name = CharField(max_length=200) description = CharField(max_length=1000) # The set of editors can be modified by the creator. editors = ManyToManyField(to=User, related_name="editable_rules") # If a rule is forked, this will store a reference to the original rule forked_from = ForeignKey("Rule", on_delete=SET_NULL, null=True, blank=True) primary_content = ForeignKey("RuleContent", null=True, blank=True, on_delete=SET_NULL)
class BaseModel(Model): """ Base """ id = UUIDField(primary_key=True, default=uuid4, editable=False) time_created = DateTimeField(verbose_name="Created on", auto_now_add=True, null=True) time_modified = DateTimeField(verbose_name="Last modified on", auto_now=True, null=True) creator = ForeignKey("users.User", verbose_name="Created by", related_name="%(app_label)s_%(class)s_creator", null=True, blank=True, on_delete=CASCADE) last_modified_by = ForeignKey( "users.User", verbose_name="Last modified by", related_name="%(app_label)s_%(class)s_last_modified", null=True, blank=True, on_delete=CASCADE) class Meta: abstract = True def save(self, *args, **kwargs): if not self.time_created: self.time_created = timezone.now() self.time_modified = timezone.now() return super(BaseModel, self).save(*args, **kwargs)
class Language(models.Model): id = UUIDField(primary_key=True, default=uuid.uuid4) doctor = ForeignKey("Doctor", on_delete=models.PROTECT, related_name="languages") query_name = SlugField() display_name = TextField()
class Asset(Model): """Top level class for entire class hierarchy""" class Meta: db_table = "asset" """Asset type can take following values: - pipeline - power line - electric truss """ PIPELINE = 'PIP' POWER_LINE = 'POW' ELECTRIC_TRUSS = 'ELE' TYPE_CHOICES = ( (PIPELINE, 'Pipeline'), (POWER_LINE, 'Power line'), (ELECTRIC_TRUSS, 'Electric truss'), ) id = UUIDField(primary_key=True, default=uuid4, editable=False) type = CharField(max_length=3, choices=TYPE_CHOICES, blank=False, null=False) name = CharField(max_length=120, blank=False, null=False, default=default_asset_name) created = DateTimeField(auto_now_add=True) modified = DateTimeField(auto_now=True) description = TextField(blank=True, null=True) note = TextField(blank=True, null=True) geometry = GeometryField(blank=True, null=True, srid=settings.DEFAULT_SRID)
class Anomaly(Model): """Some object of interest inside the frame""" class Meta: db_table = "anomaly" """Object type, up to now there's only one option: - insulator """ INSULATOR = 'INS' TYPE_CHOICES = ((INSULATOR, 'Insulator'), ) UNKNOWN = 'UNK' STATUS_CHOICES = ((UNKNOWN, 'Unknown'), ) frame = ForeignKey(Frame, related_name='_anomalies', on_delete=CASCADE) id = UUIDField(primary_key=True, default=uuid4, editable=False) type = CharField(max_length=3, choices=TYPE_CHOICES) status = CharField(max_length=3, choices=STATUS_CHOICES) confidence = IntegerField(blank=False, null=False) x_min = IntegerField(blank=False, null=False) x_max = IntegerField(blank=False, null=False) y_min = IntegerField(blank=False, null=False) y_max = IntegerField(blank=False, null=False)
class RSGenericAddress(RSAddress): object_id = UUIDField() content_type = ForeignKey(ContentType, on_delete=CASCADE) content_object = GenericForeignKey('content_type', 'object_id') class Meta: abstract = True
class UserEarnings(CreatedModified): class TimePeriod(TextChoices): ALL = 'all', _('All') SEVEN_DAYS = '7d', _('7 Days') THIRTY_DAYS = '30d', _('30 Days') uuid = UUIDField(default=uuid.uuid4, editable=False, primary_key=True) user = ForeignKey('users.User', on_delete=CASCADE) repository = ForeignKey(Repository, on_delete=CASCADE) time_period = CharField(max_length=8, choices=TimePeriod.choices) total_amount = PositiveBigIntegerField(validators=[ MaxValueValidator(MAX_POINT_VALUE), MinValueValidator(MIN_POINT_VALUE), ]) class Meta: constraints = [ UniqueConstraint(fields=['repository', 'time_period', 'user'], name='unique_repository_time_period_user') ] default_related_name = 'user_earnings' verbose_name_plural = 'user earnings' def __str__(self): return f'#{self.pk}: {self.user.email}/{self.repository}/{self.time_period}'
class BlogPost(Model): guid = UUIDField(primary_key=True, default=uuid.uuid4, editable=False) enabled = BooleanField(default=True) title = CharField(max_length=200, blank=True, null=True) slug = SlugField(max_length=200, blank=True, null=True) pub_date = DateTimeField(blank=True, null=True) creator = ForeignKey(BlogUser, blank=True, null=True, on_delete=DO_NOTHING) category = ForeignKey(BlogCategory, blank=True, null=True, on_delete=DO_NOTHING) description = RichTextField(blank=True, null=True) content = RichTextField(blank=True, null=True) guid_is_permalink = BooleanField(default=True) class Meta: verbose_name = "Post" verbose_name_plural = "Posts" def __str__(self): return self.title if self.title else "Blog Post" def save(self, *args, **kwargs): if not self.slug: self.slug = slugify(self.title) super(BlogPost, self).save(*args, **kwargs)
class Command(Model): id = UUIDField(primary_key=True, default=uuid.uuid4, editable=False) cycle_duration = PositiveSmallIntegerField() creation_time = DateTimeField(auto_now=True) class Meta: indexes = (Index(fields=['creation_time']), )
class BaseModel(Model): id = UUIDField(primary_key=True, default=uuid.uuid4, editable=False) created_at = DateTimeField(auto_now_add=True, db_index=True) updated_at = DateTimeField(auto_now=True, db_index=True) class Meta: abstract = True
class Event(models.Model): """Event instance which may result in one or more Alerts.""" timestamp = models.DateTimeField(auto_now=True) eventid = UUIDField(default=uuid.uuid4, editable=False) severity = models.IntegerField(validators=[MinValueValidator(0), MaxValueValidator(100)]) log_message = models.TextField(null=True, blank=True) context = PickledObjectField() trigger_result = PickledObjectField() def __unicode__(self): return '<Event %s/%s (%s)>' % (self.id, self.eventid, self.timestamp) def __repr__(self): return unicode(self) def get_details(self): """Return details in a string""" msg = [] fmt = '{0:15}: {1}' msg.append(fmt.format('ID', self.id)) msg.append(fmt.format('EventID', self.eventid)) msg.append(fmt.format('Severity', self.severity)) msg.append(fmt.format('Timestamp', self.timestamp)) msg.append(fmt.format('Log Message', self.log_message)) msg.append(fmt.format('Trigger Result', self.trigger_result)) msg.append(fmt.format('Context', self.context)) alerts = self.alert_set.all() if alerts: msg.append('') msg.append('Associated Alerts:') for a in alerts: msg.append(a.get_details()) return '\n'.join(msg)
class Token(Model): class Meta: get_latest_by = 'expires' verbose_name = '[Access] Authentication Token' verbose_name_plural = '[Access] Authentication Tokens' expires = DateTimeField('Token Expire Time', null=True, blank=True) uid = UUIDField('Token UUID', primary_key=True, default=uuid4, editable=False) def __str__(self): if self.expires is not None: return '[Token] %s (%s)' % (str( self.uid), self.expires.strftime('%m/%d/%y %H:%M')) return '[Token] %s (No Expire)' % str(self.uid) def __len__(self): if self.expires is not None: return max((self.expires - now()).seconds, 0) return 0 def __bool__(self): return len(self) > 0 or self.expires is None
class UserProfile(Model): id = UUIDField(primary_key=True, default=uuid.uuid4, editable=False, unique=True) user = OneToOneField(User, on_delete=CASCADE, related_name='profile') role = CharField(max_length=1, choices=UserRole.CHOICES, default=UserRole.USUAL) is_system = BooleanField(default=False) login = CharField(null=False, unique=True, max_length=255) name = CharField(null=False, max_length=255) updated_at = DateTimeField(auto_now=True, editable=False) created_at = DateTimeField(auto_now_add=True, editable=False) is_active = BooleanField(default=True) objects = Manager() active = ActiveObjectManager() system_user = SystemUserObjectManager() class Meta: verbose_name = "User Profile" ordering = ('pk', ) indexes = [Index(fields=['is_system'])] def __str__(self): return self.login @staticmethod def get_profile_by_user(user): return UserProfile.objects.filter(user=user.id).first()
class Test(Model): name = CharField(max_length=20) owner = ForeignKey(settings.AUTH_USER_MODEL, null=True, blank=True, on_delete=SET_NULL) public = BooleanField(default=False) date = DateField(null=True, blank=True) datetime = DateTimeField(null=True, blank=True) permission = ForeignKey('auth.Permission', null=True, blank=True, on_delete=PROTECT) # We can’t use the exact names `float` or `decimal` as database column name # since it fails on MySQL. a_float = FloatField(null=True, blank=True) a_decimal = DecimalField(null=True, blank=True, max_digits=5, decimal_places=2) bin = BinaryField(null=True, blank=True) ip = GenericIPAddressField(null=True, blank=True) duration = DurationField(null=True, blank=True) uuid = UUIDField(null=True, blank=True) try: from django.db.models import JSONField json = JSONField(null=True, blank=True) except ImportError: pass class Meta: ordering = ('name', )
class Game(Model): uuid = UUIDField(default=uuid.uuid4, primary_key=True) white_player = ForeignKey( settings.AUTH_USER_MODEL, on_delete=CASCADE, related_name="white_player", null=True, ) black_player = ForeignKey( settings.AUTH_USER_MODEL, on_delete=CASCADE, related_name="black_player", null=True, ) created_at = DateTimeField(auto_now_add=True) started_at = DateTimeField(null=True) finished_at = DateTimeField(null=True) result = OneToOneField( Result, on_delete=CASCADE, ) board = OneToOneField( Board, on_delete=CASCADE, )
class User(AbstractUser): avatar = ImageField(blank=True, default='default/default-user.jpg', upload_to=user_directory_path) birth_date = DateField(null=True, blank=True, default=None) email = EmailField('email', unique=True, blank=True, null=False) phone = CharField(max_length=20, blank=True, default=None, null=True) thumbnail = ImageField(blank=True, default='default/default-user.jpg') is_verified = BooleanField('verified', default=False) verification_uuid = UUIDField('Unique Verification UUID', default=uuid.uuid4) @classmethod def create(cls, **kwargs): new_user = cls() new_user.birth_date = kwargs.get('birth_date') if kwargs.get( 'birth_date') else None new_user.email = kwargs.get('email') if kwargs.get('email') else None new_user.first_name = kwargs.get('first_name') if kwargs.get( 'first_name') else None new_user.last_name = kwargs.get('last_name') if kwargs.get( 'last_name') else None new_user.password = make_password(kwargs.get('password')) new_user.phone = kwargs.get('phone') if kwargs.get('phone') else None new_user.username = kwargs.get('username') return new_user def __str__(self): return self.username if self.username else '%s %s' % (self.first_name, self.last_name)
def test_update_UUIDField_using_Value(self): UUID.objects.create() UUID.objects.update( uuid=Value(uuid.UUID('12345678901234567890123456789012'), output_field=UUIDField())) self.assertEqual(UUID.objects.get().uuid, uuid.UUID('12345678901234567890123456789012'))
def _handle_pk_field(queryset): pk = queryset.model._meta.pk if isinstance(pk, ForeignKey): return _handle_pk_field(pk.target_field) if isinstance( pk, ( IntegerField, AutoField, BigIntegerField, PositiveIntegerField, PositiveSmallIntegerField, SmallIntegerField, ), ): return partial(Cast, output_field=BigIntegerField()) if isinstance(pk, UUIDField): if connection.features.has_native_uuid_field: return partial(Cast, output_field=UUIDField()) return partial( Replace, text=Value('-'), replacement=Value(''), output_field=CharField(), ) return None