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 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 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 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 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 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 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 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 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 Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(160))
slug = db.Column(db.String(160))
body = db.Column(db.String(3000))
dateCreated = db.Column(db.String(80))
category = db.Column(db.String(80))
image = db.Column(db.String(160))
# user relationship
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', back_populates='posts')
# defines the init function
def __init__(self, *args, **kwargs):
# creates the slug
if not 'slug' in kwargs:
kwargs['slug'] = slugify(kwargs.get('title', ''))
super().__init__(*args, **kwargs)
# represents the table
def __repr__(self):
return '<Post {}>'.format(self.title)
from server.database import db
tags = db.Table(
'tags',
db.Column('tag_id', db.Integer, db.ForeignKey('tag.id'), primary_key=True),
db.Column('project_id',
db.Integer,
db.ForeignKey('project.id'),
primary_key=True))
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))
from server.database import db
# categories to words relationship
categories = db.Table(
'categories',
db.Column('category_id',
db.Integer,
db.ForeignKey('category.id'),
primary_key=True),
db.Column('word_id',
db.Integer,
db.ForeignKey('word.id'),
primary_key=True))
# concepts to words relationship
concepts = db.Table(
'concepts',
db.Column('concept_id',
db.Integer,
db.ForeignKey('concept.id'),
primary_key=True),
db.Column('word_id',
db.Integer,
db.ForeignKey('word.id'),
primary_key=True))
class Word(db.Model):
id = db.Column(db.Integer, primary_key=True)
string = db.Column(db.String, nullable=False)
from server.database import Model, db, Column, relationship
user_assoc = db.Table(
'user_assoc',
db.Column('user', db.Integer, db.ForeignKey('userprofile.id')),
db.Column('paper', db.Integer, db.ForeignKey('papers.id'))
)
class Paper(Model):
__tablename__ = 'papers'
id = Column(db.Integer, primary_key=True)
author = Column(db.Str, primary_key=True)
title = Column(db.Str, nullable=True)
subject = Column(db.Text, nullable=True)
keywords = Column(db.String, nullable=True)
pages = Column(db.Integer)
# 文献的路径信息可以由文献的DOI号或者是文献标题获取到(判断有无)，文件的存放路径应该在配置文件中规定，不存到数据库，可以通过
# property规范
# user.profile.papers 获取到用户的所有信息
owners = relationship(
'UserProfile',
secondary=user_assoc,
# 个人文库，library
backref='papers'
)
def __init__(self, author, title, subject, keyword):
db.Model.__init__(cls, author=author, title=title)
# coding: utf-8
import datetime as dt
from flask_jwt import current_identity
from server.database import (Model, SurrogatePK, db, Column, reference_col,
relationship)
from slugify import slugify
from server.profile.models import UserProfile
favoriter_assoc = db.Table(
"favoritor_assoc",
db.Column("favoriter", db.Integer, db.ForeignKey("userprofile.id")),
db.Column("favorited_article", db.Integer, db.ForeignKey("article.id")))
tag_assoc = db.Table(
"tag_assoc", db.Column("tag", db.Integer, db.ForeignKey("tags.id")),
db.Column("article", db.Integer, db.ForeignKey("article.id")))
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):
from flask_jwt import current_identity
from server.database import (Model, SurrogatePK, db,
reference_col, relationship)
followers_assoc = db.Table("followers_assoc",
db.Column("follower", db.Integer, db.ForeignKey("userprofile.user_id")),
db.Column("followed_by", db.Integer, db.ForeignKey("userprofile.user_id")))
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())