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 User(UsersMixin):
def _validate_industries(field, value):
for industry in value:
yield from industry.industry.fetch(no_data=True)
def _validate_invited_by(field, value):
from models.utils import is_valid_invited_by
if not (yield from is_valid_invited_by(value)):
raise ValidationError('There is no such user or group code.')
fullname = fields.StrField(required=True)
email = fields.EmailField(unique=True, required=True)
nickname = fields.StrField(unique=True,
required=True,
validate=validate.Regexp(r'[\w\d]+'))
birthday = fields.DateTimeField(required=True, format=DATE_FORMAT)
phone_numbers = fields.ListField(
fields.StrField(validate=validate.Regexp(r'[+][\w\d]+')),
required=True)
photo = fields.StrField(required=True)
bio = fields.StrField(required=False, validate=validate.Length(max=320))
organizations = fields.StrField(required=False,
validate=validate.Length(max=320))
education = fields.StrField(required=False,
validate=validate.Length(max=320))
personal_invite_code = fields.StrField(
unique=True,
required=True,
validate=validate.Length(equal=INVITE_CODE_LENGTH))
social_links = fields.ListField(fields.EmbeddedField(SocialLink))
current_location = fields.EmbeddedField(Location)
preferred_ways_to_meet = fields.ListField(
fields.StrField(validate=validate.OneOf(PREFERRED_WAYS_TO_MEET)),
unique=True)
join_date = fields.DateTimeField(missing=datetime.utcnow())
is_active = fields.BoolField(missing=False)
is_deleted = fields.BoolField()
date_deleted = fields.DateTimeField()
is_notifications_enabled = fields.BoolField(missing=True)
skills = fields.ListField(fields.ReferenceField(Tag), required=True)
interests = fields.ListField(fields.ReferenceField(Tag))
industries = fields.ListField(fields.EmbeddedField(Industry),
required=True,
io_validate=_validate_industries)
languages = fields.ListField(fields.EmbeddedField(Language))
looking_for = fields.ListField(fields.ReferenceField(LookingFor))
bubbles = fields.ListField(fields.EmbeddedField(Bubble))
invited_type = fields.StrField(required=True,
validate=validate.OneOf(INVITE_TYPE))
invited_by = fields.StrField(required=True,
io_validate=_validate_invited_by)
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 FormField(EmbeddedDocument): # pylint: disable=abstract-method
"""
A field in a form to fill out.
Taken from fenetre/db.py.
"""
# This should be a substring of the nearest label text to the control we're filling in.
# Optional _not automatically set_
expected_label_segment = fields.StrField(required=False, default=None)
# Index on page (includes headings)
index_on_page = fields.IntField(required=True,
validate=validate.Range(min=0))
# Value to fill in.
# The grammar for this field is in fieldexpr.py in lockbox.
target_value = fields.StrField(required=True)
# Type of field
kind = fields.StrField(required=True,
validate=validate.OneOf(
[x.value for x in FormFieldType]))
# Is this field critical? as in; if we don't fill it in do we still submit the form?
critical = fields.BoolField(default=True)
class LookingFor(Document):
title = fields.StrField(required=True)
description = fields.StrField()
skills = fields.ListField(fields.ReferenceField('Tag'))
recommendations = fields.ListField(fields.ReferenceField('Recommendation'))
date = fields.DateTimeField()
only_for_my_contacts = fields.BoolField()
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 CachedFormGeometry(Document): # pylint: disable=abstract-method
"""
A document used for caching results to requests for form geometry.
"""
url = fields.URLField(required=True, unique=True)
# Token of the user that requested this form geometry
# used to limit requests per user
requested_by = fields.StrField(required=False, allow_none=True)
geometry = fields.ListField(fields.EmbeddedField(FormGeometryEntry),
required=False,
allow_none=True)
auth_required = fields.BoolField(required=False, allow_none=True)
screenshot_file_id = fields.ObjectIdField(required=False, allow_none=True)
grab_screenshot = fields.BoolField(default=False)
response_status = fields.IntField(required=False)
error = fields.StrField(required=False)
class Trip(Document):
user = fields.ReferenceField('User', required=True)
from_location = fields.EmbeddedField(Location, required=True)
to_location = fields.EmbeddedField(Location, required=True)
start_date = fields.DateTimeField(required=True)
end_date = fields.DateTimeField(required=True)
purpose = fields.StrField()
tags_to_discuss = fields.ListField(fields.ReferenceField('Tag'))
notify_users = fields.BoolField(missing=True)
class Posts(Document):
# title, body, author, published, meta{ upvotes, favs },
title = fields.StrField(required=True)
body = fields.StrField()
author = fields.StrField()
published = fields.BoolField(False)
meta = fields.DictField()
class Meta:
exclude = [
'date',
]
class User(Document):
username = fields.StrField(
required=True,
unique=True,
validate=[validate.Length(min=6, max=64),
validate.Regexp(r'^\w+$')],
error_messages={"unique": "Username already taken"})
passhash = BinaryField(required=True)
passsalt = BinaryField(required=True)
admin = fields.BoolField(default=False)
signed_eula = fields.BoolField(default=False)
# support for oauth via discord
discord_id = fields.StrField(default=None)
# potential other oauth?
# might do github here.
# we still force a password to exist on the account though.
lockbox_token = fields.StrField(
default=None) # not always present if not setup
class FormFillingTest(Document): # pylint: disable=abstract-method
"""
Represents finished/inprogress tests of form filling
"""
# config to test
course_config = fields.ObjectIdField(required=True)
# with information from this user
requested_by = fields.ObjectIdField(
required=False) # holds which user (fenetre) can see this
time_executed = fields.DateTimeField(required=False, allow_none=True)
# status
is_finished = fields.BoolField(default=False)
in_progress = fields.BoolField(default=False)
is_scheduled = fields.BoolField(default=False)
# results
errors = fields.ListField(fields.EmbeddedField(LockboxFailure), default=[])
fill_result = fields.EmbeddedField(FillFormResult,
default=None,
allow_none=True)
class User(Document):
class Meta:
collection_name = 'users'
indexes = []
user_id = fields.IntField(required=True, unique=True)
created = fields.DateTimeField(required=True)
visited = fields.DateTimeField(required=True)
username = fields.StrField(required=True, allow_none=True)
first_name = fields.StrField(required=True)
last_name = fields.StrField(required=True, allow_none=True)
language_code = fields.StrField(required=True, allow_none=True)
language = fields.StrField(required=True)
is_active = fields.BoolField(required=True, default=True)
class Form(Document):
sub_fields = fields.ListField(fields.EmbeddedField(FormField),
default=list,
validate=_validate_form_fields)
# id of file in gridfs, should be a png
representative_thumbnail = fields.ObjectIdField(default=None)
# Friendly title for this form configuration
name = fields.StrField()
# is this form the default? if there are multiple of these, uh panic
# TODO: use io_validate to check that
is_default = fields.BoolField(default=False)
class Task(Document): # pylint: disable=abstract-method
"""
A task that runs repeatedly, such as the daily form filling.
Used by the scheduler.
"""
kind = fields.StrField(required=True,
validate=validate.OneOf([x.value
for x in TaskType]))
owner = fields.ReferenceField(User, default=None)
next_run_at = fields.DateTimeField(required=True)
is_running = fields.BoolField(default=False)
retry_count = fields.IntField(default=0)
argument = fields.StrField(default="")
class Form(Document): # pylint: disable=abstract-method
"""
Configuration for a form type to fill out.
Taken from fenetre/db.py.
"""
sub_fields = fields.ListField(fields.EmbeddedField(FormField))
# id of file in gridfs, should be a png
representative_thumbnail = fields.ObjectIdField(default=None)
# Friendly title for this form configuration
name = fields.StrField()
# is this form the default?
is_default = fields.BoolField(default=False)
class User(Document): # pylint: disable=abstract-method
"""
A user in the private database.
"""
token = fields.StrField(required=True,
unique=True,
validate=validate.Length(equal=64))
# The following 4 values could be unconfigured
# Since the server only updates these after it validates credentials,
# if both login and password exist, they're guaranteed to be valid credentials
login = fields.StrField(required=False,
unique=True,
validate=validate.Regexp(r"\d+"))
password = BinaryField(required=False)
# Populated when credentials are set/updated
# A value of null indicates either credentials are unset,
# or the courses are in the process of being populated
# An empty array indicates no courses found
courses = fields.ListField(fields.ObjectIdField(),
required=False,
allow_none=True)
# Should be set as soon as valid credentials are detected
email = fields.EmailField(required=False, allow_none=True)
active = fields.BoolField(default=True)
errors = fields.ListField(fields.EmbeddedField(LockboxFailure), default=[])
last_fill_form_result = fields.EmbeddedField(FillFormResult,
default=None,
allow_none=True)
grade = fields.IntField(required=False, allow_none=True, default=None)
first_name = fields.StrField(required=False,
allow_none=True,
default=None,
validate=lambda s: s is None or len(s))
last_name = fields.StrField(required=False,
allow_none=True,
default=None,
validate=lambda s: s is None or len(s))
class ChatMember(Document):
user = fields.ReferenceField('User', required=True)
chat = fields.ReferenceField('Chat', required=True)
is_notifications_enabled = fields.BoolField()
is_active = fields.BoolField()
last_visited = fields.DateTimeField()
class SystemUser(UsersMixin):
email = fields.StrField(unique=True, required=True)
active = fields.BoolField()
class Game(BaseDocument):
"""
This is how we are going to store the game
"""
STATUS_CREATED = 'created'
STATUS_IN_PROGRESS = 'in_progress'
STATUS_TIE = 'tie'
STATUS_FINISHED = 'finished'
STATUS = [
STATUS_CREATED,
STATUS_IN_PROGRESS,
STATUS_TIE,
STATUS_FINISHED,
]
players = fields.ListField(
fields.ReferenceField("User"),
)
multiplayer = fields.BoolField(
default=False,
)
board = fields.ListField(
fields.ListField(
fields.StrField()
)
)
status = fields.StrField(
validate=validate.OneOf(STATUS),
default=STATUS_CREATED
)
created_at = fields.DateTimeField(
default=datetime.datetime.now(),
)
winner = fields.ReferenceField("User")
size = fields.IntegerField(
validate=[validate.Range(3, 10)],
default=3,
)
def pre_insert(self):
"""
Fill the board and do multiplayer validations
"""
if not self.players:
raise ValidationError(
"There should be at least one player",
)
if len(self.players) > 2:
raise ValidationError(
"Maximum two players"
)
if len(self.players) == 2:
self.multiplayer = True
else:
self.multiplayer = False
self.board = [["" for i in range(self.size)] for y in range(self.size)]
pass
class Meta:
"""
ODM Metadata
"""
collection = db.games