class AgentUser(auth.models.User, auth.models.PermissionsMixin):
user_type =models.CharField(max_length=10,default="agent")
address = models.TextField(max_length=255)
pincode = models.CharField(max_length=6, default='000000')
city = models.ForeignKey(City,on_delete=models.CASCADE)
state= models.ForeignKey(State,on_delete=models.CASCADE)
mobile = models.CharField(max_length=255)
birth_date= models.DateField(blank=True)
proof_document= models.FileField(blank=True, upload_to='agent_proof_document')
resume_document =models.FileField(blank=True, upload_to='agent_resume_document')
image = models.ImageField(blank=True, upload_to='agent_image')
interview_date =models.DateTimeField(blank=True, null=True)
interviewed = models.BooleanField(default=False, blank=True)
contacted = models.BooleanField(default=True)
approved =models.BooleanField(default=False)
def agent_approved(self):
self.approved = True
self.save()
def __str__(self):
return '@{}'.format(self.username)
def get_absolute_url(self):
return reverse_lazy('auctions:agent_profile', kwargs={'pk': self.pk}) # This represent after doing Comment Where user should redirect
class Meta:
verbose_name=('AgentUser')
verbose_name_plural =('AgentUsers')
class Classes(models.Model):
class_id = models.UUIDField(primary_key=True,
blank=False,
default=uuid.uuid4,
editable=False)
credit = models.IntegerField(blank=False, verbose_name='credit')
section_id = models.PositiveSmallIntegerField(
verbose_name="class section ID", blank=False)
start_time = models.TimeField(auto_now=False,
blank=False,
verbose_name="class start time")
end_time = models.TimeField(auto_now=False,
blank=False,
verbose_name="class end time")
course_part = models.ForeignKey(to='Courses',
on_delete=models.CASCADE,
verbose_name='Course part')
grade_scale = models.ForeignKey(to='GpaScale',
on_delete=models.CASCADE,
verbose_name='Grade Scale',
blank=False)
weights = models.ForeignKey(to='Weights',
on_delete=models.CASCADE,
verbose_name='Grade weights',
blank=False)
students = models.ArrayReferenceField(to=Student, on_delete=models.CASCADE)
teachers = models.ArrayReferenceField(to=Teacher, on_delete=models.CASCADE)
def __str__(self):
return str(self.course_part) + '_' + str(self.section_id)
class Audit(models.Model):
audit_id = models.AutoField(primary_key=True)
organization = models.ForeignKey(to='organization.Organization',
on_delete=models.CASCADE,
blank=False,
null=False,
default=0)
inventory_items = models.ManyToManyField(Item, blank=True, default=0)
assigned_sk = models.ManyToManyField(to='user_account.CustomUser',
blank=True,
default=0)
initiated_by = models.ForeignKey(to=USER_MODEL,
on_delete=models.CASCADE,
related_name='initiated_by')
initiated_on = models.DateTimeField(
auto_now_add=True) # Auto set when object is first created
last_modified_on = models.DateTimeField(
auto_now=True) # Auto set every time object is saved
assigned_sk = models.ManyToManyField(to=USER_MODEL, blank=True, default=0)
template_id = models.ForeignKey(AuditTemplate,
on_delete=models.CASCADE,
blank=True,
null=True)
accuracy = models.FloatField(default=0.0)
ACTIVE = 'Active'
AUDIT_STATUS = [(PENDING, 'Pending'), (COMPLETE, 'Complete'),
(ACTIVE, 'Active')]
status = models.CharField(max_length=12,
choices=AUDIT_STATUS,
default=PENDING)
class StateSave(models.Model):
id = models.AutoField(primary_key=True)
name = models.CharField(max_length=200, null=True)
description = models.CharField(max_length=400, null=True)
save_time = models.DateTimeField(auto_now=True, db_index=True)
create_time = models.DateTimeField(auto_now_add=True)
save_id = models.UUIDField(default=uuid.uuid4)
data_dump = models.TextField(null=False)
shared = models.BooleanField(default=False)
owner = models.ForeignKey(get_user_model(),
null=True,
on_delete=models.CASCADE)
base64_image = models.ImageField(upload_to='circuit_images',
storage=file_storage,
null=True)
version = models.CharField(max_length=20, null=False)
branch = models.CharField(max_length=20, null=False)
is_arduino = models.BooleanField(default=False, null=False)
esim_libraries = models.ManyToManyField(Library)
project = models.ForeignKey(to=Project,
on_delete=models.SET_NULL,
null=True)
def save(self, *args, **kwargs):
super(StateSave, self).save(*args, **kwargs)
def __str__(self):
return self.name
class Assignment(models.Model):
assignment_id = models.UUIDField(primary_key=True,
blank=False,
default=uuid.uuid4,
editable=False)
class_part = models.ForeignKey(to="Classes", on_delete=models.CASCADE)
assignment_type = models.CharField(choices=assignment_choices,
max_length=50)
document = models.ForeignKey(to='Documents',
blank=True,
on_delete=models.CASCADE)
name = models.CharField(max_length=300,
blank=False,
verbose_name='assignment name')
available_at = models.DateTimeField(
verbose_name='assignment available start date', blank=True)
available_end = models.DateTimeField(
verbose_name='assignment available end date', blank=False)
graded = models.BooleanField(verbose_name='graded', blank=False)
total_points = models.IntegerField(
blank=False, verbose_name='total points in assignment')
points_earned = models.IntegerField(
blank=True, verbose_name='total points earned in assignment')
def __str__(self):
return self.name
class Declaracao(models.Model):
id = models.ObjectIdField()
numero = models.CharField(max_length=10)
id_uasg = models.ForeignKey(Uasg, on_delete=models.CASCADE)
id_fornecedor = models.ForeignKey(Fornecedor, on_delete=models.CASCADE)
def filter_fornecedor_mesmo_pregao(self):
# Essa funcao retorna uma lista de declaracoes do mesmo pregao ao qual
# self se refere (aonde "numero" e o codigo do pregao [Ex.:132017] e o
# id_uasg define o uasg)
declaracoes_concorrentes = list(
Declaracao.objects.filter(numero=self.numero,
id_uasg=self.id_uasg_id))
fornecedores_concorrente = [
Fornecedor.objects.get(id=d.id_fornecedor_id)
for d in declaracoes_concorrentes
]
return fornecedores_concorrente
def filter_contrato(self):
# Essa func�o retorna uma lista de objetos "Contrato" com todos os contratos relacionados ao pregao dessa declara��o
contratos_pregao = list(
Contrato.objects.filter(numero_aviso_licitacao=self.numero,
uasg=self.id_uasg_id))
return contratos_pregao
class Variation(models.Model):
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
name = models.CharField(max_length=100)
creator = models.ForeignKey(get_user_model(), on_delete=models.CASCADE)
composition = models.ForeignKey(Composition, on_delete=models.CASCADE)
tracks = models.ManyToManyField(
Track,
through='TrackInVariation',
)
def copy_variation(self, variation):
self.name = variation.name
self.creator = variation.creator
self.composition = variation.composition
self.tracks.set(variation.tracks)
def save(self, *args, **kwargs):
user = kwargs.pop('user')
composition_id = kwargs.pop('composition_id')
self.creator = user
self.composition = Composition.objects.get(id=composition_id)
super().save(*args, **kwargs)
# def __str__(self):
# return self.name + ' (' + str(self.composition) + ') - ' + self.creator.username
class Rating(models.Model):
user = models.ForeignKey('auth.User', related_name='ratings', on_delete=models.CASCADE)
movie = models.ForeignKey(Movie, related_name='ratings', on_delete=models.CASCADE)
rating = models.IntegerField()
class Meta:
unique_together = ('user', 'movie')
class DarwinBuffering(models.Model):
interval = models.PositiveIntegerField(
default=300,
help_text=_(
"Number of seconds to cache data before analysing the batch"),
null=False)
required_log_lines = models.PositiveIntegerField(
default=10,
help_text=_(
"Minimal number of entries to require before launching analysis"),
null=False)
buffer_filter = models.ForeignKey("darwin.FilterPolicy",
related_name="buffers",
on_delete=models.CASCADE,
null=True)
destination_filter = models.ForeignKey("darwin.FilterPolicy",
related_name="buffering",
on_delete=models.CASCADE)
def to_dict(self):
return {
"interval": self.interval,
"required_log_lines": self.required_log_lines
}
class AnswerBase(models.Model):
question = models.ForeignKey(
SubCriteria, on_delete=models.SET_NULL, blank=True, null=True)
response = models.ForeignKey(
Response, on_delete=models.SET_NULL, blank=True, null=True)
created = models.DateTimeField(auto_now_add=True)
updated = models.DateTimeField(auto_now=True)
class Order(models.Model):
user = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.CASCADE)
ref_code = models.CharField(max_length=20, blank=True, null=True)
products = models.ManyToManyField(OrderItem, blank=True)
start_date = models.DateTimeField(auto_now_add=True)
ordered_date = models.DateTimeField()
ordered = models.BooleanField(default=False)
shipping_address = models.ForeignKey('Address',
related_name='shipping_address',
on_delete=models.CASCADE,
default=None)
billing_address = models.ForeignKey('Address',
related_name='billing_address',
on_delete=models.CASCADE,
default=None)
payment = models.ForeignKey('Payment',
on_delete=models.CASCADE,
default=None)
being_delivered = models.BooleanField(default=False)
received = models.BooleanField(default=False)
def __str__(self):
return self.user.username
def get_total(self):
total = 0
for order_item in self.products.all():
total += order_item.get_final_price()
return total
class Bid(models.Model):
"""
Bid object. The criteria a buyer specifies for a swipe such that he/she is willing to purchase the swipe.
"""
BID_STATES = [
(
'0', 'Pending'
), # Doesn't meet minimum, sits in the queue until an eligible listing pops up
(
'1', 'Accepted'
), # Pairing between buyer and seller has been made (either at the time of bid or after a swipe was created)
(
'2', 'Confirmed'
), # Transaction has occured between buyer and seller, whether successful or refund-based
]
bid_id = models.AutoField(primary_key=True)
status = models.CharField(max_length=1, choices=BID_STATES, default=0)
swipe = models.ForeignKey(Swipe, on_delete=models.CASCADE, null=True)
buyer = models.ForeignKey(User, on_delete=models.DO_NOTHING)
hall_id = models.ForeignKey(DiningHall, on_delete=models.DO_NOTHING)
bid_price = models.DecimalField(max_digits=5, decimal_places=2)
desired_time = models.TimeField(null=True)
visibility = models.ListField(
blank=True, null=True, default=[]
) # An array of JSON objects that contains intervals when this buyer wants the swipe
class Ride(TimeModel):
_id = models.ObjectIdField(primary_key=True)
id = models.CharField(max_length=200)
driver = models.ForeignKey(User,
on_delete=models.DO_NOTHING,
related_name='driver')
customer = models.ForeignKey(User,
on_delete=models.DO_NOTHING,
related_name='customer',
blank=True,
null=True)
departure = models.CharField(max_length=100)
destination = models.CharField(max_length=100)
departure_time = models.DateTimeField()
cost = models.FloatField()
class Meta:
db_table = 'rides'
def save(self, *args, **kwargs):
if not self.pk:
self.id = generate_recovery_code()
super(Ride, self).save(*args, **kwargs)
def __str__(self):
return str(self._id)
class Assembly(models.Model):
id = models.CharField(primary_key=True, max_length=100)
sequences = models.ManyToManyField(to=Sequence,
related_name='assemblies',
blank=True)
biosample = models.ForeignKey(BioSample,
related_name="assemblies",
on_delete=models.CASCADE,
null=True)
count = models.IntegerField(null=True, blank=True)
bp = models.IntegerField(null=True, blank=True)
Ns = models.IntegerField(null=True, blank=True)
gaps = models.IntegerField(null=True, blank=True)
min = models.IntegerField(null=True, blank=True)
max = models.IntegerField(null=True, blank=True)
avg = models.IntegerField(null=True, blank=True)
N50 = models.IntegerField(null=True, blank=True)
owner = models.ForeignKey(Account,
related_name="genomes",
on_delete=models.CASCADE)
DateCreated = models.DateTimeField(verbose_name='date created',
auto_now=True)
LastUpdate = models.DateTimeField(verbose_name='last update',
auto_now=True)
description = models.TextField(null=True, blank=True)
objects = models.DjongoManager()
def __str__(self):
return str(self.id)
class Event(models.Model):
user = models.ForeignKey(User,
default=1,
null=True,
on_delete=models.CASCADE)
event_time = models.DateTimeField(default=dt.utcnow)
event_type = models.CharField(max_length=32)
event_name = models.CharField(max_length=32)
count = models.IntegerField(default=0)
media_type = models.CharField(default="image",
max_length=32) # video or image
media_path = models.CharField(
default=root_path + "/media",
max_length=64) # link to location of media associated to the event
heatmap = models.CharField(
default=root_path + "/media", max_length=64
) # link to location of media heatmap associated to the event
camera = models.ForeignKey(to=Camera, on_delete=models.PROTECT)
def __str__(self):
return f"{self.event_name}: {self.event_type}, count: {self.count}"
def as_json(self):
doc = {
"event_time": self.event_time,
"event_type": self.event_type,
"event_name": self.event_name,
"count": self.count,
"media_type": self.media_type,
"media_path": self.media_path,
"heatmap": self.heatmap,
"camera": self.camera.__str__()
}
return doc
class Post(models.Model):
id = models.AutoField(primary_key=True)
category = models.ForeignKey(Category,
on_delete=models.CASCADE,
related_name='posts')
title = models.CharField(max_length=255)
# title_vn = models.CharField(max_length=255)
content = models.TextField()
# content_vn = models.TextField()
created_at = models.DateTimeField(auto_now_add=True)
update_at = models.DateTimeField(auto_now=True)
thumbnail = models.TextField(null=True)
author = models.ForeignKey(get_user_model(),
on_delete=models.CASCADE,
related_name='posts',
default=1)
author_username = models.CharField(max_length=100, default="admin")
# publish = models.DateTimeField(auto_now=False, auto_now_add=False)
likes = models.ManyToManyField(get_user_model())
objects = models.DjongoManager()
hidden = models.BooleanField(default=False)
flag = models.BooleanField(default=False)
def __str__(self):
return f'{self.title}'
class Task(models.Model):
""" Represents a Tasks assignable to users for project/topic nodes """
STATUS_CHOICES = [
("NEW", "New"),
("IN_PROGRESS", "In Progress"),
("COMPLETE", "Complete"),
]
_id = models.ObjectIdField()
# The node can be a Project or a Subclass of Topic
node = models.ForeignKey("TreeStructure", on_delete=models.CASCADE)
title = models.CharField(max_length=255, unique=False, blank=False)
created_by = models.ForeignKey("vpmoauth.MyUser", on_delete=models.CASCADE, related_name="created_task_set")
created_at = models.DateTimeField(auto_now_add=True, auto_now=False)
updated_at = models.DateTimeField(auto_now=True)
# The user the task is assigned to currently (defaults to created_by)
assignee = models.ForeignKey("vpmoauth.MyUser", on_delete=models.CASCADE, related_name="assigned_task_set")
status = models.CharField(max_length=11, choices=STATUS_CHOICES, blank=False, unique=False)
due_date = models.DateField(auto_now=False, auto_now_add=False, null=False)
closed_at = models.DateTimeField(auto_now=False, auto_now_add=False, null=True)
def __str__(self):
return "<{title}>: {due_date}".format(title=self.title, due_date=self.due_date.strftime("%d/%m/%Y"))
def save(self, *args, **kwargs):
""" Minor amendments to save for generic conditions """
if self.status != "COMPLETE":
self.closed_at = None
super(Task, self).save(*args, **kwargs)
class RoomReservation(models.Model):
reservation_id = models.AutoField(primary_key=True)
hotel_id = models.ForeignKey(Hotel,
on_delete=models.CASCADE,
related_name='reservation_hotel')
customer_id = models.ForeignKey(Customer,
on_delete=models.CASCADE,
related_name='reservation_customer',
default='')
room_id = models.ForeignKey(Room,
on_delete=models.CASCADE,
related_name='reservation_room')
reservation_description = models.CharField(max_length=60, default='')
from_date = models.DateField()
to_date = models.DateField()
number_of_adults = models.IntegerField()
number_of_children = models.IntegerField()
payment_no = models.CharField(max_length=120, blank=True, null=True)
def get_absolute_url(self):
return reverse('HotelsAppCRUD:rooms_reservation_index')
def __str__(self):
return "(%s) %s (%s) (%s)" % (self.reservation_id,
self.reservation_description,
self.from_date, self.to_date)
class PropertyReg(models.Model):
user = models.ForeignKey(User,related_name='owner',on_delete=models.CASCADE)
property_type = models.ForeignKey(Property,related_name='property',on_delete=models.CASCADE)
property_address = models.CharField(max_length=255)
pincode = models.CharField(max_length=6, default='000000')
city = models.ForeignKey(City,on_delete=models.CASCADE)
state = models.ForeignKey(State,on_delete=models.CASCADE)
#Thia for map implimentation using some api url
# property_location = models.URLField()
#property_description will be only edited by agentUser
property_description = models.CharField(max_length=2000, default='')
agent_id = models.ForeignKey(AgentUser,related_name='who_approves',on_delete=models.CASCADE, null=True)
approved_date = models.DateTimeField(null=True)
approved = models.BooleanField(default=False)
pre_set_amount = models.IntegerField(default=0)
viewinghours = models.CharField(max_length=20, default="None2")
submitted = models.BooleanField(default=False)
def submit(self):
self.submitted = True
self.save()
def approved_auction(self):
self.approved=True
def get_absolute_url(self):
return reverse_lazy('auctions:agent_property_details', kwargs={'pk': self.pk})
class RoomBilling(models.Model):
reservation_id = models.AutoField(primary_key=True)
customer_id = models.ForeignKey(Customer,
on_delete=models.CASCADE,
related_name='billing_customer')
room_charge_id = models.ForeignKey(RoomCharges,
on_delete=models.CASCADE,
related_name='billing_charge')
invoice_no = models.CharField(max_length=120, default='')
billing_address1 = models.CharField(max_length=120)
billing_address2 = models.CharField(max_length=120, blank=True, null=True)
county = models.CharField(max_length=120)
postal_code = models.CharField(max_length=20)
country = models.CharField(max_length=120)
total_discounts = models.DecimalField(max_digits=5,
decimal_places=2,
default='')
total_invoice = models.DecimalField(max_digits=5,
decimal_places=2,
default='')
def get_absolute_url(self):
return reverse('HotelsAppCRUD:rooms_billing_index')
def __str__(self):
return "(%s) %s" % (self.reservation_id, self.invoice_no)
class RoomReservationView(models.Model):
reservation_id = models.AutoField(primary_key=True)
hotel_id = models.ForeignKey(Hotel, on_delete=models.CASCADE)
customer_id = models.ForeignKey(Customer, on_delete=models.CASCADE)
room_id = models.ForeignKey(Room, on_delete=models.CASCADE)
reservation_description = models.CharField(max_length=60)
from_date = models.DateField()
to_date = models.DateField()
number_of_adults = models.IntegerField()
number_of_children = models.IntegerField()
payment_no = models.CharField(max_length=120, blank=True, null=True)
hotel = models.ArrayModelField(model_container=Hotel, )
customer = models.ArrayModelField(model_container=Customer, )
room = models.ArrayModelField(model_container=Room, )
def get_absolute_url(self):
return reverse('HotelsAppCRUD:rooms_reservation_index')
def __str__(self):
return "(%s) %s (%s) (%s)" % (self.reservation_id,
self.reservation_description,
self.from_date, self.to_date)
class Meta:
managed = False
db_table = 'HotelsAppCRUD_roomreservation_view'
class order(models.Model):
buyer = models.ForeignKey(buyers,
on_delete=models.CASCADE,
related_name='buyer_id_order')
product = models.ForeignKey(product,
on_delete=models.SET_NULL,
null=True,
related_name='product_id_order')
date_of_order = models.DateTimeField()
told_date_of_order = models.DateTimeField()
date_of_delivery = models.DateTimeField()
order_details = models.EmbeddedField(
model_container=order_details_abs,
model_form_class=order_details_abs_form)
quantity = models.IntegerField(null=False)
total_price = models.TextField()
payment_status = models.BooleanField(default=False)
delivery_status = models.BooleanField(default=False)
loan_status = models.BooleanField(default=False)
loan_amount = models.IntegerField(default=None)
cancel_status = models.BooleanField(default=False)
cancel_date = models.DateTimeField()
objects = models.DjongoManager()
class RunningTestsAnswers(models.Model):
_id = models.ObjectIdField()
test_duration = models.IntegerField('Длительность теста')
start_date = models.DateTimeField('Время запуска теста',
default=timezone.now)
test = models.ForeignKey(Test,
null=True,
verbose_name='Запущенный тест',
related_name='right_answers',
on_delete=models.SET_NULL,
default=DEFAULT_TEST_ID)
user = models.ForeignKey(settings.AUTH_USER_MODEL,
null=True,
verbose_name='Пользователь, проходящий тест',
related_name='right_answers',
on_delete=models.SET_NULL,
default=DEFAULT_AUTHOR_ID)
right_answers = models.ArrayField(model_container=QuestionRightAnswer)
objects = models.DjongoManager()
@property
def time_left(self) -> float:
delta = timezone.now() - self.start_date
return self.test_duration - delta.total_seconds()
class Meta:
db_table = 'main_running_tests_answers'
verbose_name = 'Ответы за запущенные тесты'
verbose_name_plural = 'Ответы за запущенные тесты'
class TestResult(models.Model):
_id = models.ObjectIdField()
is_running = models.BooleanField('Тест еще запущен')
comment = models.TextField('Комментарий преподавателя', default='')
date = models.DateTimeField('Время запуска тестирования',
default=timezone.now)
launched_lecturer = models.ForeignKey(
settings.AUTH_USER_MODEL,
null=True,
verbose_name='Пользователь, запустивный тест',
related_name='testing_results',
on_delete=models.SET_NULL)
test = models.ForeignKey(Test,
null=True,
verbose_name='Тест',
related_name='testing_results',
on_delete=models.SET_NULL)
subject = models.ForeignKey(Subject,
null=True,
verbose_name='Предмет',
related_name='testing_results',
on_delete=models.SET_NULL)
objects = models.DjongoManager()
@property
def object_id(self):
return self._id
class Meta:
db_table = 'main_tests_results'
verbose_name = 'Результат тестирования'
verbose_name_plural = 'Результаты тестирований'
class History(models.Model):
user = models.ForeignKey(User, on_delete=models.CASCADE)
series = models.ForeignKey(Series, on_delete=models.CASCADE)
movies = models.ForeignKey(Movie, on_delete=models.CASCADE)
def __str__(self):
return self.user
class UserHistory(models.Model):
user_email = models.ForeignKey(UserData, on_delete=models.CASCADE, related_name="u_user_email")
payment_modes = (
('1', 'Debit/Credit card'),
('2', 'UPI'),
('3', 'Cash'),
('4', 'Net banking'),
)
mode_of_payment = models.CharField(choices=payment_modes, default='2', max_length=1)
timestamp = models.ForeignKey(Booking, on_delete=models.CASCADE, related_name="u_timestamp")
modes = (
(1, 'Bus'),
(2, 'Flight'),
(3, 'Train'),
(4, 'Cab'),
(5, 'Ship'),
)
mode_of_travel = models.IntegerField(choices=modes, default=1)
travel_amount = models.IntegerField()
restaurant = models.CharField(max_length=100)
food_amount = models.IntegerField()
lodge = models.CharField(max_length=100)
stay_amount = models.IntegerField()
def __str__(self):
return f'{self.user_email}\'s history {self.pk}'
class Comment(models.Model):
id = models.UUIDField(primary_key=True,
default=uuid.uuid4,
editable=False,
unique=True)
author = models.ForeignKey('userAuth.User',
null=True,
on_delete=models.SET_NULL,
editable=False,
related_name='comment')
dateTimePosted = models.DateTimeField(auto_now_add=True, editable=False)
dateTimeEdited = models.DateTimeField(auto_now=True, null=True)
parentPost = models.ForeignKey('Post',
null=True,
on_delete=models.CASCADE,
editable=True,
related_name='comment')
content = models.OneToOneField(Content,
on_delete=models.CASCADE,
related_name='comment')
points = models.IntegerField(default=0)
likers = models.ArrayReferenceField(to='userAuth.User',
on_delete=models.SET_NULL,
blank=True,
null=True,
related_name='+')
dislikers = models.ArrayReferenceField(to='userAuth.User',
on_delete=models.SET_NULL,
blank=True,
null=True,
related_name='+')
def __str__(self):
return "Reply to: {}".format(self.post.title)
class Task(djongo_models.Model):
"""Unit of work to be done for the sprint."""
STATUS_TODO = 1
STATUS_IN_PROGRESS = 2
STATUS_TESTING = 3
STATUS_DONE = 4
STATUS_CHOICES = (
(STATUS_TODO, _('Not Started')),
(STATUS_IN_PROGRESS, _('In Progress')),
(STATUS_TESTING, _('Testing')),
(STATUS_DONE, _('Done')),
)
name = djongo_models.CharField(max_length=100)
description = djongo_models.TextField(blank=True, default='')
sprint = djongo_models.ForeignKey(Sprint, blank=True, null=True, on_delete=djongo_models.CASCADE)
status = djongo_models.SmallIntegerField(choices=STATUS_CHOICES, default=STATUS_TODO)
order = djongo_models.SmallIntegerField(default=0)
assigned = djongo_models.ForeignKey(settings.AUTH_USER_MODEL, null=True, blank=True, on_delete=djongo_models.SET_NULL)
started = djongo_models.DateField(blank=True, null=True)
due = djongo_models.DateField(blank=True, null=True)
completed = djongo_models.DateField(blank=True, null=True)
def __str__(self):
return self.name
class TOTPProfile(models.Model):
""" Class for Learning Profiles
Encryption is done via AES256
"""
auth_repository = models.ForeignKey(
to="authentication.BaseRepository",
verbose_name=_("Authentication repository"),
default=None,
on_delete=models.CASCADE)
totp_repository = models.ForeignKey(
to="authentication.OTPRepository",
verbose_name=_("TOTP authentication repository"),
default=None,
on_delete=models.CASCADE,
related_name="totp_profiles_of")
login = models.TextField(verbose_name=_("User's login"), default="")
encrypted_value = models.TextField(default="")
class meta:
unique_together = ("auth_repository", "totp_repository", "login")
def decrypt(self):
"""
:return: Return the password in cleartext
"""
aes = AESCipher(str(settings.SECRET_KEY) + str(self.login))
data = aes.decrypt(self.encrypted_value)
if str(data) == '':
return None
return data
def set_data(self, value):
"""
:return: Return the encrypted value
"""
aes = AESCipher(str(settings.SECRET_KEY) + str(self.login))
self.encrypted_value = aes.encrypt(str(value)).decode('utf8')
return self.encrypted_value
def store(self):
self.save()
def to_dict(self):
return {
'id': str(self.id),
"auth_repository": str(self.auth_repository.id),
"totp_repository": str(self.totp_repository.id),
"login": str(self.login)
}
def to_template(self):
""" returns the attributes of the class """
return {
'id': str(self.id),
'auth_repository': str(self.auth_repository),
'totp_repository': str(self.totp_repository),
'login': self.login
}
class Ferias(models.Model):
OPCOES = (
(15, "Quinze dias"),
(30, "Trinta dias"),
)
objects = models.Manager()
class FeriasFruidas(models.Manager):
def all(self):
return super().get_queryset().filter(
Q(tipo='f') & Q(data_termino__lt=timezone.now().date()) & Q(deferida=True))
class FeriasIndeferidas(models.Manager):
def all(self):
return super().get_queryset().filter(Q(tipo='f') & Q(deferida=False))
class FeriasEmAndamento(models.Manager):
def all(self):
return super().get_queryset().filter(Q(tipo='f') & Q(data_inicio__lte=timezone.now().date()) & Q(
data_termino__gte=timezone.now().date()) & Q(deferida=True))
fruidas = FeriasFruidas()
indeferidas = FeriasIndeferidas()
em_andamento = FeriasEmAndamento()
trabalhador = models.ForeignKey(Trabalhador, on_delete=models.CASCADE)
qtd_dias = models.IntegerField(choices=OPCOES)
data_inicio = models.DateField()
data_termino = models.DateField(editable=False)
criado_em = models.DateTimeField(auto_now_add=True)
modificado_em = models.DateTimeField(auto_now=True)
deferida = models.BooleanField(editable=False, default=False)
observacoes = models.TextField(blank=True, editable=False)
tipo = models.CharField(max_length=2, default='f', editable=False)
fruida = models.BooleanField(editable=False, default=False)
criado_por = models.ForeignKey(User, on_delete=models.SET_NULL, editable=False, null=True, blank=True)
def save(self, validacao=True, *args, **kwargs):
self.data_termino = self.data_inicio + timedelta(days=self.qtd_dias - 1)
if not validacao:
self.deferida = False
else:
self.deferida = valida_ferias(self)
super(Ferias, self).save(*args, **kwargs)
def __str__(self):
return '%d dias - %s -saindo %s' % (self.qtd_dias, self.trabalhador.nome, self.data_inicio.strftime("%d/%m/%Y"))
def get_absolute_url(self):
return reverse('ferias')
class Meta:
verbose_name_plural = "Férias"
verbose_name = "Férias"
ordering = ['data_inicio']
