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 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 User(db.Model, UserMixin
): #множественное наследование от классов 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(100))
role = db.Column(db.String(10), index=True)
email = db.Column(db.String(50))
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' # проверить атрибут role объекта класса User на соответствие админу
def __repr__(self):
return '<User {}>'.format(
self.username
) # при вызове функции возврат строки с именем пользователя, а не объекта
class User(
db.Model, UserMixin
): # Множественное наследование класса, берет и из db.Model и из UserMixin
id = db.Column(db.Integer, primary_key=True)
username = db.Column(
db.String(64), index=True, unique=True
) # Те колонки по которым буем часто искать помечаем unique=True - будет быстрее
password = db.Column(db.String(128))
role = db.Column(db.String(10), index=True)
email = db.Column(db.String(50))
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 name: {}, id: {}>'.format(
self.username,
self.id) # Что бы выводить имя пользователя в формате
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):
"""
Database Model for Users
"""
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)
def set_password(self, password):
"""
Sets password for each user and generates password hash via werkzeug. \n
Hash is saved to `password` class attribute.
"""
self.password = generate_password_hash(password)
def check_password(self, password):
"""
Checks provided password with hash in database. \n
Returns True or False
"""
return check_password_hash(self.password, password)
@property
def is_admin(self):
return self.role == "admin"
def __repr__(self):
return f"<User name: {self.username}, id: {self.id}>"
class Major(db.Model):
id = db.Column(db.Integer, primary_key=True)
major_code = db.Column(db.String(12), index=True, nullable=False)
major_name = db.Column(db.String(255), nullable=False)
def __repr__(self):
return '<Направление {} {}>'.format(self.major_code, self.major_name)
class Question(db.Model):
id = db.Column(db.Integer, primary_key=True)
major_id = db.Column(db.Integer,
db.ForeignKey('major.id', ondelete='CASCADE'),
nullable=False)
prof_id = db.Column(db.Integer,
db.ForeignKey('prof.id', ondelete='CASCADE'),
nullable=False)
kurs_id = db.Column(db.Integer,
db.ForeignKey('kurs.id', ondelete='CASCADE'),
nullable=False)
q_text = db.Column(db.Text, nullable=False)
img_name = db.Column(db.String(255), nullable=True)
answ1 = db.Column(db.String(255), nullable=False)
answ1_true = db.Column(db.SmallInteger, nullable=False)
answ2 = db.Column(db.String(255), nullable=True)
answ2_true = db.Column(db.SmallInteger, nullable=True)
answ3 = db.Column(db.String(255), nullable=True)
answ3_true = db.Column(db.SmallInteger, nullable=True)
major = relationship('Major')
prof = relationship('Prof')
kurs = relationship('Kurs', backref='questions')
def __repr__(self):
return '<Вопрос {}>'.format(self.q_text)
class Users(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
user_name = db.Column(db.String(52),
index=True,
unique=True,
nullable=False)
password = db.Column(db.String(128), nullable=False)
full_name = db.Column(db.String, unique=True, nullable=False)
role = db.Column(db.String(12), index=True, nullable=False)
id_major = db.Column(db.Integer, nullable=True)
id_prof = db.Column(db.Integer, nullable=True)
id_depart = db.Column(db.Integer, nullable=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'
@property
def is_department(self):
return self.role == 'department'
@property
def is_student(self):
return self.role == 'student'
def __repr__(self):
return '<Пользователь {} {}>'.format(self.full_name, self.role)
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 Settings(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50))
name = db.Column(db.String(50))
value = db.Column(db.String(50))
def __repr__(self):
return '<{} = {}>'.format(self.name, self.value)
class People(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(80))
patronymic = db.Column(db.String(80))
last_name = db.Column(db.String(80))
birth_date = db.Column(db.Date)
def __repr__(self):
return f'People {self.id} {self.last_name} {self.first_name} {self.patronymic} {self.birth_date}'
class Shop(db.Model):
id = db.Column(db.Integer, primary_key=True)
inn = db.Column(db.String(20))
name = db.Column(db.String(255), unique=True, nullable=False)
address = db.Column(db.String(255))
cash_desks = relationship('Cash_desk', backref='shop', lazy='dynamic')
def __repr__(self):
return '<Shop {}>'.format(self.name)
class Depart(db.Model):
id = db.Column(db.Integer, primary_key=True)
depart_name = db.Column(db.String(120),
index=True,
unique=True,
nullable=False)
full_name = db.Column(db.String(255), unique=True, nullable=False)
def __repr__(self):
return '<Кафедра {} {}>'.format(self.depart_name, self.full_name)
class Client(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
surname = db.Column(db.String(48))
name = db.Column(db.String(24))
middle_name = db.Column(db.String(48))
incident_counter = db.Column(db.Integer)
crime_status = db.Column(db.Integer, default=0)
def __repr__(self):
return f'{self.surname} {self.name} {self.middle_name}; \n Количество инцидентов - {self.incident_counter}'
class Announcement(db.Model):
'''
Это модель сущности построенная на основе sqlalchemy (db.py).
search_phrase - атрибут хранящий название объявления.
region - атрибут хранящий название города.
'''
id = db.Column(db.Integer, primary_key=True)
search_phrase = db.Column(db.String())
region = db.Column(db.String())
class Transport(db.Model):
id = db.Column(db.Integer, primary_key=True)
reg_number = db.Column(db.String(10))
VIN = db.Column(db.String(17))
brand = db.Column(db.String)
models_auto = db.Column(db.String)
color = db.Column(db.String)
owner = db.Column(db.String)
def __repr__(self):
return f'Транспортное средство {self.id} {self.brand} {self.models_auto} {self.reg_number}'
class Comment(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))
author = db.Column(db.String(50))
score = db.Column(db.Float)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
def __repr__(self):
return '<Комментарий {}>'.format(self.reddit_id)
class Product(db.Model):
id = db.Column(db.Integer, primary_key=True)
code = db.Column(db.String(13), index=True, unique=True)
name = db.Column(db.String(255), index=True, unique=True, nullable=False)
catalog_id = db.Column(db.Integer,
db.ForeignKey('catalog.id'),
nullable=False)
pen_names = relationship('Pen_name', backref='product', lazy='dynamic')
prices = relationship('Price', backref='product', lazy='dynamic')
def __repr__(self):
return '<Product {}>'.format(self.name)
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 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))
email = db.Column(db.String(50), unique=True)
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 '<User name={} id={}>'.format(self.username, self.id)
class Cash_desk(db.Model):
id = db.Column(db.Integer, primary_key=True)
shop_id = db.Column(db.Integer, db.ForeignKey('shop.id'), nullable=False)
fn = db.Column(db.String(16), unique=True, index=True)
def __repr__(self):
return '<Cash desk {} ({})>'.format(self.fn, self.shop.query.first())
class Account(db.Model):
"""Модель таблицы привязанных аккаунтов Steam.
Хранит идентификационный номер профиля в БД, идентификационный номер
профиля на сервисах Steam, логин профиля, логин-токен для входа без пароля,
sentry-файл для входа без 2FA-кода, ссылку на аватар профиля, никнейм
профиля, баланс кошелька, валюту кошелька и идентификационный номер
пользователя, которому принадлежит профиль.
"""
__tablename__ = "accounts"
account_id = db.Column(db.Integer, primary_key=True)
steam_id = db.Column(db.BigInteger, index=True)
username = db.Column(db.String, index=True, nullable=False)
login_key = db.Column(db.String, unique=True)
sentry = db.Column(db.LargeBinary)
avatar_url = db.Column(db.String)
nickname = db.Column(db.String)
wallet_balance = db.Column(db.Integer)
currency = db.Column(db.String(3))
user_id = db.Column(db.Integer, db.ForeignKey('users.user_id'))
items = relationship("Item", cascade="all,delete", backref='accounts',
lazy="dynamic")
def __repr__(self):
"""Определяем формат вывода объекта класса Account."""
return f"Account {self.username}."
class ChatMessages(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(256))
msg = db.Column(db.Text)
def __repr__(self):
return '<User %r>' % self.username
class Shopping_list(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
favorit = db.Column(db.Boolean, default=False, nullable=False)
private = db.Column(db.Boolean, default=True, nullable=False)
author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
author = relationship("User", lazy="joined")
items = relationship('Shopping_item',
backref='shopping_list',
lazy='dynamic')
access = relationship('List_access')
date_create = db.Column(db.DateTime, default=datetime.utcnow)
date_change = db.Column(db.DateTime, default=datetime.utcnow)
def check_access(self, user_id):
if self.author_id == user_id:
return 4
elif self.private:
return 0
else:
level = self.access.filter_by(user_id=user_id).first()
if level:
return level.role
return 0
def access_dict(self):
access_dict = {}
for access in self.access:
access_dict[access.user.username] = access.role
return access_dict
def __repr__(self):
return '<Shopping list {}>'.format(self.id)
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 Kurs(db.Model):
id = db.Column(db.Integer, primary_key=True)
major_id = db.Column(db.Integer,
db.ForeignKey('major.id', ondelete='CASCADE'),
nullable=False)
prof_id = db.Column(db.Integer,
db.ForeignKey('prof.id', ondelete='CASCADE'),
nullable=False)
depart_id = db.Column(db.Integer, nullable=False)
kurs_name = db.Column(db.String(255), index=True, nullable=False)
img_folder = db.Column(db.String(255), nullable=True)
percent_result = db.Column(db.Integer, nullable=False)
major = relationship('Major')
prof = relationship('Prof', backref='kurs')
def __repr__(self):
return ' {}'.format(self.kurs_name)
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):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
password = db.Column(db.String(128))
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 '<User name={} id={}>'.format(self.usernamem, self.id)
class Pen_name(db.Model):
id = db.Column(db.Integer, primary_key=True)
product_id = db.Column(db.Integer,
db.ForeignKey('product.id'),
nullable=False)
name = db.Column(db.String(255), index=True, unique=True, nullable=False)
def __repr__(self):
return '<Pen name {}>'.format(self.name)
