class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(80), unique=True)
password_hash = db.Column(db.String(240), unique=False)
is_online = db.Column(db.Boolean, unique=False)
def __init__(self, username, email, password, is_online=False):
self.username = username
self.email = email
self.password_hash = hash_password(password)
self.is_online = is_online
def __repr__(self):
return '<User %r>' % self.username
def create(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def update(self):
db.session.add(self)
db.session.commit()
class Word(db.Model):
id = db.Column(db.Integer, primary_key=True)
string = db.Column(db.String, nullable=False)
# categories relationship
categories = db.relationship('Category',
secondary=categories,
lazy='subquery',
backref=db.backref('words', lazy=True))
# concepts relationship
concepts = db.relationship('Concept',
secondary=concepts,
lazy='subquery',
backref=db.backref('related_words', lazy=True))
# gets the first letter
def get_first_letter(self):
return self.string[:2]
# gets the second letter
def get_second_letter(self):
return self.string[2:3]
# gets the non-string word
def get_non_string_word(self):
string = self.string.strip('"')
string = string.strip("'")
return string
# repr
def __repr__(self):
return f"<w-{self.string.upper()}>"
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
string = db.Column(db.String, nullable=False)
# repr
def __repr__(self):
return f"<c-{self.string.upper()}>"
class Ad(db.Model):
id = db.Column(db.String(80), primary_key=True)
title = db.Column(db.String(160))
type = db.Column(db.String(80))
content = db.Column(db.String(1000))
def __repr__(self):
return '<Ad: {}>'.format(self.title)
class Student(db.Model, UserMixin):
__tablename__ = "students"
# define attributes
# IDs must be like "xxFIxxx" which consists of seven letters.
user_id = db.Column(CHAR(7), nullable=False, primary_key=True)
password = db.Column(VARCHAR(255), nullable=False)
report_count = db.Column(INTEGER)
is_allowed_to_add_schedule = db.Column(BOOLEAN, nullable=False)
msg_from_admin = db.Column(TEXT, nullable=True)
def __init__(self, user_id, password):
self.user_id = user_id
self.password = generate_password_hash(password)
self.report_count = 0
self.is_allowed_to_add_schedule = True
self.msg_from_admin = ""
def verify_password(self, password):
if check_password_hash(self.password, password):
return True
else:
return False
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return self.user_id
def get(self):
return self
@classmethod
def auth(cls, user_id, password):
user = db.session.query(Student)\
.filter(Student.user_id == user_id).first()
if user.user_id == user_id and\
check_password_hash(user.password, password):
return True
else:
return False
def __repr__(self):
return "<user_id=%s, password=%s, report_count=%s, \
is_allowed_to_add_schedule=%s>"\
% (
self.user_id,
self.password,
self.report_count,
self.is_allowed_to_add_schedule
)
class DbRepeat(db.Model):
__tablename__ = 'dc_repeats'
id_repeat = db.Column(db.Integer, primary_key=True, autoincrement=True)
repeat_days = db.Column(db.Integer, unique=True)
def __init__(self, repeat_days=None):
self.repeat_days = repeat_days
def __repr__(self):
return '<DbRepeat {} days>'.format(self.repeat_days)
class Tags(Model):
__tablename__ = 'tags'
id = db.Column(db.Integer, primary_key=True)
tagname = db.Column(db.String(100))
def __init__(self, tagname):
db.Model.__init__(self, tagname=tagname)
def __repr__(self):
return self.tagname
class DbUserWordRepeat(db.Model):
__tablename__ = 'user_words_repeats'
id_user_word_repeat = db.Column(db.Integer,
primary_key=True,
unique=True,
autoincrement=True)
id_word = db.Column(db.Integer,
db.ForeignKey(DbWord.id_word),
nullable=False)
id_repeat = db.Column(db.Integer,
db.ForeignKey(DbRepeat.id_repeat),
nullable=False)
repeat_after_db_dts = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.utcnow)
def __init__(self, id_word=None):
self.id_word = id_word
def __repr__(self):
return '<DbUserWordRepeat [{}] - repeat_after={}>'.format(
self.id_user_word, self.repeat_after_db_dts)
def set_repeat(self, db_repeat):
now = datetime.datetime.utcnow()
self.id_repeat = db_repeat.id_repeat
self.repeat_after_db_dts = (
now + datetime.timedelta(days=db_repeat.repeat_days)).replace(
hour=0, minute=0, second=0)
def set_next_repeat_dts(self):
db_repeats = db.session.query(DbRepeat).order_by(
DbRepeat.repeat_days).all()
def get_min_db_repeat(min_days):
for item in db_repeats:
if item.repeat_days > min_days:
return item
return db_repeats[len(db_repeats) - 1]
if self.id_repeat is None:
db_repeat = get_min_db_repeat(0)
self.set_repeat(db_repeat)
return
current_db_repeat = [
item for item in db_repeats if item.id_repeat == self.id_repeat
][0]
db_repeat = get_min_db_repeat(current_db_repeat.repeat_days)
self.set_repeat(db_repeat)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
class User(db.Model):
__tablename__ = 'user'
id = db.Column(CHAR(7), primary_key=True)
password = db.Column(VARCHAR(255), nullable=False)
def __init__(self, id, password):
self.id = id
self.password = password
def __repr__(self):
return "<User(id='%s', password='******')>" % (self.id, self.password)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80))
password = db.Column(db.String(160))
category = db.Column(db.String(80))
# posts relationship
posts = db.relationship('Post', back_populates='user')
# represents the table
def __repr__(self):
return '<User {}>'.format(self.username)
class Company(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
location = db.Column(db.String, nullable=False)
email = db.Column(db.String, nullable=False)
logo = db.Column(db.String, nullable=False)
created_at = db.Column(db.Float, nullable=False)
modified_at = db.Column(db.Float, nullable=False)
# stripe
stripe_id = db.Column(db.String)
# projects relationship
projects = db.relationship('Project', backref='company', lazy=True)
# serializes
@property
def serialize(self):
json_company = {
"id": self.id,
"name": self.name,
"location": self.location,
"email": self.email,
"logo": self.logo,
"stripe_id": self.stripe_id,
"created_at": self.created_at,
"modified_at": self.modified_at,
}
return json_company
# repr
def __repr__(self):
return "<Company - {}>".format(self.name)
class Image(db.Model):
__tablename__ = 'images'
id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
nullable=False)
file_name = db.Column(db.String(), nullable=False, unique=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', name='FK_users_images'))
timestamp = db.Column(db.DateTime, index=True, default=db.func.now())
def __repr__(self):
return '<id {}:{}>'.format(self.id, self.file_name)
class Concept(db.Model):
id = db.Column(db.Integer, primary_key=True)
type = db.Column(db.String, nullable=True)
string = db.Column(db.String, nullable=True)
# gets the words related to the concept in an organized fashion
# TODO: build out this function
def get_words(self):
return self.words
# repr
def __repr__(self):
return f"<co-{self.string.upper()}>"
class Admin(db.Model):
__tablename__ = "admin"
# define attributes of admin
# id must be "admin" and others will be failed at validation.
id = db.Column(CHAR(5), nullable=False, primary_key=True)
password = db.Column(VARCHAR(255), nullable=False)
# do not allow admin to change its username
def __init__(password, self):
self.password = password
def __repr(self):
return "This is an Administrative account. 403 unauthorized."
class DbLanguage(db.Model):
__tablename__ = 'dc_languages'
EN = 1
RU = 2
id_language = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text, unique=True)
def __init__(self, id_lang=None, name=None):
self.id_language = id_lang
self.name = name
def __repr__(self):
return '<DbLanguage [{}] - {}>'.format(self.id_language, self.name)
class Task(db.Model):
__tablename__ = 'tasks'
task_id = db.Column(INTEGER, primary_key=True)
user_id = db.Column(CHAR(7), nullable=False)
content = db.Column(TEXT, nullable=False)
_limit = db.Column(CHAR(10), nullable=False)
def __init__(self, user_id, content, _limit):
self.user_id = user_id
self.content = content
self._limit = _limit
def __repr__(self):
return "<Task(task_id='%s', user_id='%s', content='%s', _limit='%s')>" % (
self.task_id, self.user_id, self.content, self._limit)
class NotaFiscal(db.Model):
__tablename__ = 'nfe'
id = db.Column(db.Integer, primary_key=True)
access_key = db.Column(db.String(120),
unique=True,
index=True,
nullable=False,
server_default='')
total_value = db.Column(db.Float, nullable=False, default=0)
def __repr__(self):
return f'Nfe: {self.access_key} {self.total_value}'
def to_dict(self):
return {'access_key': self.access_key, 'total_value': self.total_value}
class User(db.Model):
__tablename__ = 'notice'
noticeID = db.Column(int(255), primary_key=True)
adminID = db.Column(VARCHAR(255), nullable=False)
title = db.Column(VARCHAR(1000), nullable=False)
content = db.Column(VARCHAR(10000), nullable=False)
def __init__(self, noticeID, adminID):
self.noticeID = noticeID
self.adminID = adminID
def __repr__(self):
return "<User(id='%s', password='******')>" % (
self.id,
self.password
)
class DbUser(db.Model):
__tablename__ = 'users'
id_user = db.Column(db.Integer,
primary_key=True,
unique=True,
index=True,
autoincrement=True)
id_session = db.Column(db.Text, nullable=True)
id_language = db.Column(db.Integer,
db.ForeignKey(DbLanguage.id_language),
nullable=False)
email = db.Column(db.Text, nullable=False, index=True)
password = db.Column(db.Text, nullable=False)
password_salt = db.Column(db.Text, nullable=False)
is_in_use = db.Column(db.Boolean, nullable=False, default=True)
def __init__(self, email=None, lang=None, password=None):
self.email = email
self.id_language = lang
if password is not None:
from server.tools.passwords import create_password_hash_and_salt
self.password, self.password_salt = create_password_hash_and_salt(
password)
def __repr__(self):
return '<DbUser [{}] - {}>'.format(self.id_user, self.email)
class Purpose(db.Model):
__tablename__ = 'purposes'
id = db.Column(INTEGER(unsigned=True), primary_key=True)
record_id = db.Column(
INTEGER(unsigned=True),
db.ForeignKey('records.id', onupdate='CASCADE', ondelete='CASCADE'))
purpose_id = db.Column(
INTEGER(unsigned=True),
db.ForeignKey('purpose_masters.id',
onupdate='CASCADE',
ondelete='CASCADE'))
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
created_by = db.Column(db.String(255), nullable=False)
updated_by = db.Column(db.String(255), nullable=False)
def __init__(self, record_id, purpose_id, created_by):
self.record_id = record_id
self.purpose_id = purpose_id
self.created_by = created_by
self.updated_by = created_by
class Task(db.Model):
__tablename__ = 'tasks'
id = db.Column(db.String(), primary_key=True, nullable=False)
name = db.Column(db.String(), index=True, nullable=False)
description = db.Column(db.String())
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', name='FK_users_tasks'))
complete = db.Column(
db.Boolean,
default=False,
)
created = db.Column(db.DateTime(), default=db.func.now())
updated = db.Column(db.DateTime(),
default=db.func.now(),
onupdate=db.func.now())
def get_rq_job(self):
try:
rq_job = rq.job.Job.fetch(self.id, connection=current_app.redis)
except (redis.exceptions.RedisError, rq.exceptions.NoSuchJobError):
return None
return rq_job
def get_progress(self):
job = self.get_rq_job()
return job.meta.get('progress', 0) if job is not None else 100
class BlacklistedToken(db.Model):
id = db.Column(db.Integer, primary_key=True)
jti = db.Column(db.String(36), nullable=False)
user_identity = db.Column(db.String(50), nullable=False)
expires = db.Column(db.DateTime, nullable=False)
def as_json(self):
"""Get the JSON representation of a BlacklistedToken object.
Returns:
The JSON representation of a BlacklistedToken object.
"""
return {
'id': self.id,
'jti': self.jti,
'user': self.user_identity,
'expires': self.expires
}
class UserProfile(Model, SurrogatePK):
__tablename__ = 'userprofile'
# id is needed for primary join, it does work with SurrogatePK class
id = db.Column(db.Integer, primary_key=True)
user_id = reference_col('users', nullable=False)
user = relationship('User', backref=db.backref('profile', uselist=False))
follows = relationship('UserProfile',
secondary=followers_assoc,
primaryjoin=id == followers_assoc.c.follower,
secondaryjoin=id == followers_assoc.c.followed_by,
backref='followed_by',
lazy='dynamic')
def __init__(self, user, **kwargs):
db.Model.__init__(self, user=user, **kwargs)
def is_following(self, profile):
return bool(self.follows.filter(followers_assoc.c.followed_by == profile.id).count())
def follow(self, profile):
if self is not profile and not self.is_following(profile):
self.follows.append(profile)
return True
return False
def unfollow(self, profile):
if self is not profile and self.is_following(profile):
self.follows.remove(profile)
return True
return False
@property
def following(self):
if current_identity:
return current_identity.profile.is_following(self)
return False
@property
def username(self):
return self.user.username
@property
def bio(self):
return self.user.bio
@property
def image(self):
return self.user.image
@property
def email(self):
return self.user.email
class DbWord(db.Model):
__tablename__ = 'words'
id_word = db.Column(db.Integer,
primary_key=True,
unique=True,
index=True,
autoincrement=True)
id_user = db.Column(db.Integer,
db.ForeignKey(DbUser.id_user),
index=True,
nullable=False)
id_word_type = db.Column(db.Integer,
db.ForeignKey(DbWordType.id_type),
nullable=True)
word = db.Column(db.Text, nullable=False, index=True)
transcription = db.Column(db.Text, nullable=True)
score = db.Column(db.Integer, nullable=False, index=True, default=0)
is_learnt = db.Column(db.Boolean, nullable=False, default=False)
last_learn_db_dts = db.Column(db.DateTime, nullable=True)
add_db_dts = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.utcnow)
is_in_use = db.Column(db.Boolean, nullable=False, default=True)
def __init__(self,
id_user=None,
word=None,
id_type=None,
transcription=None):
self.id_user = id_user
self.word = word
self.id_word_type = id_type
self.transcription = transcription
def __repr__(self):
return '<DbWord [{}] - {}>'.format(self.id_word, self.word)
class Tag(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
created_at = db.Column(db.Float, nullable=False)
modified_at = db.Column(db.Float, nullable=False)
# serializes
@property
def serialize(self):
json_tag = {
"id": self.id,
"name": self.name,
"created_at": self.created_at,
"modified_at": self.modified_at,
}
return json_tag
# repr
def __repr__(self):
return "<Tag - {}>".format(self.name)
class DbTranslation(db.Model):
__tablename__ = 'translations'
id_translation = db.Column(db.Integer,
primary_key=True,
unique=True,
autoincrement=True)
id_word = db.Column(db.Integer,
db.ForeignKey(DbWord.id_word),
nullable=False)
id_language = db.Column(db.Integer,
db.ForeignKey(DbLanguage.id_language),
nullable=False)
translation = db.Column(db.Text, nullable=False, index=True)
add_db_dts = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.utcnow)
is_in_use = db.Column(db.Boolean, nullable=False, default=True)
def __init__(self, id_word=None, id_lang=None, translation=None):
self.id_word = id_word
self.id_language = id_lang
self.translation = translation
def __repr__(self):
return '<DbTranslation [{}] - {}>'.format(self.id_translation,
self.translation)
class Project(db.Model):
id = db.Column(db.Integer, primary_key=True)
published = db.Column(db.Boolean, nullable=False)
demo = db.Column(db.Boolean, nullable=False)
title = db.Column(db.String, nullable=False)
description = db.Column(db.String, nullable=False)
restrictions = db.Column(db.String)
link = db.Column(db.String, nullable=False)
created_at = db.Column(db.Float, nullable=False)
modified_at = db.Column(db.Float, nullable=False)
# company relationship
company_id = db.Column(db.Integer, db.ForeignKey('company.id'))
# tags relationship
tags = db.relationship('Tag',
secondary=tags,
lazy='subquery',
backref=db.backref('projects', lazy=True))
# serializes
@property
def serialize(self):
json_project = {
"id": self.id,
"published": self.published,
"demo": self.demo,
"title": self.title,
"description": self.description,
"restrictions": self.restrictions,
"link": self.link,
"created_at": self.created_at,
"modified_at": self.modified_at,
}
return json_project
# repr
def __repr__(self):
return "<Project - {}>".format(self.title)
class ConceptRelationship(db.Model):
id = db.Column(db.Integer, primary_key=True)
# concept noun relationship
concept_noun_id = db.Column(db.Integer, db.ForeignKey('concept.id'))
concept_noun = db.relationship("Concept",
backref="noun_relationships",
foreign_keys=[concept_noun_id])
# concept verb relationship
concept_verb_id = db.Column(db.Integer, db.ForeignKey('concept.id'))
concept_verb = db.relationship("Concept",
backref="verb_relationships",
foreign_keys=[concept_verb_id])
# concept adjective relationship
concept_adjective_id = db.Column(db.Integer, db.ForeignKey('concept.id'))
concept_adjective = db.relationship("Concept",
backref="adjective_relationships",
foreign_keys=[concept_adjective_id])
# repr
def __repr__(self):
return f"<cor-{self.concept_noun} & {self.concept_verb} & {self.concept_adjective}>"
class Comment(Model, SurrogatePK):
__tablename__ = 'comment'
id = db.Column(db.Integer, primary_key=True)
body = Column(db.Text)
createdAt = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
updatedAt = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
author_id = reference_col('userprofile', nullable=False)
author = relationship('UserProfile', backref=db.backref('comments'))
article_id = reference_col('article', nullable=False)
def __init__(self, article, author, body, **kwargs):
db.Model.__init__(self,
author=author,
body=body,
article=article,
**kwargs)
