class Order(models.Model): ref_code = models.CharField(max_length=15) owner = models.ForeignKey(User, on_delete=models.SET_NULL(), null=True) is_ordered = models.BooleanField(default=False) items = models.ManyToManyField(OrderItem) date_ordered = models.DateTimeField(null=True) def get_cart_items(self): return self.items.all() def get_cart_total(self): return sum(item.product_snacks.snacks_amt for item in self.items.all()) + sum( item.product_streetfood.streetfood_amt for item in self.items.all()) + sum( item.product_beverages.beverages_amt for item in self.items.all()) + sum( item.product_breads.breads_amt for item in self.items.all()) + sum( item.product_vegetable.vegetable_amt for item in self.items.all()) + sum( item.product_rice.rice_amt for item in self.items.all()) + sum( item.product_dessert.desserts_amt for item in self.items.all()) def __str__(self): return '{0} - {1}'.format(self.owner, self.ref_code)
def _key_set_null_or_cascade(collector, field, sub_objs, using): """ on_delete callback for AS relation: - SET_NULL for keys that have a cert sensitive signing a TRC - CASCADE for all others Certificates include votes, that are references to certificates included in previous TRCs. The votes are specified via indices to the previous TRC `certificates` field (e.g. votes = [0, 3] means the first and 4th certificate in the list of certificates from the previous TRC). We need to preserve the possible voters in the previous TRCs, so making the `certificates` effectively immutable. Furthermore, we need to preserve keys and certificates for possible signers of future TRCs. These are sensitive and regular keys/certificates. In summary: we preserve keys whose certificates are part of TRCs. We use the callback on the Key.on_delete because Key is an intermediate model between Certificate and AS, and simplifies checking membership on the cert.trc_included. See also: - test_pki:CertificateTests.test_delete_while_sensitive_voted - pki.Certificate._pre_delete """ preserve = [ key for key in sub_objs if key.certificates.exclude(trc_included__isnull=True) ] others = [key for key in sub_objs if key not in preserve] if preserve: models.SET_NULL(collector, field, preserve, using) if others: models.CASCADE(collector, field, others, using)
class Message(models.Model): message_id = models.BigIntegerField(_('Id'), primary_key=True) from_user = models.ForeignKey(User, related_name='messages', verbose_name=_("User"), on_delete=models.CASCADE) date = models.DateTimeField(_('Date')) chat = models.ForeignKey(Chat, related_name='messages', verbose_name=_("Chat"), on_delete=models.CASCADE) forward_from = models.ForeignKey(User, null=True, blank=True, related_name='forwarded_from', verbose_name=_("Forward from"), on_delete=models.SET_NULL()) text = models.TextField(null=True, blank=True, verbose_name=_("Text")) # TODO: complete fields with all message fields class Meta: verbose_name = 'Message' verbose_name_plural = 'Messages' ordering = [ '-date', ] def __str__(self): return "(%s,%s)" % (self.from_user, self.text or '(no text)')
class Batch(models.Model): def __str__(self): return self.name class Meta: #ordering = ['-startdate'] verbose_name_plural = 'batches' name = models.CharField(max_length=50) startdate = models.DateTimeField(auto_now=True) enddate = models.DateTimeField(null=True, blank=True) size = models.IntegerField() size_units = models.ForeignKey(Unit, on_delete=models.SET("_del")) active = models.BooleanField(default=True) # Using the 'related_name' on batches, applies that name on the other side for "Fermenter.batch" fermenter = models.ManyToManyField(Fermenter, blank=True, related_name='batch') startingGravity = models.FloatField() estimatedEndGravity = models.FloatField() category = models.ForeignKey(BatchCategory, on_delete=models.SET("_del"), blank=True, null=True) activity = models.ManyToManyField(ActivityLog, related_name='batch') recipe = models.ForeignKey(Recipe, on_delete=models.SET_NULL(), null=True, blank=True) def complete(self): self.enddate = datetime.now() self.active = False
class OrderItem(models.Model): product_snacks = models.OneToOneField(Snacks, on_delete=models.SET_NULL(), null=True) product_streetfood = models.OneToOneField(StreetFood, on_delete=models.SET_NULL(), null=True) product_beverages = models.OneToOneField(Beverages, on_delete=models.SET_NULL(), null=True) product_breads = models.OneToOneField(Breads, on_delete=models.SET_NULL(), null=True) product_vegetable = models.OneToOneField(Vegetable, on_delete=models.SET_NULL(), null=True) product_rice = models.OneToOneField(Rice, on_delete=models.SET_NULL(), null=True) product_dessert = models.OneToOneField(Desserts, on_delete=models.SET_NULL(), null=True) is_ordered = models.BooleanField(default=False) date_added = models.DateTimeField(auto_now=True) date_ordered = models.DateTimeField(null=True) def __str__(self): return '{}{}{}{}{}{}{}'.format( self.product_snacks.snacks, self.product_streetfood.streetfood, self.product_beverages.beverages, self.product_breads.breads, self.product_vegetable.vegetable, self.product_rice.rice, self.product_dessert.desserts)
class Comment(models.Model): userprofile = models.ForeignKey(UserProfile, on_delete=models.SET_NULL(), null=True) text = models.CharField(max_length=256) date_created = models.DateTimeField(auto_now_add=True) status = models.CharField(max_length=64, choices=(('public', 'public'), ('private', 'private')))
class Logs(models.Model): """ Model for visits logs. """ name = models.ForeignKey(Customer, on_delete=models.SET_NULL, related_name='+') date = models.DateField() area = models.ForeignKey(Area, on_delete=models.SET_NULL(), related_name='+')
class Reservation(models.Model): user = models.ForeignKey(User, on_delete=models.CASCADE) reserved_start_date = models.DateTimeField(default=timezone.now) reserved_end_date = models.DateTimeField() num_of_people = models.IntegerField(default=1) # room = models.ForeignKey(Room, on_delete=models.CASCADE) status = models.ForeignKey(ReservationStatuses, on_delete=models.SET_NULL) updated_datetime = models.DateTimeField(auto_now=True) user_comments = models.ForeignKey(UserComments, on_delete=models.SET_NULL) pay_status = models.ForeignKey(PayStatuses, on_delete=models.SET_NULL())
def SET_NULL_AND_AUTOUPDATE(collector: Any, field: Any, sub_objs: Any, using: Any) -> None: """ Like models.SET_NULL but also informs the autoupdate system about the instance that was reference. """ instances = [] for sub_obj in sub_objs: setattr(sub_obj, field.name, None) instances.append(sub_obj) inform_changed_data(instances) models.SET_NULL(collector, field, sub_objs, using)
class UserProfile(models.Model): genders = ( ("M", "M"), ("W", "W"), ("other", "other"), ) full_name = models.CharField(max_length=64) date_birth = models.DateField() gender = models.CharField(max_length=32, choices=genders) bio = models.TextField() photo = models.ImageField() user = models.OneToOneField(User, on_delete=models.SET_NULL(), null=True)
class Posts(models.Model): author = models.ForeignKey(User, on_delete=models.SET_NULL(), null=True, related_name='user_author') STATUS_CHOICES = (('draft', 'Draft'), ('published', 'Published')) title = models.CharField(max_length=255) body = models.Charfield(max_length=255) created = models.DateTimeField(auto_now_add=True) updated = models.DateTimeField(auto_now=True) publish = models.DateTimeField(default=timezone.now)
def _key_set_null_or_cascade(collector, field, sub_objs, using): """ on_delete callback for AS relation: - SET_NULL for keys with usage==TRC_VOTING_OFFLINE - CASCADE for all others This "trick" is required to be able to use voting offline keys for the creation of a new TRC after an AS has been deleted. """ voting_offline = [ key for key in sub_objs if key.usage == Key.TRC_VOTING_OFFLINE ] others = [key for key in sub_objs if key.usage != Key.TRC_VOTING_OFFLINE] if voting_offline: models.SET_NULL(collector, field, voting_offline, using) if others: models.CASCADE(collector, field, others, using)
def SET_NULL(collector, field, sub_objs, using): return models.SET_NULL(collector, field, sub_objs.non_polymorphic(), using)
def SET_NULL_OR_CASCADE(collector, field, sub_objs, using): if field.null is True: models.SET_NULL(collector, field, sub_objs, using) else: models.CASCADE(collector, field, sub_objs, using)
def SET_NULL(collector, field, sub_objs, using): if hasattr(sub_objs, 'non_polymorphic'): sub_objs = sub_objs.non_polymorphic() return models.SET_NULL(collector, field, sub_objs, using)
def SET_NULL_OR_CASCADE(collector, field, sub_objs, using): if sub_objs[0].flashcards.count() > 1: models.SET_NULL(collector, field, sub_objs, using) else: models.CASCADE(collector, field, sub_objs, using)