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 User(Document):
id = fields.ObjectIdField()
full_name = fields.StrField()
email = fields.EmailField(unique=True)
username = fields.StrField(unique=True)
hashed_password = fields.StrField()
last_password_updated_at = fields.DateTimeField()
scopes = fields.ListField(fields.StrField(), default=[])
created_at = fields.DateTimeField(default=datetime.now())
updated_at = fields.DateTimeField(default=datetime.now())
class Meta:
collection_name = 'user'
collection = db.user
@classmethod
async def get(cls, id: str):
if not ObjectId.is_valid(id):
return None
user = await cls.find_one({'_id': ObjectId(id)})
return user
def check_password(self, password: str):
if self.hashed_password:
return PWD_CONTEXT.verify(password, self.hashed_password)
def set_password(self, password: str):
self.hashed_password = PWD_CONTEXT.hash(password)
self.last_password_updated_at = datetime.now()
def create_access_token(self, expires_delta: timedelta = None):
now = datetime.utcnow()
if expires_delta:
expire = now + expires_delta
else:
expire = now + timedelta(minutes=15)
to_encode = {
'exp': expire,
'iat': now,
'sub': str(self.id),
'scope': ' '.join(self.scopes) if self.scopes else ''
}
encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
return encoded_jwt
@classmethod
async def get_by_username(cls, username: str):
return await cls.find_one({'username': username})
@classmethod
async def register_new_user(cls, email: str, full_name: str, username: str,
password: str):
user = cls(email=email, full_name=full_name, username=username)
user.set_password(password)
await user.commit()
return user
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 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 Member(Document):
class Meta:
strict = False
id = fields.IntegerField(attribute="_id")
pokemon = fields.ListField(fields.EmbeddedField(Pokemon), required=True)
selected = fields.IntegerField(required=True)
order_by = fields.StringField(default="number")
pokedex = fields.DictField(fields.StringField(),
fields.IntegerField(),
default=dict)
shinies_caught = fields.IntegerField(default=0)
balance = fields.IntegerField(default=0)
redeems = fields.IntegerField(default=0)
shiny_hunt = fields.IntegerField(default=None)
shiny_streak = fields.IntegerField(default=0)
boost_expires = fields.DateTimeField(default=datetime.min)
last_voted = fields.DateTimeField(default=datetime.min)
vote_total = fields.IntegerField(default=0)
vote_streak = fields.IntegerField(default=0)
gifts_normal = fields.IntegerField(default=0)
gifts_great = fields.IntegerField(default=0)
gifts_ultra = fields.IntegerField(default=0)
silence = fields.BooleanField(default=False)
joined_at = fields.DateTimeField(default=None)
invites = fields.IntegerField(default=0)
suspended = fields.BooleanField(default=False)
@property
def selected_pokemon(self):
try:
return next(
filter(lambda x: x.number == int(self.selected), self.pokemon))
except StopIteration:
return None
@property
def boost_active(self):
return datetime.now() < self.boost_expires
@property
def shiny_hunt_chance(self):
return (1 + math.tanh(self.shiny_streak / 50)) / 4096
def determine_shiny(self, species):
if self.shiny_hunt != species.dex_number:
return random.randint(1, 4096) == 1
else:
return random.random() < self.shiny_hunt_chance
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)
status = fields.StringField(required=True)
code = fields.IntegerField(required=True)
price = fields.FloatField(required=True)
deletion_time = fields.DateTimeField(allow_none=True)
class Account(Document):
#
username = fields.StringField(required=True)
password = fields.StringField(required=True)
createDate = fields.DateTimeField(
validate=validate.Range(min=datetime(1990, 1, 1)), required=True)
updateDate = fields.DateTimeField(
validate=validate.Range(min=datetime(1990, 1, 1)), required=True)
class Meta():
collection = db.account
class Car(Document):
model = fields.StringField()
manufacturer = fields.StringField()
release_year = fields.IntegerField()
colour = fields.StringField()
vin_code = fields.StringField(unique=True)
created_time = fields.DateTimeField(default=datetime.utcnow)
updated_time = fields.DateTimeField()
class Meta:
indexes = ["-created_time"]
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 User(Document):
#
name = fields.StringField(required=True)
department = fields.StringField(required=True)
team = fields.StringField(required=True)
createDate = fields.DateTimeField(
validate=validate.Range(min=pd.Timestamp(1990, 1, 1)), required=True)
updateDate = fields.DateTimeField(
validate=validate.Range(min=pd.Timestamp(1990, 1, 1)), required=True)
accountRef = fields.StringField(required=True)
class Meta():
collection = db.user
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 BaseDocument(Document):
createdAt = fields.DateTimeField(required=False)
updatedAt = fields.DateTimeField(required=False)
class Meta:
abstract = True
def pre_insert(self):
self.createdAt = now()
self.updatedAt = now()
def pre_update(self):
self.updatedAt = now()
class User(Document):
class Meta:
collection_name = 'users'
indexes = []
id = fields.IntField(required=True, unique=True, attribute='_id')
process_flag = fields.BooleanField(default=False)
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, default=None)
language_code = fields.StrField(required=True, allow_none=True)
language = fields.StrField(required=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 MLmodel(Document):
#
description = fields.StringField(required=True) # to remember the functionality of the pkl file
filename = fields.StringField(required=True) # plk file name
path = fields.StringField(required=True) # path of the plk file
version = fields.StringField(required=True) # plk file version
department = fields.StringField(required=True) # assign the model to department
team = fields.StringField(required=True) # assign the model to team
features = fields.StringField(required=True) # features have to be assigned
name = fields.StringField(required=True) # model name
isDeployed = fields.BooleanField(required=True,default=False)
createDate = fields.DateTimeField(validate=validate.Range(min=pd.Timestamp(1990,1,1)),required=True)
updateDate = fields.DateTimeField(validate=validate.Range(min=pd.Timestamp(1990,1,1)),required=True)
class Meta():
collection = db.mlmodel
class Subreddit(Document):
"""
"""
# __tablename__ = 'subreddits_subreddit'
# id = db.Column(db.Integer, primary_key=True)
# name = db.Column(db.String(SUBREDDIT.MAX_NAME), unique=True)
name = fields.StrField(validate=validate.Length(max=SUBREDDIT.MAX_NAME),
unique=True)
# desc = db.Column(db.String(SUBREDDIT.MAX_DESCRIPTION))
desc = fields.StrField(validate=validate.Length(
max=SUBREDDIT.MAX_DESCRIPTION))
# admin_id = db.Column(db.Integer, db.ForeignKey('users_user.id'))
admin_id = fields.ObjectIdField()
admin = fields.ReferenceField("User")
# created_on = db.Column(db.DateTime, default=db.func.now())
# updated_on = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now())
date_created = fields.DateTimeField(default=datetime.datetime.now())
date_updated = fields.DateTimeField(default=datetime.datetime.now())
# threads = db.relationship('Thread', backref='subreddit', lazy='dynamic')
# threads = fields.ReferenceField("Thread") # Integer?
status = fields.IntegerField(default=SUBREDDIT.ALIVE)
class Meta:
collection_name = 'subreddits'
# collection = db.subreddits
def __repr__(self):
return '<Subreddit %r>' % (self.name)
def get_threads(self, order_by='timestamp'):
"""
default order by timestamp
"""
# if order_by == 'timestamp':
# return self.threads.order_by(db.desc(Thread.created_on)).\
# all()[:SUBREDDIT.MAX_THREADS]
# else:
# return self.threads.order_by(db.desc(Thread.created_on)).\
# all()[:SUBREDDIT.MAX_THREADS]
threads = threads_model.Thread.find({'subreddit_id': self.id
}) #[:SUBREDDIT.MAX_THREADS]
return threads
class Payment(Document):
id_order = fields.ReferenceField(Order)
status = fields.BooleanField()
del_dtime = fields.DateTimeField()
class Meta:
collection = db.employee
class BaseStudent(Document):
name = fields.StrField(required=True)
birthday = fields.DateTimeField()
gpa = fields.FloatField()
class Meta:
abstract = True
class Channel(Document):
id = fields.IntegerField(attribute="_id")
incense_expires = fields.DateTimeField(default=datetime.min)
@property
def incense_active(self):
return datetime.utcnow() < self.incense_expires
class User(BaseDocument):
"""
This document stores the user information and data
as the number of victories and defeats
"""
username = fields.StrField(
required=True,
unique=True,
validate=[validate.Length(min=6, max=20)],
)
email = fields.StrField(
required=True,
unique=True,
validate=validate.Email(),
)
victories = fields.IntField(
default=0,
)
created_at = fields.DateTimeField(
default=datetime.datetime.now(),
)
class Meta:
"""
ODM Metadata
"""
collection = db.users
class MemberWarning(Document):
id = fields.IntegerField(attribute="_id")
member_id = fields.IntegerField(required=True)
guild_id = fields.IntegerField(required=True)
reason = fields.StringField(default=None)
active = fields.BooleanField(default=True)
date_issued = fields.DateTimeField(default=datetime.min)
class EmployeeModel(Document):
name = fields.StringField(required=True)
name_lower = fields.StringField(required=True)
email = fields.EmailField(required=True)
age = fields.IntegerField(required=True)
company = fields.StringField(required=True)
company_lower = fields.StringField(required=True)
join_date = fields.DateTimeField(required=True)
job_title = fields.StringField(required=True)
job_title_lower = fields.StringField(required=True)
gender = fields.StringField(required=True)
salary = fields.IntegerField(required=True)
class Meta:
collection_name = 'employee'
indexes = ('name_lower', 'age', 'company_lower', 'job_title_lower',
'gender', ('$name', '$company', '$job_title'))
@classmethod
def serialize(cls, dct):
return {
key: value
for key, value in dct.items()
if key != '_id' and not key.endswith('_lower')
}
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 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 Student(Document):
name = fields.StrField(required=True)
birthday = fields.DateTimeField()
courses = fields.ListField(fields.ReferenceField(Course))
class Meta:
allow_inheritance = True
class Member(Document):
class Meta:
collection_name = "member"
# vouch = fields.ListField(fields.IntegerField, default=list)
id = fields.IntegerField(attribute="_id")
balance = fields.IntegerField(default=0)
banker_balance = fields.IntegerField(default=0)
joined_at = fields.DateTimeField(default=None)
suspended = fields.BooleanField(default=False)
invites = fields.IntegerField(default=0)
gatcha_counter = fields.DictField(fields.StringField(),
fields.IntegerField(),
default=dict)
# shitty event collected code
has_collected = fields.BooleanField(default=False)
# even more shitty reputation system
vouched_for = fields.ListField(fields.IntegerField())
vouched_by = fields.ListField(fields.IntegerField())
reported_for = fields.ListField(fields.IntegerField())
reported_by = fields.ListField(fields.IntegerField())
pray_count = fields.IntegerField(default=0)
pray_winnings = fields.IntegerField(default=0)
#event system
event_activated = fields.BooleanField(default=False)
event_multiplier = fields.FloatField(default=1.0)
work_activated = fields.BooleanField(default=False)
bonus_bought = fields.BooleanField(default=False)
points = fields.FloatField(default=0.0)
class Member(Document):
class Meta:
strict = False
id = fields.IntegerField(attribute="_id")
coins = fields.IntegerField(default=0)
last_collected = fields.DateTimeField(default=datetime.min)
class ClinicalSample(Document):
clinicalSampleCode = fields.StringField(required=True)
sampleCounter = fields.IntegerField(required=True)
name = fields.StrField(required=True)
projectId = fields.ObjectIdField(required=True)
workflowTag = fields.StrField(required=False)
quality = fields.StrField(required=False)
description = fields.StrField()
processingPerson = fields.StrField()
createdDate = fields.DateTimeField(
validate=validate.Range(min=datetime(1900, 1, 1)))
updatedDate = fields.DateTimeField(
validate=validate.Range(min=datetime(1900, 1, 1)))
class Meta:
collection_name = "clinicalSample"
class WithDefault(Document):
with_umongo_default = fields.DateTimeField(
default=datetime(1999, 1, 1))
with_marshmallow_missing = fields.DateTimeField(
marshmallow_missing=datetime(2000, 1, 1))
with_marshmallow_default = fields.DateTimeField(
marshmallow_default=datetime(2001, 1, 1))
with_marshmallow_and_umongo = fields.DateTimeField(
default=datetime(1999, 1, 1),
marshmallow_missing=datetime(2000, 1, 1),
marshmallow_default=datetime(2001, 1, 1))
with_force_missing = fields.DateTimeField(
default=datetime(2001, 1, 1),
marshmallow_missing=missing,
marshmallow_default=missing)
with_nothing = fields.StrField()
class Rate(Document):
from_user = fields.ReferenceField('User', required=True)
to_user = fields.ReferenceField('User', required=True)
rate = fields.IntField(required=True,
validate=validate.Range(min=1, max=5))
description = fields.StrField()
date = fields.DateTimeField()
