class Case(db.Model):
__tablename__ = 'case'
id = db.Column(db.Integer, primary_key=True) # noqa
date = db.Column(db.DateTime,
nullable=True,
default=datetime.datetime.now())
diagnosis = db.Column(db.String, nullable=True)
patient_surename = db.Column(db.String, nullable=True)
doctor_id = db.Column(
db.Integer,
db.ForeignKey('doctor.id', ondelete='CASCADE'),
index=True,
nullable=True,
)
patient_id = db.Column(
db.Integer,
db.ForeignKey('patient.id', ondelete='CASCADE'),
index=True,
nullable=True,
)
doctor = db.relationship('Doctor', backref='case')
patient = db.relationship('Patient', backref='case')
def json_dump(self):
return {
'id': self.id, # noqa
'date': self.date,
'diagnosis': self.diagnosis,
'patient_surename': self.patient_surename,
}
def __repr__(self):
return '<Case {0} {1} {2} {3}>'.format(self.id, self.patient_surename,
self.diagnosis, self.date)
class Vacancy(db.Model):
__tablename__ = "vacancies"
id = db.Column(db.Integer, primary_key=True)
vacancy_url = db.Column(db.TEXT, nullable=True)
vacancy_name = db.Column(db.TEXT, nullable=True)
vacancy_city = db.Column(db.String(50), nullable=True)
vacancy_country = db.Column(db.String(10), nullable=True)
vacancy_salary_value = db.Column(db.TEXT, nullable=True)
vacancy_salary_min = db.Column(db.TEXT, nullable=True)
vacancy_salary_max = db.Column(db.TEXT, nullable=True)
vacancy_salary_currency = db.Column(db.TEXT, nullable=True)
vacancy_salary_period = db.Column(db.TEXT, nullable=True)
company_name = db.Column(db.TEXT, nullable=True)
vacancy_expirience = db.Column(db.TEXT, nullable=True)
vacancy_employment_type = db.Column(db.TEXT, nullable=True)
vacancy_text_clean = db.Column(db.TEXT, nullable=True)
vacancy_text_en = db.Column(db.TEXT, nullable=True)
vacancy_key_skills = db.Column(db.TEXT, nullable=True)
industry = db.Column(db.TEXT, nullable=True)
language = db.Column(db.String(5), nullable=True)
vacancy_published_at = db.Column(db.TEXT, nullable=True)
vacancy_graded = db.Column(db.Boolean, default=0, nullable=False)
vacancy_prof_area = db.Column(db.Integer, nullable=True)
favourites = db.relationship('Favourite', backref='vacancy_favourite')
vacancy_grades = db.relationship('VacancyGrade',
backref='vacancy_grades',
lazy=True)
class Task(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String, nullable=False)
description = db.Column(db.String, nullable=True)
short_description = db.Column(db.String, nullable=True)
due_date = db.Column(db.DateTime, nullable=True)
author = db.Column(db.Integer, db.ForeignKey("user.id"))
executor = db.Column(db.Integer, db.ForeignKey("user.id"))
project_id = db.Column(db.Integer, db.ForeignKey("project.id"))
comments = db.relationship("Comment",
backref=db.backref("comment"),
lazy=True)
status = db.Column(db.Integer, db.ForeignKey("status.id"))
tag = db.relationship("Tag",
secondary=tags,
backref=db.backref("task_tag"),
lazy=True)
@property
def is_active(self):
return self.status == 'active'
@property
def is_wait(self):
return self.status == 'wait'
@property
def is_disable(self):
return self.status == 'disable'
def __repr__(self):
return f"<Task {self.title} >"
class User(db.Model, UserMixin):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(50))
password = db.Column(db.String(128))
role = db.Column(db.String(10), index=True)
first_name = db.Column(db.String(80), nullable=True, server_default='Имя')
last_name = db.Column(db.String(80),
nullable=True,
server_default='Фамилия')
city = db.Column(db.String(80), nullable=True, server_default='Город')
user = db.relationship('Skill',
secondary=assoc_skill_user,
backref=db.backref('user', lazy='dynamic'))
user_1 = db.relationship('ProfessionalArea',
secondary=assoc_area_user,
backref=db.backref('user', lazy='dynamic'))
favourites = db.relationship('Favourite', backref='user_favourite')
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
@property
def is_admin(self):
return self.role == 'admin'
def __repr__(self):
return '<User {}>'.format(self.username)
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
email = db.Column(db.String(50), unique=True)
password_hash = db.Column(db.String(255), nullable=False, unique=True)
role = db.Column(db.String(5), nullable=False)
categories = db.relationship('Category',
backref='category_owner',
lazy='dynamic')
transactions = db.relationship('Transaction',
backref='transaction_owner',
lazy='dynamic')
balance = db.relationship('Balance',
backref='balance_owner',
uselist=False)
def __repr__(self):
return f"<User: name = {self.name}, id = {self.id}>"
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
@property
def is_admin(self):
return self.role == 'ADMIN'
class UsersWords(db.Model):
__tabename__ = 'users_words'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
engword_id = db.Column(db.Integer, db.ForeignKey('English_words.id'))
frenchword_id = db.Column(db.Integer, db.ForeignKey('French_words.id'))
user_engword_id = db.Column(
db.Integer, db.ForeignKey('English_words_added_by_users.id'))
user_frenchword_id = db.Column(
db.Integer, db.ForeignKey('French_words_added_by_users.id'))
imported_time = db.Column(db.DateTime,
nullable=True,
default=datetime.now())
status = db.Column(db.String, nullable=True, default='new')
memorizing_time = db.Column(db.DateTime, nullable=True)
word_translation = db.Column(db.Integer, nullable=True, default=0)
translation_word = db.Column(db.Integer, nullable=True, default=0)
word_write = db.Column(db.Integer, nullable=True, default=0)
translation_write = db.Column(db.Integer, nullable=True, default=0)
remember_word = db.Column(db.Integer, nullable=True, default=0)
users = db.relationship('User', backref='users')
english_words = db.relationship('EnglishWord', backref='english_words')
french_words = db.relationship('FrenchWord', backref='french_words')
user_english_words = db.relationship('EnglishWordOfUser',
backref='user_english_words')
user_french_words = db.relationship('FrenchWordOfUser',
backref='user_french_words')
class Project(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
tasks = db.relationship('Task', backref='project', lazy='dynamic')
users = db.relationship('User',
secondary=users_on_projets,
backref='user_project',
lazy='dynamic')
def __repr__(self):
return f"<Project {self.name}>"
class Skill(db.Model):
__tablename__ = "skills"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
count = db.Column(db.Integer, nullable=True)
category = db.relationship('Category',
secondary=assoc_skill_category,
backref=db.backref('catskill', lazy='dynamic'))
skill = db.relationship('User',
secondary=assoc_skill_user,
backref=db.backref('user_skill', lazy='dynamic'))
class ProfessionalArea(db.Model):
__tablename__ = "prof_areas"
id = db.Column(db.Integer, primary_key=True)
area_name = db.Column(db.String(100), nullable=True)
created_at = db.Column(db.TIMESTAMP,
server_default=db.func.current_timestamp(),
nullable=False)
count = db.Column(db.Integer, nullable=True)
prof_grades = db.relationship('VacancyGrade',
backref='prof_grades',
lazy=True)
area = db.relationship('User',
secondary=assoc_area_user,
backref=db.backref('user_area', lazy='dynamic'))
class Car(db.Model):
id = db.Column(db.Integer, primary_key=True)
plate = db.Column(db.String(9), unique=True)
description = db.Column(db.String(255))
waybills = db.relationship('Waybill', backref='car', lazy='dynamic')
def __repr__(self):
return '<Машина {}>'.format(self.plate)
class TeacherStudent(db.Model, UserMixin):
__tablename__ = 'teachers_students'
id = db.Column(db.Integer, primary_key=True)
teacher_id = db.Column(db.Integer,
db.ForeignKey('teachers.teacher_id',
ondelete='CASCADE'),
nullable=False)
student_id = db.Column(db.Integer,
db.ForeignKey('students.student_id',
ondelete='CASCADE'),
nullable=False)
teachers = db.relationship('Teacher', backref='teachers')
students = db.relationship('Student', backref='students')
def __repr__(self):
return f'<Teacher "{self.teacher_id}" has student {self.student_id}>'
class Auto(db.Model):
__tablename__ = 'auto'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
price = db.Column(db.Integer)
description = db.Column(db.Text)
active = db.Column(db.Boolean, unique=False, default=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
brand_id = db.Column(db.Integer, db.ForeignKey('auto_brand.id'))
model_id = db.Column(db.Integer, db.ForeignKey('auto_models.id'))
images = db.relationship('Images', backref='auto', lazy=True)
params = db.relationship('Params',
backref='auto',
lazy=True,
uselist=False)
create_date = db.Column(db.DateTime, default=datetime.datetime.now)
def __repr__(self):
return f'<Auto {self.name} >'
class Category(db.Model):
__tablename__ = 'categories'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
description = db.Column(db.Text, nullable=True)
img_src = db.Column(db.String, unique=True, nullable=True)
door_list = db.relationship("Door", backref="door_id")
def __repr__(self):
return '<Category {} {}>'.format(self.name, self.description)
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), index=True, unique=True)
docs = db.relationship('Doc', backref='category', lazy='dynamic')
def __init__(self, name):
self.name = name
def __repr__(self):
return '<Category {}'.format(self.body)
class Query(db.Model):
id = db.Column(db.Integer, primary_key=True)
category_id = db.Column(db.Integer, db.ForeignKey('settings.id'))
category = db.relationship("Settings", foreign_keys=[category_id])
query_str = db.Column(db.String(50))
age_id = db.Column(db.Integer, db.ForeignKey('settings.id'))
age = db.relationship("Settings", foreign_keys=[age_id])
status = db.Column(db.String(25))
percent = db.Column(db.Integer)
result_url = db.Column(db.String(12), index=True, unique=True)
date = db.Column(db.DateTime, default=datetime.utcnow)
user = db.Column(db.Integer, db.ForeignKey('user.id'))
posts = db.relationship("Post",
secondary=association_table,
backref="queries",
cascade="all",
passive_deletes=True)
def __repr__(self):
return '<Запрос: {}>'.format(self.query_str)
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password = db.Column(db.String(128))
image_file = db.Column(db.String(20), nullable=True, default='default.jpg')
role = db.Column(db.String(10), index=True)
english_words = db.relationship('EnglishWord', secondary='users_words')
french_words = db.relationship('FrenchWord', secondary='users_words')
user_english_words = db.relationship('EnglishWordOfUser',
secondary='users_words')
user_french_words = db.relationship('FrenchWordOfUser',
secondary='users_words')
teacher = db.relationship('Teacher', backref='user', uselist=False)
student = db.relationship('Student', backref='user', uselist=False)
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
@property
def is_admin(self):
return self.role == 'admin'
def __repr__(self):
return '<User {}>'.format(self.username)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), unique=True, index=True, nullable=False)
email = db.Column(db.String(50), nullable=False)
password = db.Column(db.String(128), nullable=False)
userpic_url = db.Column(db.String(), nullable=True)
comments = db.relationship("Comment", backref=db.backref("comments"), lazy=True)
messages = db.relationship("Messege", backref=db.backref("messege"), lazy=True)
role =db.Column(db.String(10), index=True)
def set_password(self, password):
self.password=generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
@property
def is_admin(self):
return self.role =='admin'
def __repr__(self):
return f"<User {self.username}>"
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.Integer, nullable=False)
created = db.Column(db.DateTime, nullable=False, default=datetime.now())
news_id = db.Column(
db.Integer,
db.ForeignKey('news.id', ondelete='CASCADE'),
index=True
)
user_id = db.Column(
db.Integer,
db.ForeignKey('user.id', ondelete='CASCADE'),
index=True
)
news = db.relationship('News', backref='comments')
user = db.relationship('User', backref='comments')
def __repr__(self):
return '<Comment {}>'.format(self.id)
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
mail = db.Column(db.String(50), index=True, unique=True)
number = db.Column(db.String(11), index=True, unique=True)
password = db.Column(db.String(128))
role = db.Column(db.String(10), index=True, default='user')
avatar = db.Column(db.String)
street_address = db.Column(db.String)
auto = db.relationship('Auto', lazy=True, backref='auto')
messages_sent = db.relationship('Message',
foreign_keys='Message.sender_id',
backref='author',
lazy='dynamic')
messages_received = db.relationship('Message',
foreign_keys='Message.recipient_id',
backref='recipient',
lazy='dynamic')
last_message_read_time = db.Column(db.DateTime)
def new_messages(self):
last_read_time = self.last_message_read_time or datetime(1900, 1, 1)
return Message.query.filter_by(recipient=self).filter(
Message.timestamp > last_read_time).count()
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
@property
def is_admin(self):
return self.role == 'admin'
def __repr__(self):
return f'User {self.username}, id={self.id}'
class Teacher(db.Model, UserMixin):
__tablename__ = 'teachers'
teacher_id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE'),
unique=True)
students = db.relationship('Student', secondary='teachers_students')
def __repr__(self):
return f'<Teacher "{self.teacher_id}" has user id {self.user_id}>'
def get_id(self):
return set(self.teacher_id)
class Category(db.Model):
__tablename__ = 'categories'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey(User.id))
name = db.Column(db.String(50), nullable=False)
is_income = db.Column(db.Boolean, nullable=False)
transactions = db.relationship('Transaction',
backref='trans_cat',
lazy='dynamic')
def __repr__(self):
return (f"<Category: name = {self.name}, id = {self.id},"
f" is_income = {self.is_income}>")
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
reddit_id = db.Column(db.String(50))
body = db.Column(db.Text)
url = db.Column(db.String(150))
done = db.Column(db.Boolean, default=False)
score = db.Column(db.Float)
comments = db.relationship('Comment',
backref='comments',
lazy='dynamic',
cascade='all,delete-orphan')
def __repr__(self):
return '{}'.format(self.reddit_id)
class Timing(db.Model):
__tablename__ = 'timing'
id = db.Column(db.Integer, primary_key=True) # noqa
doctor_id = db.Column(db.Integer,
db.ForeignKey('doctor.id', ondelete='CASCADE'),
index=True)
day = db.Column(db.DateTime, nullable=True, default=datetime.date.today())
hours_with = db.Column(db.Integer, nullable=True, default=9)
minutes_with = db.Column(db.Integer, nullable=True, default=0)
hours_to = db.Column(db.Integer, nullable=True, default=18)
minutes_to = db.Column(db.Integer, nullable=True, default=0)
doctor = db.relationship('Doctor', backref='timing')
def __repr__(self):
return '<Timing {0} {1}>'.format(self.doctor_id, self.day)
class User(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
login = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(100), nullable=False)
is_admin = db.Column(db.Boolean, nullable=False, default=False)
persons = db.relationship("Person", backref="user")
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
def __repr__(self):
return f'<User id {self.id}>'
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), index=True, unique=True)
password = db.Column(db.String(128))
role = db.Column(db.String(10), index=True)
email = db.Column(db.String(50), unique=True)
queries = db.relationship('Query', backref='author', lazy='dynamic')
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
@property
def is_admin(self):
return self.role == 'admin'
def __repr__(self):
return '<User {}>'.format(self.username)
class Ads(db.Model):
id = db.Column(db.Integer,
primary_key=True,
unique=True,
autoincrement=True,
nullable=False)
title = db.Column(db.String, nullable=False)
url = db.Column(db.String, unique=True, nullable=False)
price = db.Column(db.Integer, default=0)
address = db.Column(db.String)
published = db.Column(db.DateTime, nullable=False, default=datetime.now())
text = db.Column(db.Text)
images = db.relationship("Img", backref="img_src")
@property
def first_image_src(self):
if self.images:
return self.images[0].src
return ""
@property
def all_ads_images_src(self):
if self.images:
return [img.src for img in self.images]
return []
@staticmethod
def img_src_for_ad_id(id_):
res = []
for ad in Ads.query.all():
for im in ad.images:
if im.ad_id == id_:
res.append(im.src)
return res
def comments_count(self):
return Comment.query.filter(Comment.ads_id == self.id).count()
def __repr__(self):
return 'Ads {} {}>'.format(self.title, self.url)
class Auto_brand(db.Model):
__tablename__ = 'auto_brand'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
model = db.relationship('Auto_models', backref='auto_brand', lazy=True)
auto_id = db.relationship('Auto', backref='auto_brand', lazy=True)
class Auto_models(db.Model):
__tablename__ = 'auto_models'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
brand_id = db.Column(db.Integer, db.ForeignKey('auto_brand.id'))
auto_id = db.relationship('Auto', backref='auto_models', lazy=True)
