class Anime(Document):
name = fields.DictField(required=True)
format = fields.StrField(validate=validate.OneOf(
["ONA", "OVA", "TV", "Movie", "Special", "Music", "TV Short"]))
tags = fields.ListField(fields.StrField()) #array
genres = fields.ListField(fields.StrField()) #array
synopsis = fields.StrField()
season = fields.StrField()
duration = fields.IntField()
release_date = fields.StrField()
studios = fields.ListField(fields.StrField()) #array
episodes = fields.IntField()
source = fields.StrField(validate=validate.OneOf([
"Original", "Manga", "Light Novel", "Visual Novel", "Novel",
"Video Game", "Doujinshi"
]))
#TODO: controller logic will have to implement String ID to ObjectID from bson.objectid.ObjectId for queries
id = fields.StrField()
#TODO: client facing JSON response in API controller will have to output characters with proper structure/dictionary
#TODO: client facing JSON request in API controller will have to parse through characters and make separate queries for them.
#TODO: frontend will use the same API
#TODO: same goes with staff, as in their pictures, names, roles
rating = fields.FloatField()
cover = fields.ReferenceField("Image")
class Meta:
collection = db.anime
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 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 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 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 Tag(Document):
name = fields.StrField(required=True)
type = fields.StrField(validate=validate.OneOf(TAG_TYPES), required=True)
parent = fields.StrField(allow_none=True)
class Meta:
indexes = [
IndexModel([('name', ASCENDING), ('type', ASCENDING)],
unique=True), '$name'
]
@classmethod
async def validate_tags(cls, tag_names):
tags = []
for tag_name in tag_names:
tag = await cls.validate_tag(tag_name)
tags.append(tag)
return tags
@classmethod
async def validate_tag(cls, tag_name):
tag = await cls.find_one({'name': tag_name})
if tag is not None:
return tag
else:
raise ValidationError(
'No tag with this name({}).'.format(tag_name))
class Chat(Document):
owner = fields.ReferenceField('User', required=True)
members = fields.ListField(fields.ReferenceField('ChatMember'))
name = fields.StrField()
description = fields.StrField()
type = fields.StrField(validate=validate.OneOf(CHAT_TYPE), required=True)
last_message = fields.ReferenceField('ChatMessage', allow_none=True)
created = fields.DateTimeField()
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 GetInviteCodeRequest(Document):
email = fields.EmailField(unique=True, required=True)
code = fields.StrField(unique=True,
required=False,
validate=validate.Length(equal=INVITE_CODE_LENGTH))
state = fields.StrField(required=True,
validate=validate.OneOf(GET_INVITE_CODE_STATE))
created = fields.DateTimeField(missing=datetime.now())
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 FormGeometryEntry(EmbeddedDocument): # pylint: disable=abstract-method
"""
An entry in a form geometry description list.
"""
index = fields.IntField(required=True)
title = fields.StrField(required=True)
kind = fields.StrField(required=True,
validate=validate.OneOf(
[x.value for x in FormFieldType]))
class TagSynonym(Document):
name = fields.StrField(required=True)
type = fields.StrField(validate=validate.OneOf(TAG_TYPES), required=True)
parent = fields.StrField(allow_none=True)
parent_synonym = fields.StrField(required=True)
class Meta:
indexes = [
IndexModel([('name', ASCENDING), ('type', ASCENDING),
('parent_synonym', ASCENDING)],
unique=True), '$name'
]
class LockboxFailure(EmbeddedDocument): # pylint: disable=abstract-method
"""
A document used to report lockbox failures to fenetre.
Taken from fenetre/db.py.
"""
_id = fields.ObjectIdField(required=True)
time_logged = fields.DateTimeField(required=True)
kind = fields.StrField(required=True,
validate=validate.OneOf(
[x.value for x in LockboxFailureType]))
message = fields.StrField(required=False, default="")
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 FillFormResult(EmbeddedDocument): # pylint: disable=abstract-method
"""
A document that stores the result of a form-filling task.
"""
result = fields.StrField(required=True,
validate=validate.OneOf(
[x.value for x in FillFormResultType]))
time_logged = fields.DateTimeField(required=True)
course = fields.ObjectIdField(required=False,
default=None,
allow_none=True)
form_screenshot_id = fields.ObjectIdField(required=False, allow_none=True)
confirmation_screenshot_id = fields.ObjectIdField(required=False,
allow_none=True)
class UserRelationship(Document):
from_user = fields.ReferenceField('User', required=True)
to_user = fields.ReferenceField('User', required=True)
status = fields.StrField(validate=validate.OneOf(USER_RELATIONSHIP_STATUS))
date = fields.DateTimeField()
@classmethod
async def get_users_relationship(cls, user1_id, user2_id):
relationship = await cls.find_one({
'$or': [
{
'from_user': user1_id,
'to_user': user2_id
},
{
'from_user': user2_id,
'to_user': user1_id
},
]
})
return relationship
@classmethod
async def create_or_update_relationship(cls, from_user_id, to_user_id,
status):
relationship = await cls.get_users_relationship(
from_user_id, to_user_id)
if relationship:
relationship.from_user = from_user_id
relationship.to_user = to_user_id
relationship.status = status
else:
relationship = cls(
from_user=from_user_id,
to_user=to_user_id,
status=status,
data=datetime.utcnow(),
)
await relationship.commit()
class GameMove(BaseDocument):
"""
This collection will track the moves of the users
on the given game
"""
SYMBOLS = [
'X',
'O'
]
game = fields.ReferenceField(
"Game",
)
cell = fields.DictField(
required=True
)
symbol = fields.StrField(
validate=validate.OneOf(SYMBOLS),
required=True,
)
player = fields.ReferenceField(
"User",
required=True,
)
created_at = fields.DateTimeField(
default=datetime.datetime.now(),
)
class Meta:
"""
ODM Metadata
"""
collection = db.moves
class Car(Vehicle):
doors = fields.IntField(validate=validate.OneOf([3, 5]))
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
class Language(EmbeddedDocument):
name = fields.StrField(required=True)
level = fields.StrField(validate=validate.OneOf(LANGUAGE_LEVELS),
required=True)
class ChatMessage(Document):
sender = fields.ReferenceField('ChatMember', required=True)
type = fields.StrField(validate=validate.OneOf(CHAT_MESSAGE_TYPE))
body = fields.StrField()
date_sended = fields.DateTimeField()
class MotorBike(Vehicle):
engine_type = fields.StrField(
validate=validate.OneOf(['2-stroke', '4-stroke']))
class WithMailUser(self.User):
email = fields.StrField(
validate=[validate.Email(),
validate.Length(max=100)])
number_of_legs = fields.IntField(
validate=[validate.OneOf([0, 1, 2])])
class SocialLink(EmbeddedDocument):
value = fields.UrlField(required=True)
type = fields.StrField(validate=validate.OneOf(SOCIAL_LINK_TYPES),
required=True)
