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 User(Document):
username = fields.StrField(required=True, unique=True)
email = fields.EmailField(required=True, unique=True)
firstname = fields.StrField()
lastname = fields.StrField()
# birthday = fields.DateTimeField()
birthday = fields.DateTimeField(validate=validate.Range(min=datetime.datetime(1900, 1, 1)))
password = fields.StrField(required=True) # Don't store it in clear in real life !
date_created = fields.DateTimeField(default=datetime.datetime.now())
date_modified = fields.DateTimeField(default=datetime.datetime.now())
# authored_docs = fields.ListField(fields.ReferenceField("Paper"))
def update(self, *args, **kwargs):
if not self.date_created:
self.date_created = datetime.datetime.now()
self.date_modified = datetime.datetime.now()
return super(User, self).update(*args, **kwargs)
class Meta:
# collection = db.users
collection_name = 'users'
def get_thread_karma(self):
"""
fetch the number of votes this user has had on his/her threads
1.) Get id's of all threads by this user
2.) See how many of those threads also were upvoted but not by
the person him/her self.
"""
# thread_ids = [t.id for t in self.threads]
# select = thread_upvotes.select(db.and_(
# thread_upvotes.c.thread_id.in_(thread_ids),
# thread_upvotes.c.user_id != self.id
# )
# )
# rs = db.engine.execute(select)
# return rs.rowcount
# TODO
return Thread.find({"user_id":self.id}).count()
def get_comment_karma(self):
"""
fetch the number of votes this user has had on his/her comments
"""
# TODO
return Comment.find({'user_id': self.id}).count()
def threads(self):
app.logger.debug(Thread.find({"user_id":self.id})[:])
return list(Thread.find({"user_id":self.id}))
def comments(self):
app.logger.debug(list(Comment.find({"user_id":self.id})))
return list(Comment.find({"user_id":self.id}))
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 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 User(Document):
name = fields.StringField(required=True, unique=True)
password = fields.StringField(required=True)
age = fields.IntegerField(required=True)
email = fields.EmailField(required=False)
class Meta:
collection = db.user
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 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 MySchema(Schema):
string = fields.StringField()
uuid = fields.UUIDField()
number = fields.NumberField()
integer = fields.IntegerField()
decimal = fields.DecimalField()
boolean = fields.BooleanField()
float = fields.FloatField()
url = fields.UrlField()
email = fields.EmailField()
constant = fields.ConstantField("const")
class User(Document):
name = fields.StringField(required=True)
email = fields.EmailField(required=True, unique=True)
password = fields.StringField()
confirm_code = fields.StringField()
reset_code = fields.StringField(default="")
is_admin = fields.BooleanField(default=False)
is_math_basic = fields.BooleanField(default=True)
class Meta:
collection = db.user
class MySchema(EmbeddedSchema):
string = fields.StringField()
uuid = fields.UUIDField()
number = fields.NumberField()
integer = fields.IntegerField()
decimal = fields.DecimalField()
boolean = fields.BooleanField()
formattedstring = fields.FormattedStringField('Hello {to_format}')
float = fields.FloatField()
# localdatetime = fields.LocalDateTimeField()
url = fields.UrlField()
email = fields.EmailField()
constant = fields.ConstantField("const")
class Users(Document, metaclass=MetaBaseTemplate):
__collection__ = "users"
email = fields.EmailField(required=True, unique=True)
guid = fields.UUIDField(missing=uuid.uuid4)
name = fields.StringField(validate=validate.Length(max=50), required=True)
picture = fields.UrlField()
password = fields.StringField(load_only=True)
class Meta:
pass
# indexes = ("email",)
@classmethod
def create_password(cls, passwd):
m = hashlib.sha256()
m.update(passwd)
return m.hexdigest()
class UserModel(Document):
fullname = fields.StringField(allow_none=True)
username = fields.StringField(required=True)
email = fields.EmailField(allow_none=True)
phone_number = fields.StringField(allow_none=True)
password = fields.StringField(required=True, load_only=True)
birth_date = fields.StringField(required=False)
auth_token = fields.StringField()
auth_provider = fields.StringField(load_only=True)
random_seed = fields.StringField(load_only=True)
auth_nonce = fields.StringField()
created_at = fields.DateTimeField(default=datetime.utcnow(),
missing=datetime.utcnow(),
load_only=True)
modified_at = fields.DateTimeField(default=datetime.utcnow(),
missing=datetime.utcnow(),
load_only=True)
class Meta:
collection = db.user
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 User(Document):
'''
Represents user of bot
'''
chat_id = fields.IntField(required=True, unique=True)
username = fields.StrField(required=True)
email = fields.EmailField(required=True)
track = fields.DictField()
current_survey = fields.DictField(default={})
current_question_number = fields.IntField(default=-1)
answers = fields.ListField(fields.ListField(
fields.StringField(default='')))
def update(self, **attrs) -> Union[UpdateResult, InsertOneResult]:
for attr in attrs:
self[attr] = attrs[attr]
return self.commit()
def __str__(self):
return f"User({self.email})"
class Meta:
collection_name = 'users'
class MongoUser(BaseDocument):
uid = umo_fields.StrField(attribute='_id')
username = umo_fields.StringField(required=True)
email = umo_fields.EmailField(required=True, unique=True)
class User(Document):
email = fields.EmailField(primary_key=True, required=True)
username = fields.StrField(required=True)
class User(Document):
email = fields.EmailField(required=True)
login = fields.StringField(required=True, unique=True)
password = fields.StringField(required=True)
class UserTempl(Document):
email = fields.EmailField(required=True, unique=True)
birthday = fields.DateTimeField(validate=validate.Range(
min=datetime(1900, 1, 1)))
friend = fields.ReferenceField("UserTempl")
class User(Document):
name = fields.StringField(required=True, unique=False)
email = fields.EmailField(required=True, unique=False)
