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)
