class SubTask(Document):
""""""
task = fields.ReferenceField('Task',
required=True,
unique=True,
reverse_delete_rule=mongoengine.CASCADE)
created_on = fields.DateTimeField()
modified_on = fields.DateTimeField(default=datetime.datetime.now())
task_parent = fields.ReferenceField('Task',
required=False,
null=True,
blank=True,
unique=False)
sub_task = fields.ListField(fields.ReferenceField(
'Task',
required=False,
null=True,
reverse_delete_rule=mongoengine.PULL),
blank=True)
def save(self, *args, **kwargs):
if not self.created_on:
self.created_on = datetime.datetime.now()
self.modified_on = datetime.datetime.now()
return super(SubTask, self).save(*args, **kwargs)
class Task(Document):
""""""
name = fields.StringField(required=True)
description = fields.StringField()
start_date = fields.DateField()
end_date = fields.DateField()
phase = fields.StringField(choices=PHASES_CHOICE, required=True)
project = fields.ReferenceField('Project',
required=True,
reverse_delete_rule=mongoengine.CASCADE)
assignee = fields.ReferenceField('User',
required=True,
reverse_delete_rule=mongoengine.CASCADE)
reporter = fields.ReferenceField('User',
reverse_delete_rule=mongoengine.NULLIFY)
comments = fields.StringField(null=True)
created_on = fields.DateTimeField()
modified_on = fields.DateTimeField(default=datetime.datetime.now())
parent_task = fields.ReferenceField(
'self',
required=False,
blank=True,
null=True,
reverse_delete_rule=mongoengine.CASCADE)
def save(self, *args, **kwargs):
if not self.created_on:
self.created_on = datetime.datetime.now()
self.modified_on = datetime.datetime.now()
return super(Task, self).save(*args, **kwargs)
class Liga(gj.Document):
nombre = fields.StringField(max_length=100)
lugar = fields.ReferenceField(Localidad, requered=False)
integrantes = fields.ListField(fields.ReferenceField(Heroe),
required=False)
class Appointment(mongoengine.Document):
id = fields.SequenceField(primary_key=True, sequence_name='appointment')
professional = fields.ReferenceField(Professional, required=True)
patient = fields.ReferenceField(Patient, required=True)
start_date = fields.StringField(required=True)
end_date = fields.StringField(required=True)
def to_dict(self, professional_info=False, patient_info=False):
return {
'id': str(self.id),
'professional': self.professional.to_dict(),
'patient_id': str(self.patient.id),
'start_date': self.start_date,
'end_date': self.end_date,
}
@classmethod
def find_by_professional(cls, professional):
try:
return cls.objects(professional=professional)
except errors.DoesNotExist:
return None
@classmethod
def find_by_patient(cls, patient):
try:
return cls.objects(patient=patient)
except errors.DoesNotExist:
return None
class Professional(User):
specialties = fields.ListField(fields.ReferenceField(Specialty,
required=True),
required=True)
insurances = fields.ListField(fields.ReferenceField(Insurance,
required=True),
required=True)
rating = fields.IntField(min_value=0, max_value=5)
address = fields.EmbeddedDocumentField(Address, required=True)
def to_dict(self):
result = super(Professional, self).to_dict()
result['address'] = self.address.to_dict()
result['rating'] = self.rating
result['specialties'] = []
for specialty in self.specialties:
result['specialties'].append(specialty.to_dict())
result['insurances'] = []
for insurance in self.insurances:
result['insurances'].append(insurance.to_dict())
return result
def get_role(self):
return 'professional'
@classmethod
def get_all(cls):
result = []
for professional in cls.objects:
result.append(professional.to_dict())
return result
class Usuario(Document):
usuario = fields.StringField(required=True, max_length=30)
email = fields.EmailField(required=True, max_length=150)
nombre = fields.StringField(max_length=50)
password = fields.StringField(required=True, min_length=8)
imagen = fields.URLField(required=False)
descripcion = fields.StringField(max_length=500)
listaSeguidores = fields.ListField(fields.ReferenceField('Usuario'))
listaSeguidos = fields.ListField(fields.ReferenceField('Usuario'))
listaPublicaciones = fields.ListField(fields.ReferenceField('Publicacion'))
listaComentariosPublicaciones = fields.ListField(
fields.ReferenceField('Publicacion'))
listaGraffitisPublicaciones = fields.ListField(
fields.ReferenceField('Publicacion'))
def delete(self, *args, **kwargs):
for publicacion in self.listaComentariosPublicaciones:
comentarios = publicacion.listaComentarios
for comentario in comentarios:
if comentario.autor == self:
publicacion.__class__.objects.update(
pull__listaComentarios=comentario)
for publicacion in self.listaGraffitisPublicaciones:
graffitis = publicacion.listaGraffitis
for graffiti in graffitis:
if graffiti.autor == self:
publicacion.__class__.objects.update(
pull__listaGraffitis=graffiti)
super().delete()
class InvoicingSettings(EmbeddedDocument):
"""A wrapper to Invoicing's module settings."""
TAXES_APPLICATION = TAXES_APPLICATION
PAYMENT_TYPES = PAYMENT_TYPES
PAYMENT_CONDITIONS = PAYMENT_CONDITIONS
supported_currencies = fields.ListField(fields.ReferenceField("Currency"))
default_currency = fields.ReferenceField("Currency", required=True)
fy_start_month = fields.IntField(required=True,
default=0,
min_value=0,
max_value=11)
inv_taxes_application = fields.StringField(required=True,
choices=TAXES_APPLICATION,
default="EXCLUSIVE")
quotation_validity = fields.IntField(required=True, default=30)
payment_conditions = fields.StringField(required=True,
choices=PAYMENT_CONDITIONS,
default="CASH")
custom_payment_conditions = fields.StringField()
accepted_payment_types = fields.ListField(
fields.StringField(choices=PAYMENT_TYPES),
required=True,
default=lambda: ["CHECK", "CASH", "CREDIT_CARD", "TRANSFER"])
late_fee_rate = fields.DecimalField()
down_payment_percent = fields.DecimalField(required=True,
default=lambda: Decimal("0"))
automatic_reminders = fields.BooleanField(required=True, default=False)
automatic_reminders_text = fields.StringField(max_length=1024)
automatic_reminders_send_copy = fields.BooleanField(required=True,
default=True)
numbering = fields.EmbeddedDocumentField(
"InvoicingNumberingSettings",
required=True,
default=lambda: InvoicingNumberingSettings())
class LocationUpdate(Document):
driver = fields.ReferenceField(User)
timestamp = fields.DateTimeField()
location = fields.StringField()
checkin = fields.BooleanField()
vehicle = fields.ReferenceField(Vehicle)
handoff = fields.ReferenceField(User)
class Message(Document):
author = fields.ReferenceField(User, required=True)
addressee = fields.ReferenceField(User, required=True)
text = fields.StringField(required=True, max_length=40)
created = fields.DateTimeField(required=True,
default=datetime.datetime.now)
read = fields.BooleanField(required=True, default=False)
class Notification(DynamicDocument):
tenant = fields.ReferenceField("Tenant", required=False)
recipient = fields.ReferenceField("VosaeUser", required=True)
sent_at = fields.DateTimeField(required=True, default=datetime_now)
read = fields.BooleanField(required=True, default=False)
meta = {
"indexes": ["tenant", "recipient", "sent_at", "read"],
"ordering": ["-sent_at"],
"allow_inheritance": True
}
@classmethod
def post_save(self, sender, document, **kwargs):
"""
Post save hook handler
Emits notification through the realtime service
"""
from notification.api.resources import NotificationResource
nr = NotificationResource()
try:
resource_type = nr._get_type_from_class(nr._meta.polymorphic,
document.__class__)
except:
resource_type = None
emit_to_channel(
u'private-user-{0}'.format(unicode(document.recipient.id)),
u'new-notification', {
u'id': unicode(document.id),
u'type': resource_type
})
class DislikeShop(Document):
user = fields.ReferenceField(User, reverse_delete_rule=mongoengine.CASCADE)
shop = fields.ReferenceField(Shop, reverse_delete_rule=mongoengine.CASCADE)
created_at = fields.DateTimeField(auto_now = True, default=timezone.now)
def __str__(self):
return self.shop
class ChargeStation(Document):
meta = {
"indexes": [
'network',
'locationId',
]
}
id = fields.IntField(required=True, primary_key=True)
network = fields.ReferenceField(Network)
locationId = fields.IntField(required=True)
name = fields.StringField(required=True, max_length=200)
#0 = Unknown
#1 = Free
#2 = Fee
cost = fields.IntField()
cost_description = fields.StringField(max_length=1000)
address = fields.StringField(max_length=300)
available = fields.IntField(required=True)
hours = fields.StringField(max_length=400)
geoLocation = fields.PointField(auto_index=True)
score = fields.FloatField(min_value=0, max_value=10.0, required=True)
images = fields.ListField(fields.URLField())
chargePoints = fields.ListField(fields.ReferenceField(ChargePoint))
created_at = fields.DateTimeField()
modified_at = fields.DateTimeField(default=datetime.datetime.utcnow())
class Race(BaseDocument):
meta = {'collection': 'mop_races'}
name = fields.StringField(required=True)
description = fields.StringField(required=True)
restrictions = fields.ListField(fields.ReferenceField('Skill'), required=False)
exclusive_skills = fields.ListField(fields.ReferenceField('Skill'), required=False)
class GroupJoinRequest(BaseModel):
uid = fields.StringField(required=True, primary_key=True)
group = fields.ReferenceField(Group, required=True, reverse_delete_rule=2)
user = fields.ReferenceField(User, required=True, reverse_delete_rule=2)
created_at = fields.IntField(required=True)
# db collection
meta = {"collection": "join_requests"}
class Event(SintelDocument):
"""Event object.
An Event represents an anomalous period on a Signal.
It is descrived by start and stop times and, optionally, a severity score.
It is always associated to a Signal and, optionally, to a Signalrun.
"""
SOURCE_ORION = 'ORION'
SOURCE_SHAPE_MATCHING = 'SHAPE_MATCHING'
SOURCE_MANUALLY_CREATED = 'MANUALLY_CREATED'
SOURCE_CHOICES = (SOURCE_ORION, SOURCE_SHAPE_MATCHING,
SOURCE_MANUALLY_CREATED)
signalrun = fields.ReferenceField(Signalrun, reverse_delete_rule=CASCADE)
signal = fields.ReferenceField(Signal, reverse_delete_rule=CASCADE)
start_time = fields.IntField(required=True)
stop_time = fields.IntField(required=True)
severity = fields.FloatField()
source = fields.StringField(required=True, choices=SOURCE_CHOICES)
num_annotations = fields.IntField(default=0)
# HACK - do not have tag currently
tag = fields.StringField()
@property
def annotations(self):
return Annotation.find(event=self)
@property
def event_interactions(self):
return EventInteraction.find(event=self)
@property
def latest_event_interaction(self):
return self.event_interactions.last()
class Place(gj.Document):
title = fields.StringField(required=True,
max_length=70,
unique_with='address')
main_category = fields.StringField(max_length=30, choices=src.categories)
categories = fields.ListField(fields.StringField(max_length=30,
choices=src.categories),
default=[])
main_cuisine = fields.StringField(max_length=30, choices=src.cuisines)
cuisines = fields.ListField(fields.StringField(max_length=30,
choices=src.cuisines),
default=[])
additional_services = fields.ListField(fields.StringField(
max_length=30, choices=src.additional_services),
default=[])
description = fields.StringField(max_length=3000)
phone = fields.StringField(required=True, max_length=20, unique=True)
instagram = fields.URLField()
website = fields.URLField()
timezone = fields.StringField(required=True)
opening_hours = fields.ListField(field=fields.ListField(
field=fields.DateTimeField(default=datetime.utcnow), max_length=2),
max_length=7,
default=[[None, None]] * 7)
address = fields.EmbeddedDocumentField(Address, required=True)
main_photo = fields.ReferenceField(Image, reverse_delete_rule=NULLIFY)
photos = fields.ListField(fields.ReferenceField(Image,
reverse_delete_rule=PULL),
default=[])
general_review = fields.ReferenceField(GeneralReview,
reverse_delete_rule=NULLIFY,
unique=True)
configuration = fields.EmbeddedDocumentField(Configuration)
is_active = fields.BooleanField(default=False)
class TestDocument(db.DynamicDocument):
user = fields.ReferenceField(UserTest,
reverse_delete_rule=mongoengine.CASCADE,
required=True)
data_list = fields.ListField(fields.ReferenceField(DataTest))
count = fields.IntField()
factor = fields.FloatField()
class MessageDocument(Document):
text = fields.StringField(required=False)
images = fields.ListField(
fields.ImageField(collection_name='message_images'), required=False)
document = fields.FileField(collection_name='message_documents',
required=False)
session = fields.ReferenceField(document_type=SessionDocument,
required=True)
room = fields.ReferenceField(document_type=ChatRoomDocument, required=True)
seen_by = fields.ListField(
fields.ReferenceField(document_type=SessionDocument), required=False)
created_at = fields.DateTimeField(required=False)
meta = {'collection': 'messages', 'ordering': ['-created_at']}
@classmethod
def set_timings(cls, sender, document, **kwargs):
"""
Set Created and expiration at on Save
:param sender:
:param document:
:param kwargs:
:return:
"""
document.created_at = datetime.utcnow()
class Activity(Document):
url_number = fields.IntField()
name = fields.StringField(verbose_name=u'活动名称')
detail = fields.StringField(verbose_name=u'活动详情')
creator = fields.GenericReferenceField() # 发起社团
start_time = fields.DateTimeField()
finish_time = fields.DateTimeField()
place = fields.StringField(verbose_name=u'活动地点')
max_student = fields.IntField() # 人数上限
pay = fields.IntField(verbose_name=u'人均花费')
who_likes = fields.ListField(
fields.ReferenceField(Student, reverse_delete_rule=PULL)) # 喜欢活动的人
who_entered = fields.ListField(
fields.ReferenceField(Student, reverse_delete_rule=PULL)) # 参加这个活动的人
clicks = fields.IntField() # 点击数
is_active = fields.BooleanField()
def description(self):
return self.creator.corporation.name + "发起了" + self.name
def is_started(self): # 判断是否已经开始
if self.finish_time < datetime.datetime.now():
return True
else:
return False
def get_reply(self):
from reply.models import Reply
return Reply.objects(target=self)
class Signalrun(OrionDocument, Status):
"""Signalrun object.
The Signalrun object represents a single executions of a Pipeline on a Signal
within a Datarun.
It contains information about whether the execution was successful or not, when
it started and ended, the number of events that were found by the Pipeline, and
where the model and metrics are stored.
"""
datarun = fields.ReferenceField(Datarun, reverse_delete_rule=CASCADE)
signal = fields.ReferenceField(Signal, reverse_delete_rule=CASCADE)
start_time = fields.DateTimeField()
end_time = fields.DateTimeField()
model_location = fields.StringField()
metrics_location = fields.StringField()
num_events = fields.IntField(default=0)
@property
def events(self):
return Event.find(signalrun=self)
def start(self):
"""Mark this Signalrun as started on DB.
The ``start_time`` will be set to ``datetime.utcnow()``,
the ``status`` will be set to RUNNING.
"""
self.start_time = datetime.utcnow()
self.status = self.STATUS_RUNNING
self.save()
def end(self, status, events):
"""Mark this Signalrun as ended on DB.
The ``end_time`` will be set to ``datetime.utcnow()``, the ``status``
will be set to the given value, and the given events will be inserted
into the Database.
"""
try:
if events is None:
events = []
for start_time, stop_time, severity in events:
Event.insert(
signalrun=self,
signal=self.signal,
start_time=start_time,
stop_time=stop_time,
severity=severity,
source=Event.SOURCE_ORION,
)
except Exception:
LOGGER.exception('Error storing signalrun %s events', self.id)
status = self.STATUS_ERRORED
self.end_time = datetime.utcnow()
self.status = status
self.num_events = len(events)
self.save()
class Content(Document):
project = fields.ReferenceField(Project, required=True)
content = fields.DictField(required=True)
file_name = fields.StringField(required=True)
sheet_name = fields.StringField(required=True)
input_headers = fields.ReferenceField(Input_headers, required=True)
status = fields.BooleanField(default=False)
created_at = fields.DateTimeField(default=datetime.utcnow)
class ProblemCondition(Document):
_id = fields.ObjectIdField()
name = fields.StringField()
student = fields.ReferenceField(Student)
problem = fields.ReferenceField(Problem)
result = fields.StringField()
wrong = fields.ListField(fields.StringField())
times = fields.IntField()
class RideRequest(Document):
start = fields.StringField(required=True, null=False)
destination = fields.StringField(required=True, null=False)
start_time = fields.StringField(required=True, null=False)
status = fields.StringField(required=True,
null=False) #pending or fullfilled
requester_id = fields.ReferenceField(User, required=True, null=False)
rider_id = fields.ReferenceField(User)
class Exam(Document):
examName = fields.StringField(max_length=200)
userId = fields.ReferenceField(User)
questionIds = fields.ReferenceField(Question)
categoryId = fields.ReferenceField(Category)
def __str__(self):
self.examName
class Trainer(Document):
user_id = fields.ReferenceField(User)
student_ids = fields.ListField(fields.ReferenceField(Student))
workout_ids = fields.ListField(fields.ReferenceField(Workout))
def add_student(self, student_id):
self.student_ids.append(student_id)
self.save()
class Tag(Document):
_id = fields.ObjectIdField()
name = fields.StringField()
description = fields.StringField()
types = fields.StringField()
difficulty = fields.IntField()
book = fields.ReferenceField(Book)
topic = fields.ListField(fields.ListField(fields.ReferenceField(Chapter)))
class Issue(Document):
name = fields.StringField(max_length=20)
tags = fields.ListField(fields.ReferenceField(Tag))
description = fields.StringField()
createdAt = fields.DateTimeField()
resolved = fields.DateTimeField()
vehicle = fields.ReferenceField(Vehicle)
meta = {'collection': 'issues'}
class GroupMembership(BaseModel):
uid = fields.StringField(required=True, primary_key=True)
group = fields.ReferenceField(Group, required=True, reverse_delete_rule=2)
user = fields.ReferenceField(User, required=True, reverse_delete_rule=2)
role = fields.StringField(required=True, choise=['admin', 'member'])
joined_at = fields.IntField()
added_by = fields.ReferenceField(User, required=True)
# db collection
meta = {"collection": "group_membership"}
class Announcement(BaseModel):
uid = fields.StringField(required=True, primary_key=True)
content = fields.StringField(required=True, min_length=1, max_length=10000)
group = fields.ReferenceField(Group, required=True, reverse_delete_rule=2)
created_at = fields.IntField(required=True)
created_by = fields.ReferenceField(User, required=True)
updated_at = fields.IntField()
# db collection
meta = {"collection": "announcements"}
class Group(BaseModel):
uid = fields.StringField(required=True, primary_key=True)
name = fields.StringField(required=True, min_length=3, max_length=50)
description = fields.StringField(required=True, max_length=100)
created_by = fields.ReferenceField(User, required=True)
created_at = fields.IntField(required=True)
updated_at = fields.IntField()
updated_by = fields.ReferenceField(User)
# db collection
meta = {"collection": "groups"}