class Rental(gj.Document):
rental_id = mongoengine.SequenceField(collection_name='Rental',
unique=True)
book = gj.FollowReferenceField(Book)
customer = gj.FollowReferenceField(Customer)
rental_start = mongoengine.DateTimeField()
rental_end = mongoengine.DateTimeField()
class Servicios(mge.Document):
codigo = mge.SequenceField(primary_key=True)
nombre = mge.StringField(max_length=255)
estado = mge.StringField(default="ACTIVO", choices=("ACTIVO", "NO ACTIVO"))
def __eq__(self, serv):
return self.codigo == serv.codigo
class User(mongoengine.Document):
user_id = mongoengine.SequenceField(collection_name='sequences',
unique=True)
user_name = mongoengine.StringField(required=True, unique=True)
first_name = mongoengine.StringField()
last_name = mongoengine.StringField()
meta = {'indexes': ['user_id', 'user_name'], 'ordering': ['+user_id']}
class ServiciosPlanMovil(mge.Document):
codigo = mge.SequenceField(primary_key=True)
id_plan = mge.StringField(required=True, max_length=255)
id_servicio = mge.IntField(required=True)
def __eq__(self, sp):
return self.id_plan == sp.id_plan and self.id_servicio == sp.id_ser
class Karma(mongoengine.Document):
id = mongoengine.SequenceField(primary_key=True)
chat_id = mongoengine.LongField(required=True)
message_id = mongoengine.LongField(required=True)
response_message_id = mongoengine.LongField(null=True)
message = mongoengine.StringField(required=True)
giver_user_id = mongoengine.LongField(required=True)
giver_username = mongoengine.StringField(required=True)
receiver_user_id = mongoengine.LongField(required=True)
receiver_username = mongoengine.StringField(required=True)
vote = mongoengine.IntField(required=True)
date_added = mongoengine.DateTimeField(default=localized_date)
date_modified = mongoengine.DateTimeField(default=localized_date)
date_deleted = mongoengine.DateTimeField(required=False, null=True)
@classmethod
def by_id(cls, id):
try:
return cls.objects.get(id=id)
except cls.DoesNotExist:
return None
@classmethod
def by_chat_id_and_receiver_user_id(cls, chat_id, receiver_user_id):
try:
return cls.objects.get(chat_id=chat_id,
receiver_user_id=receiver_user_id)
except cls.DoesNotExist:
return None
class TipoPlanMovil(mge.Document):
codigo = mge.SequenceField(primary_key=True)
tipo = mge.StringField()
estado = mge.StringField(default="ACTIVO", choices=("ACTIVO", "NO ACTIVO"))
def __eq__(self, tipo):
return self.codigo == tipo.codigo
class Comment(mongoengine.Document):
account = mongoengine.ReferenceField("User", required=True)
subject = mongoengine.GenericReferenceField(required=True)
created = mongoengine.DateTimeField(default=datetime.now)
updated = mongoengine.DateTimeField(default=datetime.now)
text = mongoengine.StringField(required=True)
counter = mongoengine.SequenceField()
meta = {
"alias": "default",
"collection": "comments",
"indexes": [
"subject",
"account",
]
}
def dict(self):
return {
"created": int(datetime.timestamp(self.created)),
"updated": int(datetime.timestamp(self.updated)),
"account": self.account.dict(),
"counter": self.counter,
"text": self.text
}
class GameTime(mongoengine.Document):
gametime_id = mongoengine.SequenceField(collection_name='sequences',
unique=True)
game_id = mongoengine.ReferenceField(Game)
user_id = mongoengine.ReferenceField(User)
start_date = mongoengine.DateTimeField()
end_date = mongoengine.DateTimeField()
meta = {'indexes': ['gametime_id'], 'ordering': ['+gametime_id']}
class Snapshot(me.Document):
id = me.SequenceField(primary_key=True)
created_at = me.DateTimeField(default=datetime.now(), required=True)
trained_at = me.DateTimeField()
types = me.MapField(me.EmbeddedDocumentField(Type), required=True)
semaphore = me.IntField(default=0)
meta = {'indexes': ['semaphore']}
@staticmethod
def from_string(version_string):
if 'CURRENT' in version_string:
return Snapshot.current()
return Snapshot.objects.get(id=int(version_string[1:]))
@staticmethod
def current():
return Snapshot.objects.get(id=CURRENT_ID)
def __str__(self):
return f'v{"CURRENT" if self.id == CURRENT_ID else self.id}'
@contextmanager
def training_lock(self, un_train: bool = False):
if Snapshot.objects(id=self.id,
semaphore=0).update_one(dec__semaphore=1) == 1:
try:
yield self
finally:
if Snapshot.objects(id=self.id, semaphore=-1).update_one(
inc__semaphore=1,
trained_at=None if un_train else datetime.now()) == 1:
self.reload()
else:
raise TrainingLockFreeError
else:
raise TrainingLockAcquireError
@contextmanager
def loading_lock(self):
if Snapshot.objects(
id=self.id,
semaphore__gte=0).update_one(inc__semaphore=1) == 1:
try:
yield self
finally:
if Snapshot.objects(
id=self.id,
semaphore__gt=0).update_one(dec__semaphore=1) == 1:
self.reload()
else:
raise LoadingLockFreeError
else:
raise LoadingLockAcquireError
class Cobranza(mongoengine.Document):
nroDocumento = mongoengine.SequenceField()
socio = mongoengine.ReferenceField("Socio")
alumno = mongoengine.ReferenceField("Alumno")
formaPago = mongoengine.StringField(required=True, max_length=25)
fechaCobranza = mongoengine.DateField(required=True)
mes = mongoengine.StringField(required=True, max_length=15)
monto = mongoengine.FloatField(required=True, max_length=11)
isAnulada = mongoengine.BooleanField(default=False)
fechaCobranzaAnulada = mongoengine.DateField(required=False)
descripcionCobranzaAnulada = mongoengine.StringField(required=False, max_length=100)
class TransactionLog(me.Document):
"""Capped Collection to Log transactions."""
timestamp = me.DateTimeField(
required=True,
default=datetime.utcnow()
)
collection = me.StringField(required=True)
doc_id = me.DynamicField()
ts = me.SequenceField()
meta = {"max_documents": 100000}
class Editor(mongoengine.Document):
"""
An Editor of a publication.
"""
meta = {'collection': 'test_editor'}
id = mongoengine.StringField(primary_key=True)
first_name = mongoengine.StringField(required=True, help_text="Editor's first name.", db_field='fname')
last_name = mongoengine.StringField(required=True, help_text="Editor's last name.")
metadata = mongoengine.MapField(field=mongoengine.StringField(), help_text="Arbitrary metadata.")
company = mongoengine.LazyReferenceField(Publisher)
avatar = mongoengine.FileField()
seq = mongoengine.SequenceField()
class MessageRequest(mongoengine.Document):
m_id = mongoengine.SequenceField(required=True)
urgency = mongoengine.StringField(required=True)
caller_name = mongoengine.StringField(required=True)
caller_number = mongoengine.StringField(required=True)
called_name = mongoengine.StringField(required=True)
called_num = mongoengine.StringField(required=True)
message = mongoengine.StringField(required=False)
meta = {"db_alias": "core", "collection": "messageRequests"}
class Game(mongoengine.Document):
game_id = mongoengine.SequenceField(collection_name='sequences',
unique=True)
game_title = mongoengine.StringField(required=True)
platform = mongoengine.StringField()
genre = mongoengine.StringField()
release_year = mongoengine.IntField(required=True)
developer = mongoengine.StringField()
publisher = mongoengine.StringField()
franchise = mongoengine.StringField()
series = mongoengine.StringField()
image_path = mongoengine.StringField()
game_note = mongoengine.StringField()
meta = {'indexes': ['game_id'], 'ordering': ['+game_id']}
class SimpleReply(mongoengine.Document):
id = mongoengine.SequenceField(primary_key=True)
pattern = mongoengine.StringField(unique=True)
pattern_type = mongoengine.StringField(choices=PATTERN_TYPES,
default='exact',
required=True)
response = mongoengine.StringField(required=True)
response_type = mongoengine.StringField(choices=RESPONSE_TYPES,
default="text",
required=True)
mime_type = mongoengine.StringField(required=False)
file_name = mongoengine.StringField(required=False)
caption = mongoengine.StringField(required=False)
parse_mode = mongoengine.StringField(required=False)
user_id = mongoengine.LongField(required=True)
username = mongoengine.StringField(required=True)
date_added = mongoengine.DateTimeField(default=localized_date)
date_modified = mongoengine.DateTimeField(default=localized_date)
date_deleted = mongoengine.DateTimeField(required=False, null=True)
@classmethod
def by_id(cls, id):
try:
return cls.objects.get(id=id)
except cls.DoesNotExist:
return None
@classmethod
def by_pattern(cls, pattern):
try:
return cls.objects.get(pattern=pattern)
except cls.DoesNotExist:
return None
@classmethod
def all(cls):
try:
return cls.objects(date_deleted=None)
except:
return None
def __str__(self):
return "{{ id = {id}, pattern = \"{pattern}\", pattern_type = {pattern_type}, response = \"{response}\", response_type = {response_type} }}".format(
id=self.id,
pattern=self.pattern,
pattern_type=self.pattern_type,
response=self.response,
response_type=self.response_type)
class Company(mongoengine.Document):
name = mongoengine.StringField(max_length=255, required=True)
lagel_person = mongoengine.StringField(max_length=255, null=True)
register_capital = mongoengine.StringField(null=True)
# register_time = db.DateTimeField(null=True)
register_time = mongoengine.StringField(null=True)
tel = mongoengine.StringField(null=True)
area = mongoengine.StringField(required=True, default="中国")
update_time = mongoengine.DateTimeField(default=datetime.now)
company_id = mongoengine.SequenceField(required=True)
reg_time = mongoengine.StringField(default="0")
reg_capital = mongoengine.StringField(default="0")
# 定义为索引
meta = {
'indexes': ["name", "lagel_person", "area"]
}
class Meeting(mongoengine.Document):
"""
Records details about a meeting - when it starts/stops, which talks were
debated, and the complete meeting transcript.
"""
number = mongoengine.SequenceField()
start = mongoengine.DateTimeField()
end = mongoengine.DateTimeField()
talks_decided = mongoengine.ListField(
mongoengine.ReferenceField(TalkProposal))
transcript = mongoengine.ListField(
mongoengine.EmbeddedDocumentField(TranscriptMessage))
def add_to_transcript(self, timestamp, user, message):
t = TranscriptMessage(timestamp=timestamp, user=user, message=message)
Meeting.objects(id=self.id).update_one(push__transcript=t)
class manufacturer(mongoengine.Document):
iterID = mongoengine.SequenceField(primary_key=True)
name = mongoengine.StringField()
contactInfo = mongoengine.DictField(required=False)
@property
def prefix(self):
return str(self._id).zfill(3)
def nextSKU(self):
objects = product.objects(manufacturer=self).order_by("$natural")
if objects.count() == 0:
return f"{self.prefix}00001"
else:
lastSKU = objects.first.sku
lastID = int(lastSKU[3:])
nextID = str(lastID + 1)
return f"{self.prefix}{nextID.zfill(5)}"
class Books(mongoengine.DynamicDocument):
book_name = mongoengine.StringField()
book_id = mongoengine.SequenceField()
author = mongoengine.StringField()
available = mongoengine.BooleanField()
added_in_library = mongoengine.DateTimeField()
modified = mongoengine.DateTimeField()
publisher = mongoengine.StringField()
publishing_year = mongoengine.IntField()
fine_amount = mongoengine.IntField(default=0)
status = mongoengine.EmbeddedDocumentField(StatusLog, default=StatusLog())
# status_history = mongoengine.ListField(mongoengine.EmbeddedDocumentField(BookStatus))
def save(self, *args, **kwargs):
if not self.added_in_library:
self.added_in_library = timezone.now()
self.modified = timezone.now()
super(Books, self).save(*args, **kwargs)
class Topic(mongoengine.Document):
id = mongoengine.SequenceField(primary_key=True)
chat_id = mongoengine.LongField(required=True, unique=True)
text = mongoengine.StringField(required=True)
subtopics = mongoengine.ListField(
mongoengine.ReferenceField(Subtopic,
reverse_delete_rule=mongoengine.PULL))
separator = mongoengine.StringField(default=' | ')
user_id = mongoengine.LongField(required=True)
username = mongoengine.StringField()
date_added = mongoengine.DateTimeField(default=localized_date)
date_modified = mongoengine.DateTimeField(default=localized_date)
date_deleted = mongoengine.DateTimeField(required=False, null=True)
@classmethod
def by_id(cls, id):
try:
return cls.objects.get(id=id)
except cls.DoesNotExist:
return None
@classmethod
def by_chat_id(cls, chat_id):
try:
return cls.objects.get(chat_id=chat_id)
except cls.DoesNotExist:
return None
def __repr__(self):
return self.text if len(self.subtopics) == 0 else '{}{}{}'.format(
self.text, self.separator,
self.separator.join(subtopic.text for subtopic in self.subtopics))
def __str__(self):
return self.__repr__()
class ProbeAlias(mongoengine.Document):
id = mongoengine.SequenceField(primary_key=True)
alias = mongoengine.StringField(unique=True)
probe_id = mongoengine.LongField(required=True)
user_id = mongoengine.LongField(required=True)
username = mongoengine.StringField(required=True)
date_added = mongoengine.DateTimeField(default=localized_date)
date_modified = mongoengine.DateTimeField(default=localized_date)
date_deleted = mongoengine.DateTimeField(required=False, null=True)
@classmethod
def by_id(cls, id):
try:
return cls.objects.get(id=id)
except cls.DoesNotExist:
return None
@classmethod
def by_probe_id(cls, probe_id):
try:
return cls.objects.get(probe_id=probe_id)
except cls.DoesNotExist:
return None
@classmethod
def by_alias(cls, alias):
try:
return cls.objects.get(alias__iexact=alias)
except cls.DoesNotExist:
return None
@classmethod
def all(cls):
try:
return cls.objects(date_deleted=None)
except:
return None
def __str__(self):
return "{{ id = {id}, alias = \"{alias}\", probe_id = \"{probe_id}\" }}".format(id=self.id, probe_id=self.probe_id, alias=self.alias)
class ToDo(mongoengine.Document):
"""Data of the todo containing multiple tasks."""
def __unicode__(self):
return self.slug
hid = mongoengine.SequenceField() # helper_id
title = mongoengine.StringField()
slug = mongoengine.StringField()
tasks = mongoengine.EmbeddedDocumentListField(Task)
def populate_embedded(self, elements):
for data in elements:
hid = data.get('hid')
try:
task = self.tasks.get(hid=hid)
except mongoengine.errors.DoesNotExist:
task = self.tasks.create(**data)
else:
for k, v in data.items():
setattr(task, k, v)
task.save()
class User(me.Document):
test_key = me.SequenceField(primary_key=True, value_decorator=str)
is_anonymous = me.BooleanField(db_field='anon', default=False)
nickname = me.StringField(required=True)
test_login = me.StringField(required=False)
class Task(mongoengine.EmbeddedDocument):
"""An element of the ToDo."""
hid = mongoengine.SequenceField()
content = mongoengine.StringField()
is_done = mongoengine.BooleanField(default=False)
class ParameterInfo(mongoengine.Document):
para_id = mongoengine.SequenceField(primary_key=True)
para_name = mongoengine.StringField()
para_desc = mongoengine.StringField()
class Doc(me.Document):
_id = me.SequenceField(primary_key=True)
file_path = me.StringField()
course = me.StringField()
num_terms = me.IntField()
downloaded_at = me.DateTimeField()
class Territory(me.Document):
""" Implements a territory. """
id = me.SequenceField(primary_key=True)
name = me.StringField(required=True)
start = me.DictField(required=True)
end = me.DictField(required=True)
area = me.FloatField(default=0.)
painted_area = me.IntField(default=0)
squares = me.ListField(me.ReferenceField(sq.Square))
def clean(self):
"""
Invalidates insert of overlapping territory.
Calculates derived attributes.
"""
if self.overlapping_territories():
raise me.ValidationError('Overlapping territory')
self.area = self.calculate_area()
self.painted_area = self.calculate_painted_area()
if len(self.squares) == 0:
self.squares = sq.Square.generate_squares(self.start, self.end)
def overlapping_territories(self):
"""
Determines if there is another registered territory overlapping this
location.
Two territories do NOT overlap if one is totally to the left/right/
up/down of the other.
"""
self_left = min(self.start['x'], self.end['x'])
self_right = max(self.start['x'], self.end['x'])
self_down = min(self.start['y'], self.end['y'])
self_up = max(self.start['y'], self.end['y'])
for t in Territory.objects:
t_left = min(t.start['x'], t.end['x'])
t_right = max(t.start['x'], t.end['x'])
t_down = min(t.start['y'], t.end['y'])
t_up = max(t.start['y'], t.end['y'])
overlap = not ((self_left > t_right) or (self_right < t_left) or
(self_up < t_down) or (self_down > t_up))
if overlap:
return True
return False
def calculate_area(self):
""" Find total area. """
delta_x = abs(self.start['x'] - self.end['x']) # + 1
delta_y = abs(self.start['y'] - self.end['y']) # + 1
return delta_x * delta_y
def calculate_painted_area(self):
""" Find total painted area. """
return len(self.painted_squares())
def painted_squares(self):
return [s for s in self.squares if s.painted is True]
def serialize(self, include_squares=False):
_dict = {
'id': str(self.id),
'name': self.name,
'start': self.start,
'end': self.end,
'area': self.area,
'painted_area': self.calculate_painted_area()
}
if include_squares:
_dict['painted_squares'] = [{
'x': s.x,
'y': s.y
} for s in self.painted_squares()]
return _dict
@classmethod
def post_delete(cls, sender, document, **kwargs):
for s in document.squares:
s.delete()
class NierGames(medb.Document):
weapon_id = medb.SequenceField(primary_key=True)
urlIma = medb.StringField()
game = medb.StringField() # Replicant or Automata in this field
status = medb.EmbeddedDocumentField(WeaponStatus)
class DeviceInfo(mongoengine.Document):
dev_id = mongoengine.SequenceField()
dev_name = mongoengine.StringField(required=True)
dev_desc = mongoengine.StringField()
dev_paras = mongoengine.ListField()
class Users(medb.Document):
user_id = medb.SequenceField(primary_key=True)
userName = medb.StringField(max_length=10, required=True)
email = medb.EmailField(required=True)
paswd = medb.StringField(max_length=30, required=True)
kind = medb.StringField(max_length=1) # A or N in this field
