def test_enum_field_init(self):
field = EnumField(PersonStatus)
self.assertEqual(field.default, PersonStatus.UNBORN)
self.assertEqual(len(PersonStatus.choices()), len(field.choices))
field = EnumField(PersonStatus, default=PersonStatus.ALIVE)
self.assertEqual(field.default, PersonStatus.ALIVE)
field = EnumField(PersonStatus, default=None)
self.assertEqual(field.default, None)
def test_enum_field_init(self):
for enum, default in {
PersonStatus: NOT_PROVIDED,
PersonStatusDefault: PersonStatusDefault.UNBORN,
}.items():
field = EnumField(enum)
self.assertEqual(field.default, default)
self.assertEqual(len(enum.choices()), len(field.choices))
field = EnumField(enum, default=enum.ALIVE)
self.assertEqual(field.default, enum.ALIVE)
field = EnumField(enum, default=None)
self.assertEqual(field.default, None)
class Person(models.Model):
example = models.CharField(max_length=100, default='foo')
status = EnumField(PersonStatus, default=PersonStatus.ALIVE)
def save(self, *args, **kwargs):
super(Person, self).save(*args, **kwargs)
return 'Person.save'
class Login(BaseModel):
team = models.ForeignKey(Team, on_delete=models.CASCADE)
stage = EnumField(TeamStatus)
username = models.CharField(max_length=256, null=False, unique=True)
password = models.CharField(max_length=256, null=False)
is_sent = models.BooleanField(default=False)
def send_email(self, **kwargs):
if self.is_sent:
return
event = self.team.event
filepath = event.email_conf['logins-templates'][TeamStatus.labels[
self.stage]]
template = get_template(filepath)
message = template.render({'login': self, 'team': self.team})
subject, message = message.split('\n\n', 1)
message = message.replace('\n', '<br>\n')
to = []
for m in self.team.ordered_participants:
to.append(m.email)
msg = EmailMultiAlternatives(subject, message, to=to, **kwargs)
msg.attach_alternative(message, 'text/html')
result = msg.send()
if result:
self.is_sent = True
self.save()
return result
def __str__(self):
return '%s in %s' % (self.username, TeamStatus.labels[self.stage])
class Meta:
unique_together = (('team', 'stage'), ('stage', 'username'))
def field(cls, **kwargs):
"""
A shortcut for
Usage:
class MyModelStatuses(Enum):
UNKNOWN = 0
class MyModel(Model):
status = MyModelStatuses.field()
"""
return EnumField(cls, **kwargs)
def field(cls, **kwargs):
""" A shortcut for field declaration
Usage:
class MyModelStatuses(Enum):
UNKNOWN = 0
class MyModel(Model):
status = MyModelStatuses.field()
:param kwargs: Arguments passed in EnumField.__init__()
:rtype: EnumField
"""
return EnumField(cls, **kwargs)
class CompanionInvite(models.Model):
email = models.EmailField()
sender = models.ForeignKey(User,
on_delete=models.CASCADE,
related_name="sent_invites")
user = models.ForeignKey(
User,
on_delete=models.CASCADE,
related_name="received_invites",
blank=True,
null=True,
)
status = EnumField(enums.CompanionInviteStatus,
default=enums.CompanionInviteStatus.created)
invite_code = models.CharField(max_length=50, default=generate_invite_code)
invited = models.DateTimeField(auto_now_add=True)
accessed = models.DateTimeField(null=True, blank=True)
signed_up = models.DateTimeField(null=True, blank=True)
def __str__(self):
return f"{self.email}"
class DealWatchGroup(models.Model):
source = models.CharField(max_length=20)
destination = models.CharField(max_length=20)
airlines = models.CharField(max_length=100, blank=True, null=True)
last_updated = models.DateTimeField(null=True, blank=True)
kind = EnumField(enums.DWGKind, default=enums.DWGKind.unknown)
def airline_list(self):
if len(self.airlines) == 0:
return []
return list(self.airlines.split(","))
def in_cities(self):
st, sv = self.source.split(":")
dt, dv = self.destination.split(":")
if not (st == "city" and dt == "city"):
return False
return (sv in settings.DEALS_CITIES and dv in settings.DEALS_CITIES
) or (sv in settings.DEALS_INTERNATIONAL
and dv in settings.DEALS_INTERNATIONAL)
def in_home_markets(self):
st, sv = self.source.split(":")
dt, dv = self.destination.split(":")
if not (dt == "city" and (dv in settings.DEALS_CITIES
or dv in settings.DEALS_INTERNATIONAL)):
return False
return User.objects.filter(market__type=st, market__code=sv).exists()
def in_watches(self):
return self.watches.exists()
def must_die(self):
if self.in_cities():
return False
if self.in_watches():
return False
if self.in_home_markets():
return False
return True
class Participant(BaseModel):
coder = models.ForeignKey(Coder,
null=True,
blank=True,
on_delete=models.CASCADE)
event = models.ForeignKey(Event, on_delete=models.CASCADE)
team = models.ForeignKey('Team',
related_name='participants',
null=True,
blank=True,
on_delete=models.CASCADE)
first_name = models.CharField(max_length=255, blank=True)
last_name = models.CharField(max_length=255, blank=True)
first_name_native = models.CharField(max_length=255, blank=True)
last_name_native = models.CharField(max_length=255, blank=True)
middle_name_native = models.CharField(max_length=255, blank=True)
email = models.EmailField(null=True, blank=True)
phone_number = PhoneNumberField(blank=True)
date_of_birth = models.DateField(null=True, blank=True)
organization = models.ForeignKey(Organization,
null=True,
blank=True,
on_delete=models.SET_NULL)
country = CountryField(null=True, blank=True)
tshirt_size = EnumField(TshirtSize, null=True, blank=True)
is_coach = models.BooleanField(default=False)
addition_fields = JSONField(default=dict, blank=True)
objects = ParticipantManager()
def __str__(self):
return "%s %s" % (self.first_name, self.last_name)
@property
def tshirt_size_value(self):
return TshirtSize.labels[
self.tshirt_size] if self.tshirt_size else None
class Beer(models.Model):
style = EnumField(BeerStyle)
state = EnumField(BeerState, null=True, blank=True)
class Lamp(models.Model):
state = EnumField(LampState)
class Beer(models.Model):
style = EnumField(BeerStyle)
state = EnumField(BeerState, null=True, db_index=False)
class Person(models.Model):
status = EnumField(PersonStatus, default=PersonStatus.ALIVE)
def save(self, *args, **kwargs):
super(Person, self).save(*args, **kwargs)
return 'Person.save'
class Beer(models.Model):
style = EnumField(BeerStyle)
state = EnumField(BeerState, null=True, blank=True)
label = EnumField(LabelBeer, default=get_default_beer_label)
class Lamp(models.Model):
state = EnumField(LampState, verbose_name="stately_state")
class Team(BaseModel):
name = models.CharField(max_length=255)
event = models.ForeignKey(Event, on_delete=models.CASCADE)
author = models.ForeignKey(Participant,
related_name='team_author_set',
on_delete=models.CASCADE)
coach = models.ForeignKey(Participant,
related_name='team_coach_set',
null=True,
blank=True,
on_delete=models.CASCADE)
status = EnumField(TeamStatus, default=TeamStatus.NEW)
objects = TeamManager()
def __str__(self):
return self.name
@property
def ordered_participants(self):
ret = []
for p in self.participants.all():
if p == self.author:
ret.insert(0, p)
else:
ret.append(p)
return ret
@property
def title(self):
organizations = '+'.join(
sorted(
set(p.organization.abbreviation or 'none'
for p in self.participants.all() if p.organization)))
names = ', '.join(p.last_name for p in self.ordered_participants)
ret = f'{self.name}: {names}'
if organizations:
ret = f'[{organizations}] {ret}'
return ret
@property
def members(self):
ret = self.ordered_participants
if self.coach:
ret.append(self.coach)
return ret
@property
def organizations(self):
ret = [
p.organization for p in self.participants.all() if p.organization
]
duplicate = set()
ret = [
x for x in ret if x.id not in duplicate and not duplicate.add(x.id)
]
return ret
@property
def country(self):
country, repeat = Counter(
p.country.name for p in self.participants.all()).most_common(1)[0]
return country
@property
def status_label(self):
return TeamStatus.labels[self.status]
def attach_login(self, cache=None):
event = self.event
filename = event.logins_paths[self.status_label]
if cache is None or filename not in cache:
passwords = {}
with open(filename, 'r') as fo:
reader = csv.reader(fo)
for username, password in reader:
login = Login.objects.filter(username=username).first()
if login is None:
passwords[username] = password
elif login.password != password:
login.password = password
login.save()
if cache is not None:
cache[filename] = passwords
else:
passwords = cache[filename]
if Login.objects.filter(team=self, stage=self.status).exists():
return False, None
username = random.choice(list(passwords.keys()))
password = passwords.pop(username)
login = Login.objects.create(team=self,
stage=self.status,
username=username,
password=password)
return True, login
class Meta:
unique_together = (
'name',
'event',
)
