class Book(Document):
title = fields.StrField()
length = fields.IntField(attribute='l')
author = fields.EmbeddedField(Author, attribute='a')
chapters = fields.ListField(fields.EmbeddedField(Chapter))
tags = fields.ListField(fields.StrField(), attribute='t')
editor = fields.ReferenceField(Editor, attribute='e')
class Course(Document): # pylint: disable=abstract-method
"""
A course.
Course instances are shared between students.
Taken from fenetre/db.py.
"""
# Course code including cohort str
course_code = fields.StrField(required=True, unique=True)
# Is this course's form setup locked by an admin?
configuration_locked = fields.BoolField(default=False)
# FORM config:
# does this course use an attendance form (to deal with people who have COOP courses or something)
has_attendance_form = fields.BoolField(default=True)
# form URL
form_url = fields.URLField(default=None)
# form configuration
form_config = fields.ReferenceField(Form, default=None)
# Slots we know this course occurs on (f"{day}-{period}" so for example "2-1a" is day 2 in the morning asynchronous
known_slots = fields.ListField(fields.StrField(), default=[])
# Teacher name
teacher_name = fields.StrField(default="")
class Comment(EmbeddedDocument):
id = fields.ObjectIdField(default=ObjectId())
content = fields.StrField()
created_by = fields.ReferenceField("User")
created_at = fields.DateTimeField(default=datetime.now())
updated_at = fields.DateTimeField(default=datetime.now())
class Payment(Document):
id_order = fields.ReferenceField(Order)
status = fields.BooleanField()
del_dtime = fields.DateTimeField()
class Meta:
collection = db.employee
class UserModel(Document):
buylist = fields.ReferenceField(ListModel, default=None)
chat_id = fields.IntField(required=True, unique=True)
username = fields.StrField()
#lastnotice = fields.DateTimeField(default=get_now())
checknotice = fields.BoolField(default=True)
chosenbuilding = fields.IntField(default=0)
noticehour = fields.IntField(default=8)
notification = fields.DictField(default={
BEFORE_CLEANING: None,
ON_CLEANING: 8
})
lastnotice = fields.DictField(default={
BEFORE_CLEANING: get_now(),
ON_CLEANING: get_now()
})
class Meta:
collection_name = 'user'
def update(self, **attrs) -> Union[UpdateResult, InsertOneResult]:
for attr in attrs:
self[attr] = attrs[attr]
return self.commit()
def get_buy_list(self) -> ListModel:
try:
return self.buylist.fetch()
except ValidationError:
_list = create_list(self.chat_id)
self.update(buylist=_list)
return _list
class Meeting(Document):
owner = fields.ReferenceField('User', required=True)
members = fields.ListField(fields.ReferenceField('MeetingMember'))
meeting_type = fields.StrField(validate=validate.OneOf(MEETING_TYPES),
required=True)
state = fields.StrField(validate=validate.OneOf(MEETING_STATES))
description = fields.StrField()
place_address = fields.StrField()
latitude = fields.FloatField()
longitude = fields.FloatField()
google_place_id = fields.IntField()
google_place_city_id = fields.IntField()
date_created = fields.DateTimeField(missing=datetime.now())
date_resolved = fields.DateTimeField(required=True)
class Course(Document):
name = fields.StrField(required=True)
teacher = fields.ReferenceField(Teacher, required=True)
class Meta:
register_document = False
collection = db.course
class User(umongo.Document): # noqa
"""
Main user document in database
"""
uid = fields.IntegerField(required=True, unique=True)
created_time = fields.IntegerField(default=time.time)
accounts = fields.ListField(fields.ReferenceField("UserInChat"),
default=[]) # accounts it is a list of
# chats (references to chats) where user exists.
class Meta:
collection = instance.db.users
@staticmethod
async def create_user(uid: int) -> typing.Union["User", typing.NoReturn]:
"""
Create user in database or raise exception. - umongo.exceptions.UMongoError
:param uid:
:return:
"""
user: User = User(uid=uid)
await user.commit()
return user
@staticmethod
async def get_user(uid: int) -> typing.Union["User", typing.NoReturn]:
"""
Lookup user in database via UID.
:param uid:
:return:
"""
user = await User.find_one({"uid": uid})
return user
@staticmethod
async def get_account(document_id: str):
"""
Lookup user in user chats via document `_id`
:param document_id:
:return:
"""
user = await User.find_one({"accounts": document_id})
return user
@staticmethod
async def add_account(usr: "******", document_id: str):
"""
Add user account to accounts list.
:param usr: user object
:param document_id: document '_id' of new account
:return:
"""
current: dict = usr.dump()
accounts: list = current["accounts"]
accounts.append(document_id)
usr.update({"accounts": accounts})
return await usr.commit()
class IOStudent(Student):
io_field = fields.StrField(io_validate=io_validate)
list_io_field = fields.ListField(
fields.IntField(io_validate=io_validate))
reference_io_field = fields.ReferenceField(
classroom_model.Course, io_validate=io_validate)
embedded_io_field = fields.EmbeddedField(
EmbeddedDoc, io_validate=io_validate)
class ResetLink(Document):
user = fields.ReferenceField('User', required=True)
code = fields.StrField(required=True)
type = fields.StrField(required=True,
validate=validate.OneOf(RESET_LINK_TYPE))
is_used = fields.BoolField(missing=False)
date_created = fields.DateTimeField(missing=datetime.now())
date_valid = fields.DateTimeField(allow_none=True)
class User(Document):
email = fields.EmailField(required=True, unique=True)
birthday = fields.DateTimeField(
validate=validate.Range(min=datetime(1900, 1, 1)))
friends = fields.ListField(fields.ReferenceField("User"))
class Meta:
collection = db.user
class Image(Document):
type = fields.StrField(required=True,
validate=validate.OneOf(
["character_image", "actor_image"]))
character = fields.ReferenceField("Character")
class Meta:
collection = db.image
class Tag(Document):
name = fields.StrField()
text = fields.StrField()
guild = fields.ReferenceField(document=Guild)
user_id = fields.IntegerField()
class Meta:
collection_name = 'tag'
class Category(Document):
# id_cat = fields.IntegerField()
id_cafe = fields.ReferenceField(Cafe)
name_cat = fields.StringField(required=True, unique=True)
image_url_cat = fields.UrlField()
class Meta:
collection = db.category
class Product(Document):
category = fields.ReferenceField(Category)
name = fields.StringField(required=True, unique=True)
description = fields.StringField(required=True, unique=True)
price = fields.NumberField(required=True)
image_url = fields.UrlField()
available_from = fields.DateTimeField()
available_till = fields.DateTimeField()
class Reaction(Document):
string = fields.StrField(attribute='_id', unique=True)
reaction = fields.StrField()
is_emb = fields.BooleanField()
guild = fields.ReferenceField(document=Guild)
class Meta:
collection_name = 'reaction'
class TaskType(Document):
number = fields.StringField(required=True, unique=True)
points = fields.IntegerField(required=True, default=1)
cods = fields.ListField(fields.StringField)
description = fields.StringField()
count_of_tasks = fields.IntegerField(default=0)
subject = fields.ReferenceField(Subject)
class Order(Document):
id_order = fields.IntegerField(required=True, unique=True)
products = fields.ListField(fields.ReferenceField(Product))
user_id = fields.IntegerField(required=True, unique=True)
order_dtime = fields.DateTimeField()
del_dtime = fields.DateTimeField()
class Meta:
collection = db.order
class Student(Document):
name = fields.StrField(required=True)
birthday = fields.DateTimeField()
courses = fields.ListField(fields.ReferenceField(Course))
class Meta:
register_document = False
collection = db.student
allow_inheritance = True
class Topic(Document):
"""
:ivar str name:
:ivar typing.List[Rule] rules:
"""
name = fields.StringField(required=True)
rules = fields.ListField(fields.ReferenceField(Rule, dbRef=True),
required=True)
class OrderDocument(Document):
products = fields.ListField(fields.ReferenceField(ProductDocument),
required=True)
cafe = fields.ObjectIdField(required=True)
user_id = fields.StringField(required=True, unique=True)
order_time = fields.DateTimeField(required=True)
code = fields.IntegerField(required=True)
price = fields.FloatField(required=True)
deletion_time = fields.DateTimeField(allow_none=True)
class Message(Document):
message = fields.StringField(required=True)
time = fields.DateTimeField(missing=datetime.now())
user_id = fields.ReferenceField(User, required=True)
@property
def user(self):
user = self.user_id._document
return user
class AddTagRequest(Document):
user = fields.ReferenceField('User', required=True)
tag_name = fields.StrField(required=True)
type = fields.StrField(validate=validate.OneOf(TAG_TYPES))
state = fields.StrField(validate=validate.OneOf(ADD_TAG_REQUEST_STATE))
date = fields.DateTimeField(missing=datetime.now())
@property
def repeats_count(self):
return 0
class RoutePoint(Document, metaclass=MetaBaseTemplate):
route = fields.ReferenceField(Route, required=True)
point = fields.DictField(required=True)
photos = fields.ListField(fields.ObjectIdField, missing=list)
text = fields.StringField()
tags = fields.ListField(fields.StringField, missing=list)
liked = fields.IntegerField(missing=0)
class Meta:
collection_name = "route_points"
class Cafe(Document):
# id_cafe = fields.IntegerField()
name_cafe = fields.StringField(required=True, unique=True)
address = fields.StringField(required=True, unique=True)
info = fields.StringField()
image_url_cafe = fields.UrlField()
payment_type = fields.ReferenceField(PaymentTypes)
class Meta:
collection = db.cafe
class AutoRole(Document):
_id = fields.IntegerField(unique=True)
delay = fields.IntegerField()
active_auto_role = fields.ListField(fields.DictField(
user_id=fields.IntegerField(),
date_of_accession=fields.DateTimeField())
)
guild = fields.ReferenceField(document=Guild)
class Meta:
collection_name = 'autorole'
class Remind(Document):
_id = fields.IntegerField()
r_num = fields.IntegerField()
user_id = fields.IntegerField()
text = fields.StrField()
guild = fields.ReferenceField(document=Guild)
channel_id = fields.IntegerField()
remind_time = fields.DateTimeField()
class Meta:
collection_name = 'remind'
class Product(Document):
# id_prod = fields.IntegerField()
id_cat = fields.ReferenceField(Category)
name_prod = fields.StringField(required=True, unique=True)
description = fields.StringField(required=True, unique=True)
price = fields.NumberField(required=True)
image_url_prod = fields.UrlField()
avail_from = fields.DateTimeField()
avail_till = fields.DateTimeField()
class Meta:
collection = db.product
class Project(Document):
projectId = fields.StrField(required=True)
name = fields.StrField(required=True)
ownerName = fields.StrField(required=True)
ownerORCID = fields.StrField(required=True)
description = fields.StrField()
createdDate = fields.DateTimeField(default=datetime.now)
updatedDate = fields.DateTimeField(default=datetime.now)
samples = fields.ListField(fields.ReferenceField("Sample"))
isLocked = fields.BooleanField(default="false")
class Meta:
collection_name = "project"
class Context(Document):
"""
:ivar User ofUser:
:ivar datetime timestamp:
:ivar typing.List[Params] params:
:ivar Message message:
"""
ofUser = fields.ReferenceField(User, dbRef=True, required=True)
timestamp = fields.StrictDateTimeField(tz_aware=True,
format="iso",
required=True)
params = fields.ListField(fields.EmbeddedField(Params))
message = fields.EmbeddedField(Message)
