class Bird(models.Model):
name = models.CharField(max_length=50)
date_of_birth = models.DateField('Date of Birth',
blank=True,
default=date.today)
color = EnumChoiceField(color, blank=True, default=color.default)
height = models.DecimalField(max_digits=5,
decimal_places=2,
blank=True,
default=0)
weight = models.DecimalField(max_digits=5,
decimal_places=2,
blank=True,
default=0)
date_entered = models.DateField('Date Entered Shelter', default=date.today)
bio = models.TextField(blank=True, default="")
shelter = models.ForeignKey('shelter')
species = EnumChoiceField(Species, default=Species.bird, editable=False)
breed = EnumChoiceField(bird_breed, blank=True, default=bird_breed.default)
adoption_status = EnumChoiceField(adopt_status,
default=adopt_status.available)
def __unicode__(self):
return self.name + " " + unicode(
self.date_entered.strftime('%Y-%m-%d'))
class DesiredMate(models.Model):
breed = models.CharField(choices=Breeds, default='beagle', max_length=100)
#breed = MultiSelectField(choices = BreedsDesiredMate, default = ['beagle', 'sapsal'])
sex = EnumChoiceField(SexDesiredMate, default=SexDesiredMate.male)
size = EnumChoiceField(SizeDesiredMate, default=SizeDesiredMate.small)
personality = models.OneToOneField(PersonalityDesiredMate,
on_delete=models.CASCADE)
class JobListingList(models.Model):
'''Postgres database view'''
id = models.BigIntegerField(primary_key=True)
company_name = models.TextField()
job_title = models.TextField()
description = models.TextField()
position_type = EnumChoiceField(enum_class=JobPositionType)
contract_length = models.IntegerField()
salary = models.IntegerField()
salary_frequency = EnumChoiceField(enum_class=SalaryFrequency)
languages = ArrayField(models.TextField())
city = models.TextField()
state_name = models.TextField()
country_name = models.TextField()
post_code = models.TextField()
tags = ArrayField(models.TextField())
status = models.IntegerField()
created_date = models.DateTimeField()
modified_date = models.DateTimeField()
published_date = models.DateTimeField()
closed_date = models.DateTimeField()
objects = ModelManager()
class Meta:
managed = False
db_table = 'job_listing_joblistinglistview'
class Schema(models.Model):
"""Schema model"""
external_id = models.PositiveIntegerField(null=False, blank=False)
type = EnumChoiceField(SchemaTypeChoice)
name = models.CharField(max_length=128, null=False, blank=False)
ebcdic = models.BooleanField(default=False)
format = EnumChoiceField(SchemaFormatChoice)
fields = django.contrib.postgres.fields.JSONField()
class Lead(BaseModel):
first_name = models.CharField(max_length=64, blank=False, null=False, )
last_name = models.CharField(max_length=64, blank=False, null=False, )
mobile = models.CharField(max_length=13, blank=False, null=False, )
email = models.CharField(max_length=128, blank=False, null=False,unique=True)
location_type = EnumChoiceField(LocationType, default=LocationType.Country)
location_string = models.CharField(max_length=64)
status = EnumChoiceField(LeadStatus, default=LeadStatus.Created)
communication = models.CharField(max_length=512,null=True)
tags = models.CharField(max_length=512, null=True) # Comma List
class Game(models.Model):
# Future improvements: peg1 - peg4 should be an array
peg1 = EnumChoiceField(Color, default=Color.Green)
peg2 = EnumChoiceField(Color, default=Color.Green)
peg3 = EnumChoiceField(Color, default=Color.Green)
peg4 = EnumChoiceField(Color, default=Color.Green)
# Future improvement - I would add a boolean field in the response stating if the game was won or not
def __str__(self):
return "GamedId: {}".format(self.id)
class AttemptResponse(models.Model):
# Future improvements: response1 - response4 should be an array
response1 = EnumChoiceField(ResultColor, null=True, blank=True)
response2 = EnumChoiceField(ResultColor, null=True, blank=True)
response3 = EnumChoiceField(ResultColor, null=True, blank=True)
response4 = EnumChoiceField(ResultColor, null=True, blank=True)
def __str__(self):
return "Attempt response: {} {} {} {}".format(self.response1,
self.response2,
self.response3,
self.response4)
class Priority(BaseModel):
priority_id = models.AutoField(primary_key=True)
user_class = EnumChoiceField(UserClass, default=UserClass.FIRST)
user_study = EnumChoiceField(UserStudy, default=UserStudy.DATAING)
class Meta:
ordering = ("user_class", "user_study")
verbose_name_plural = "Priorities"
def __str__(self):
return f"{self.user_class} {self.user_study}"
class Companion(models.Model):
user = models.ForeignKey('auth.User',
related_name='companion',
on_delete=models.CASCADE)
name = models.CharField(null=False, blank=False, max_length=15)
sex = EnumChoiceField(Sex, default=Sex.male)
birth_year = models.PositiveIntegerField(default=2018)
breed = models.CharField(choices=Breeds, default='beagle', max_length=100)
size = EnumChoiceField(Size, default=Size.small)
desired_mate = models.OneToOneField(DesiredMate, on_delete=models.CASCADE)
personality = models.OneToOneField(Personality, on_delete=models.CASCADE)
mating_season = models.OneToOneField(MatingSeason,
on_delete=models.CASCADE)
class Bet(models.Model):
description = models.TextField()
wager = models.TextField()
bettor = models.CharField(max_length=100)
opponent = models.CharField(max_length=100)
deadline = models.DateTimeField('end date')
created_at = models.DateTimeField('bet made date', auto_now_add=True)
outcome = EnumChoiceField(BetResultChoice, blank=True, null=True)
state = EnumChoiceField(BetStateChoice, default=BetStateChoice.O)
def __str__(self):
return "Description: {}, Bettor: {}, Opponent: {}, Deadline: {}, Outcome: {}"\
.format(self.description, self.bettor, self.opponent, self.deadline, self.outcome)
class AttemptSerializer(serializers.ModelSerializer):
game = GameSerializer(read_only = True)
result = AttemptResponseSerilaizer()
class Meta:
model = Attempt
fields = '__all__'
id = serializers.UUIDField(read_only = True)
peg1 = EnumChoiceField(enum_class = Color)
peg2 = EnumChoiceField(enum_class = Color)
peg3 = EnumChoiceField(enum_class = Color)
peg4 = EnumChoiceField(enum_class = Color)
class MembershipHistory(BaseModel):
"""Model for a Group Membership History"""
user = models.ForeignKey(User, on_delete=models.CASCADE)
group = models.ForeignKey(Group, on_delete=models.CASCADE)
membership_type = EnumChoiceField(MembershipType, default=MembershipType.MEMBER)
start_date = models.DateTimeField()
end_date = models.DateTimeField()
class Meta:
unique_together = ("user", "group", "end_date")
verbose_name = "Membership History"
verbose_name_plural = "Membership Histories"
def __str__(self):
return f"{self.user} - {self.group} - {self.membership_type} - {self.end_date}"
@staticmethod
def from_membership(membership):
"""Creates a Membership History object from a Membership object"""
MembershipHistory.objects.create(
user=membership.user,
group=membership.group,
membership_type=membership.membership_type,
start_date=membership.created_at,
end_date=today(),
)
class Sliders(models.Model):
slider_id = models.BigIntegerField
slider_url = models.ImageField(upload_to=Image_Path, default='')
type_slider = EnumChoiceField(enum_class=TypeState, default=TypeState.book)
def __str__(self):
return str(self.type_slider)
class Attempt(models.Model):
# Future improvements: peg1 - peg4 should be an array
peg1 = EnumChoiceField(Color, default=Color.Green)
peg2 = EnumChoiceField(Color, default=Color.Green)
peg3 = EnumChoiceField(Color, default=Color.Green)
peg4 = EnumChoiceField(Color, default=Color.Green)
game = models.ForeignKey(Game, on_delete=models.CASCADE)
result = models.OneToOneField(AttemptResponse,
on_delete=models.CASCADE,
null=True,
blank=True)
def __str__(self):
return "Attempt for game {} values: {} {} {} {}".format(
self.game.id, self.peg1, self.peg2, self.peg3, self.peg4)
class RoomSerializer(serializers.ModelSerializer):
# room_type = RoomTypeSerializer()
status = EnumChoiceField(enum_class=Status)
class Meta:
model = Rooms
fields = '__all__'
class Food(models.Model):
"""To create the Food table in the database with 8 attributs (fields)."""
name = models.CharField("nom de l'aliment", max_length=255)
brand = models.CharField("marque de l'aliment",
max_length=100,
null=False,
default='rien')
category = models.ForeignKey(Category,
on_delete=models.CASCADE,
related_name='category',
verbose_name="catégorie")
nutrition_grade = EnumChoiceField(NutritionGrade,
verbose_name="nutriscore")
nutrition_score = models.SmallIntegerField("autre nutriscore")
url = models.URLField("url de la fiche de l'aliment")
image_food = models.URLField("url de l'image de l'aliment")
image_nutrition = models.URLField(
"url de l'image des repères nutritionnels de l'aliment")
class Meta:
"""Each (name + brand) item must be unique."""
verbose_name = "aliment"
unique_together = ("name", "brand")
def __str__(self):
return '%s %s' % (self.name, self.brand)
class Notification(models.Model):
class Meta:
app_label = 'notification'
actor = models.ForeignKey('core.User',
related_name='notifications',
on_delete=models.CASCADE)
verb = EnumChoiceField(NotificationVerb)
content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
object_id = models.PositiveIntegerField()
content_object = GenericForeignKey('content_type', 'object_id')
time = models.DateTimeField(auto_now_add=True, db_index=True)
objects = NotificationManager()
def get_absolute_url(self):
if self.content_type.model_class() == apps.get_model('core.Dataset'):
return reverse('dataset', args=[str(self.object_id)])
raise Exception('No url defined for this content type')
def get_full_url(self):
"""
Get the full url of the content_object (with the server scheme and url).
"""
return '%s://%s%s' % (settings.SERVER_SCHEME, settings.SERVER_URL,
self.get_absolute_url())
def __str__(self):
return f'N: {self.actor} {self.verb} {self.object_id} {self.time}'
class Faq(models.Model):
buz_id = models.ForeignKey(
'Company', on_delete=models.CASCADE,
)
class_kind = EnumChoiceField(Enum_Kind)
owner = models.CharField('Owner.', max_length=20, null=True)
subject = models.CharField('Subject.', max_length=100)
content = models.TextField('Content', null=True)
attach = models.FileField('Attachment.', upload_to='uploads/faq/%Y/%m/%d/',
max_length=100, blank=True)
passno = models.CharField('Password.', max_length=4, null=True,
help_text=('Required. 4 digits Only.'))
cdate = models.DateTimeField('Create Date', auto_now_add=True)
mdate = models.DateTimeField('Modify Date', auto_now=True)
class Meta:
db_table = 'faq'
verbose_name_plural = 'faqs'
ordering = ['-mdate']
def __str__(self):
return self.subject
def get_absolute_url(self):
return reverse('faq:faq_detail', args=(self.id,))
def get_previous_faq(self):
return self.get_previous_by_mdate()
def get_next_faq(self):
return self.get_next_by_mdate()
def save(self, *args, **kwargs):
super(Faq, self).save(*args, **kwargs)
class WorkflowStepSchemaSerializer(serializers.ModelSerializer):
id = serializers.IntegerField(required=False, read_only=False)
type = EnumChoiceField(enum_class=WorkflowStepSchemaTypeChoice)
class Meta:
model = WorkflowStepSchema
fields = ('id', 'type', 'name', 'schema')
class CheckInBookingSerializer(serializers.ModelSerializer):
customer_first_name = serializers.CharField(required=False,
allow_blank=True)
customer_last_name = serializers.CharField(required=False,
allow_blank=True)
adults = serializers.IntegerField(required=False)
child = serializers.IntegerField(required=False)
# booking_id = serializers.CharField(required=False)
address = serializers.CharField(required=False, allow_blank=True)
check_in = serializers.DateField(required=False)
check_out = serializers.DateField(required=False)
number_of_days = serializers.IntegerField(required=False)
email = serializers.EmailField(required=False, allow_blank=True)
id_proof_one = serializers.FileField(required=False)
id_proof_two = serializers.FileField(required=False)
token_amount = serializers.FloatField(required=False)
pincode = serializers.IntegerField(required=False)
status = serializers.BooleanField(required=False, read_only=True)
checked_in = serializers.BooleanField(required=False, read_only=True)
taluka = serializers.CharField(required=False, allow_blank=True)
booking_status = EnumChoiceField(enum_class=Status)
def create(self, validated_data):
check_in_instance = Booking.objects.create(
checked_in=True, booking_status=Status.Occupied, **validated_data)
RoomStatus.objects.create(booking=check_in_instance,
room=check_in_instance.room,
from_date=check_in_instance.check_in,
to_date=check_in_instance.check_out,
room_status=Status.Occupied)
return check_in_instance
class Meta:
model = Booking
fields = '__all__'
class CurrentAndUpcomingReservation(pg.ReadOnlyMaterializedView):
class Meta:
managed = False
# Must declare a unique key which can be used against for concurrent refreshes.
concurrent_index = 'reservation_id'
##############
# Attributes #
##############
reservation_id = models.UUIDField(primary_key=True,
default=uuid.uuid4,
editable=False)
first_name = models.CharField(max_length=255, null=False)
last_name = models.CharField(max_length=255)
in_date = models.DateField(editable=False, null=False)
out_date = models.DateField(editable=False, null=False)
room_number = models.CharField(max_length=255, null=False)
checkin_datetime = models.DateTimeField(null=True)
checkout_datetime = models.DateTimeField(null=True)
status = EnumChoiceField(enum_class=ReservationState,
default=ReservationState.pending,
null=False)
sql = CURRENT_AND_UPCOMING_RESERVATIONS_SQL
class MembershipModel(models.Model):
""" Membership details """
# Auto-generated membership number as primary key
membership_no = models.AutoField(primary_key=True)
# Default to object creation time, but allow this to be set manually
date_joined = models.DateField(default=date.today)
# Whether or not the membership fee has been payed (if applicable)
group_expiry = models.DateField(default=one_year_from_today)
type = EnumChoiceField(MembershipType, default=MembershipType.member)
""" Membership relationships """
member = models.ForeignKey(UserModel, on_delete=models.CASCADE)
group = models.ForeignKey(GroupModel, on_delete=models.CASCADE)
class Meta:
""" Configure the name displayed in the admin panel """
verbose_name = "Membership"
verbose_name_plural = "Memberships"
unique_together = ("member", "group")
def __str__(self):
return "Membership for {} to {}".format(str(self.member),
str(self.group))
def is_singular_board_member(self):
return self.type in MembershipType.singular_board_members()
def is_board_member(self):
return self.type in MembershipType.board_members()
class Profile(models.Model):
user = models.OneToOneField('auth.User', on_delete=models.CASCADE)
nickname = models.CharField(null=False, blank=False, max_length=15)
first_address = models.CharField(null=False, blank=False, max_length=100)
second_address = models.CharField(null=False, blank=False, max_length=100)
age = models.PositiveIntegerField(default=0)
gender = EnumChoiceField(Sex, default=Sex.male)
email = models.CharField(null=False, blank=False, max_length=30)
class Workflow(models.Model):
"""Workflow model"""
name = models.CharField(max_length=128, null=False, blank=False)
type = EnumChoiceField(WorkflowTypeChoice)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
version = models.PositiveIntegerField()
description = models.TextField(null=True, blank=True)
class WorkflowStepSchema(models.Model):
"""WorkflowStepSchema model"""
name = models.CharField(max_length=128)
type = EnumChoiceField(WorkflowStepSchemaTypeChoice)
workflow_step = models.ForeignKey(WorkflowStep,
related_name='schemas',
on_delete=models.CASCADE)
schema = models.ForeignKey(Schema, on_delete=models.CASCADE)
class OfferIpo(models.Model):
company_name = models.CharField(max_length=150)
country_id = models.ForeignKey(Structure,
on_delete=models.CASCADE,
related_name='country',
null=True)
exchange_code = models.CharField(max_length=10)
offer_type = EnumChoiceField(OfferType, default=OfferType.ipo)
quarter_type = EnumChoiceField(OfferMethod, default=OfferMethod.sal)
open_date = models.DateField(null=True)
close_date = models.DateField(null=True)
extended_date = models.DateField(null=True)
proposed_listing_date = models.DateField(null=True)
actual_listing_date = models.DateField(null=True)
def __str__(self):
return self.company_name
class DataLocation(CoreModel):
"""
Represent a data location.
"""
class Meta:
app_label = 'core'
get_latest_by = "added"
ordering = ['added']
backend = models.ForeignKey(
'core.StorageResource',
verbose_name="Storage back-end",
on_delete=models.CASCADE,
help_text='Select the storage or application platform that holds data.'
)
category = EnumChoiceField(
StorageLocationCategory,
default=StorageLocationCategory.master,
blank=False,
null=False,
verbose_name='Nature of data copy.',
help_text='Is this the master copy, a working copy or a backup?.')
dataset = models.ForeignKey('core.Dataset',
related_name='data_locations',
on_delete=models.CASCADE)
datatypes = models.ManyToManyField(
"core.DataType",
verbose_name="Stored datatypes",
blank=True,
related_name="storage_locations",
help_text=
'The scope of this storage. Leave empty if all data types are stored in a single location.'
)
data_declarations = models.ManyToManyField(
'core.DataDeclaration',
blank=True,
related_name='data_locations',
verbose_name='Stored data declarations',
help_text=
'The scope of this storage. Leave empty if all data declarations are stored in a single location.'
)
location_description = TextFieldWithInputWidget(
blank=True,
null=True,
verbose_name='Location of the data',
help_text=
'E.g. Laptop 1, server folder path or application URL endpoint.')
def __str__(self):
return '{} - {} - {}'.format(self.category, self.backend.name,
self.location_description)
class Cheatsheet(BaseModel, BasePermissionModel):
write_access = AdminGroup.admin()
read_access = [Groups.TIHLDE]
id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
title = models.CharField(max_length=200)
creator = models.CharField(max_length=200)
grade = EnumChoiceField(UserClass, default=UserClass.FIRST)
study = EnumChoiceField(UserStudy, default=UserStudy.DATAING)
course = models.CharField(max_length=200)
type = EnumChoiceField(CheatsheetType, default=CheatsheetType.LINK)
official = models.BooleanField(default=False)
url = models.URLField(max_length=600)
class Meta:
verbose_name = "Cheatsheet"
verbose_name_plural = "Cheatsheets"
def __str__(self):
return f"{self.title} {self.course}"
class AbstractVideoTranscode(models.Model):
media_format = EnumChoiceField(MediaFormats)
quality = EnumChoiceField(VideoQuality, default=VideoQuality.default)
processing = models.BooleanField(default=False)
file = models.FileField(null=True, blank=True, verbose_name=_('file'),
upload_to=get_upload_to)
error_message = models.TextField(blank=True)
@property
def url(self):
return self.file.url
def get_upload_to(self, filename):
folder_name = 'video_transcodes'
filename = self.file.field.storage.get_valid_name(filename)
return os.path.join(folder_name, filename)
class Meta:
abstract = True
class Chapter(models.Model):
chapter_no = models.PositiveIntegerField(null=True, blank=True)
chapter_name = models.CharField(max_length=100)
chapter_url = models.FileField(upload_to='static/book', default='')
state = EnumChoiceField(enum_class=State, default=State.free)
book_id = models.ForeignKey(Books, on_delete=models.CASCADE, default=1)
def __str__(self):
return self.chapter_name
