class WhoOwesWhom(db.Model): id = db.Column(db.Integer, primary_key=True) who = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) whom = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) group_id = db.Column(db.Integer, db.ForeignKey('groups.id'), nullable=False) debt_amount = db.Column(db.Integer) def __init__(self, who, whom, group_id): self.who = who self.whom = whom self.group_id = group_id self.debt_amount = 0 @property def get_amount(self): return self.debt_amount def plus_amount(self, amount): self.debt_amount += amount def to_json(self): json_wow = { 'who': url_for('api.get_user', id=self.who, _external=True), 'whom': url_for('api.get_user', id=self.whom, _external=True), 'group': url_for('api.get_group', id=self.group_id, _external=True), 'debt_amount': self.debt_amount } return json_wow
class CostGroup(db.Model): __tablename__ = 'cost_groups' id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) group_id = db.Column(db.Integer, db.ForeignKey('groups.id'), nullable=False) group_member = db.relationship('User', backref='group', lazy=True) def __init__(self, user_id, group_id): self.user_id = user_id self.group_id = group_id def to_json(self): json_memberships = {'user_id': self.user_id, 'group_id': self.group_id} return json_memberships @staticmethod def from_json(memberships_json): try: user_id = memberships_json.get('user_id') group_id = memberships_json.get('group_id') if user_id is None or group_id is None: return None return CostGroup(user_id, group_id) except AttributeError: return None
class Employee(UserMixin, db.Model): _tablename_ = 'employees' id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(60), index=True, unique=True) username = db.Column(db.String(60), index=True, unique=True) first_name = db.Column(db.String(60), index=True) last_name = db.Column(db.String(60), index=True) password_hash = db.Column(db.String(128)) department_id = db.Column(db.Integer, db.ForeignKey('departments.id')) role_id = db.Column(db.Integer, db.ForeignKey('roles.id')) is_admin = db.Column(db.Boolean, default=False) @property def password(self): """ Prevent pasword from being accessed """ raise AttributeError('password is not a readable attribute.') @password.setter def password(self, password): """ Set password to a hashed password """ self.password_hash = generate_password_hash(password) def verify_password(self, password): """ Check if hashed password matches actual password """ return check_password_hash(self.password_hash, password) def __repr__(self): return '<Employee: {}>'.format(self.username)
class UserRoles(db.Model): __tablename__ = "user_roles" id = db.Column(db.Integer(), primary_key=True) # Define foreign keys with Users and Role tables user_id = db.Column(db.Integer(), db.ForeignKey("users.id", ondelete="CASCADE")) role_id = db.Column(db.Integer(), db.ForeignKey("roles.id", ondelete="CASCADE"))
class Association(db.Model, CRUDMixin): employee = db.Column(db.Integer, db.ForeignKey('archive_employees.id', ondelete='cascade'), primary_key=True) rating = db.Column(db.Integer, db.ForeignKey('ratings.id', ondelete='cascade'), primary_key=True)
class Costs(db.Model): __tablename__ = "costs" id = db.Column(db.Integer, primary_key=True) cost_title = db.Column(db.String(128), nullable=False) spent_money = db.Column(db.Float, nullable=False) who_spent = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) purchase_time = db.Column(db.DateTime, default=datetime.now()) group_id = db.Column(db.Integer, db.ForeignKey('groups.id'), nullable=False) def __init__(self, cost_title, spent_money, group_id): self.cost_title = cost_title self.spent_money = spent_money self.group_id = group_id def __repr__(self): return f"{self.cost_title} was spent {self.spent_money} UAN " \ f"at {self.purchase_time.year} {self.purchase_time.month} {self.purchase_time.day} " def to_json(self): json_cost = { 'url': url_for('api.get_cost', id=self.id, _external=True), 'title': self.cost_title, 'spent_money': self.spent_money, 'who_spent': url_for('api.get_user', id=self.who_spent, _external=True), 'purchase_time': self.purchase_time, 'group': url_for('api.get_group', id=self.group_id, _external=True) } return json_cost @staticmethod def from_json(cost_json): cost_title = cost_json.get('cost_title') spent_money = cost_json.get('spent_money') group_id = cost_json.get('group_id') return Costs(cost_title=cost_title, spent_money=spent_money, group_id=group_id)
class Post(db.Model): id = db.Column(db.Integer, primary_key=True) body = db.Column(db.String(140)) timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) def __repr__(self): return "<Post {}>".format(self.body)
class Papers(db.Model): id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(400), index=True) url = db.Column(db.String(200), index=True) doi = db.Column(db.String(100), index=True) proposer_id = db.Column(db.Integer, db.ForeignKey('users.id')) schedule = db.relationship('Schedules', backref='paper', lazy='dynamic') def __repr__(self): return '<Paper {}>'.format(self.title)
class Post(db.Model): id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(100), nullable=False) date_posted = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) content = db.Column(db.Text, nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) def __repr__(self): return "Post('%s','%s')" % (self.title, self.date_posted)
class Request(db.Model): id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(50)) description = db.Column(db.Text) client_id = db.Column(db.Integer, db.ForeignKey('client.id')) priority = db.Column(db.Integer) target_date = db.Column(db.Date) product = db.Column(db.Enum(ProductEnum)) timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow) # def __repr__(self): # return '<Request %r>' % (self.client) def __repr__(self): return f"<Request(client='{self.client}', title='{self.title}', priority='{self.priority}')>"
class Needs(db.Model): __tablename__ = 'needs' id = db.Column(db.Integer, primary_key=True) text = db.Column(db.Text) done = db.Column(db.Boolean, default=False) group_id = db.Column(db.Integer, db.ForeignKey('groups.id')) who_posted = db.Column(db.Integer, db.ForeignKey('users.id')) def __init__(self, text, group_id): self.text = text self.group_id = group_id def __repr__(self): return f"Need {self.text} as soon as possible" def to_json(self): json_needs = { 'url': url_for('api.get_need', id=self.id, _external=True), 'text': self.text, 'done': self.done, 'group': url_for('api.get_group', id=self.group_id, _external=True), 'author': url_for('api.get_user', id=self.who_posted, _external=True) } return json_needs @staticmethod def from_json(json_need): description = json_need.get('text') group_id = json_need.get('group_id') return Needs(description, group_id)
class Rating(db.Model, CRUDMixin): __tablename__ = 'ratings' id = db.Column(db.Integer, primary_key=True) pos_weight = db.Column(db.Integer, nullable=False) nps_weight = db.Column(db.Integer, nullable=False) fz_weight = db.Column(db.Integer, nullable=False) refund_fz_weight = db.Column(db.Integer, nullable=False) sms_weight = db.Column(db.Integer, nullable=False) kr_weight = db.Column(db.Integer, nullable=False) box_weight = db.Column(db.Integer, nullable=False) ops_weight = db.Column(db.Integer, nullable=False) date = db.Column(db.DateTime, default=datetime.datetime.utcnow) user_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete='cascade'), nullable=False) employees = db.relationship('ArchiveCS', secondary='association', back_populates='rating_id', cascade="all,delete") def __repr__(self): return f'Рейтинг от {self.date}' @property def weight_serialize(self): return { 'pos_weight': self.pos_weight, 'nps_weight': self.nps_weight, 'fz_weight': self.fz_weight, 'refund_fz_weight': self.refund_fz_weight, 'sms_weight': self.sms_weight, 'kr_weight': self.kr_weight, 'box_weight': self.box_weight, 'ops_weight': self.ops_weight } @property def format_date_(self): if sys.platform == 'win32': locale.setlocale(locale.LC_ALL, 'rus_rus') else: locale.setlocale(locale.LC_ALL, 'ru_RU.UTF-8') format_ = datetime.datetime.strftime(self.date, '%d %B %Y') return format_
class Ingredient(db.Model): __tablename__ = 'ingredients' ing_id = db.Column(db.Integer, primary_key=True) ing_name = db.Column(db.String(12), unique=True, nullable=False) ing_fg_id = db.Column(db.Integer, db.ForeignKey('food_groups.fg_id'), nullable=False) ing_desc = db.Column(db.String(255), unique=False, nullable=True) ing_pic = db.Column(db.String(255), unique=False, nullable=True) food_group = db.relationship('Food_Group') attributes = db.relationship('Attribute', secondary=ing_att_assc) recipes = db.relationship('Recipe', secondary=ing_rec_assc) def __repr__(self): return '<Ingredient %r>' % self.ing_name def num_pos_attributes(self): """ Returns the number of postitive attributes belonging to the ingredient """ count = 0 for attr in self.attributes: if attr.att_pos_neg: count+=1 return count def num_neg_attributes(self): """ Returns the number of negative attributes belonging to the ingredient """ count = 0 for attr in self.attributes: if not attr.att_pos_neg: count+=1 return count def rendered_image(self): """ Wraps the image in HTML to be rendered in the table view later """ html = '<img src="'+self.ing_pic+ '"width="160" height="160" alt="'+self.ing_name+ '" title="'+self.ing_name+ '" >' return Markup(html)
class Schedules(db.Model): id = db.Column(db.Integer, primary_key=True) date = db.Column(db.Date(), index=True, unique=True) extra_info = db.Column(db.String(500)) speaker_id = db.Column(db.Integer, db.ForeignKey('users.id')) paper_id = db.Column(db.Integer, db.ForeignKey('papers.id'))
class User(db.Model, UserMixin): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(64), nullable=False, index=True, unique=True) email = db.Column(db.String(64), nullable=False, unique=True, index=True) password_hash = db.Column(db.String(128)) confirmed = db.Column(db.Boolean, default=False) profile_image = db.Column(db.String(128), nullable=False, default='default_profile_img.png') costs = db.relationship('Costs', backref='author', lazy=True) role_id = db.Column(db.Integer, db.ForeignKey('roles.id')) needs = db.relationship('Needs', backref='author', lazy=True) memberships = db.relationship('CostGroup', backref='user', lazy=True) def __init__(self, username, email, password): self.username = username self.email = email self.password_hash = generate_password_hash(password) if self.role is None: if self.email == current_app.config['COSTAPP_ADMIN']: self.role = Role.query.filter_by(name='Administrator').first() if self.role is None: self.role = Role.query.filter_by(default=True).first() def check_password(self, password): return check_password_hash(self.password_hash, password) def can(self, permissions): return self.role.permissions is not None and\ (self.role.permissions & permissions) == permissions def is_administrator(self): return self.can(Permission.ADMIN) def __repr__(self): return f"Name = {self.username} " def generate_confirmation_token(self, expiration=3600): s = Serializer(current_app.config['SECRET_KEY'], expiration) return s.dumps({'confirm': self.id}) def confirm(self, token): s = Serializer(current_app.config['SECRET_KEY']) try: data = s.loads(token) except: return False if data.get('confirm') != self.id: return False self.confirmed = True db.session.commit() return True def generate_reset_token(self, expiration=3600): s = Serializer(current_app.config['SECRET_KEY'], expiration) return s.dumps({'reset': self.id}) def to_json(self): user_json = { 'url': url_for('api.get_user', id=self.id, _external=True), 'username': self.username, 'role': self.role.name, 'groups': url_for('api.get_user_groups', id=self.id, _external=True) } return user_json def generate_auth_token(self, expiration): s = Serializer(current_app.config['SECRET_KEY'], expires_in=expiration) return s.dumps({'id': self.id}).decode('ascii') @staticmethod def verify_auth_token(token): s = Serializer(current_app.config['SECRET_KEY']) try: data = s.loads(token) except: return None return User.query.get(data['id']) @staticmethod def from_json(user_json): username = user_json.get('username') email = user_json.get('email') password_hash = generate_password_hash(user_json.get('password')) return User(username, email, password_hash)
import re from secrets import token_urlsafe from datetime import datetime from flask_login import UserMixin from werkzeug.security import generate_password_hash, check_password_hash from main_app import db, login access_table = db.Table( 'access_table', db.Column('access_token', db.String, db.ForeignKey('users.access_token')), db.Column('service_id', db.Integer, db.ForeignKey('services.id'))) class MasterKey(db.Model): __tablename__ = 'master_keys' token = db.Column(db.String(120), primary_key=True) class Service(db.Model): __tablename__ = 'services' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(32), index=True, unique=True) base_url = db.Column(db.String(64), index=True, unique=True) description = db.Column(db.String(256)) internal = db.Column(db.Boolean, default=True, nullable=False) @property def help_url(self): return self.base_url + "/help"
from datetime import datetime from main_app import db, login from werkzeug.security import generate_password_hash, check_password_hash from flask_login import UserMixin from hashlib import md5 @login.user_loader def load_user(id): return User.query.get(int(id)) followers = db.Table( 'followers', db.Column('follower_id', db.Integer, db.ForeignKey('user.id')), db.Column('followed_id', db.Integer, db.ForeignKey('user.id'))) class User(UserMixin, db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(64), index=True, unique=True) email = db.Column(db.String(128), index=True, unique=True) password_hash = db.Column(db.String(128)) posts = db.relationship('Post', backref='author', lazy='dynamic') about_me = db.Column(db.String(140)) last_seen = db.Column(db.DateTime, default=datetime.utcnow) followed = db.relationship('User', secondary=followers, primaryjoin=(followers.c.follower_id == id), secondaryjoin=(followers.c.followed_id == id),
class ArchiveCS(db.Model, CRUDMixin): __tablename__ = 'archive_employees' id = db.Column(db.Integer, primary_key=True) first_name = db.Column(db.String(100), unique=False, index=True) last_name = db.Column(db.String(100), unique=False, index=True) middle_name = db.Column(db.String(100), unique=False, index=True) pos_plan = db.Column(db.Integer, nullable=False) pos_fact = db.Column(db.Integer, nullable=False) nps_plan = db.Column(db.Float, nullable=False) nps_fact = db.Column(db.Float, nullable=False) refund_fz = db.Column(db.Boolean, nullable=False) fz_plan = db.Column(db.Float, nullable=False) fz_fact = db.Column(db.Float, nullable=False) sms_plan = db.Column(db.Float, nullable=False) sms_fact = db.Column(db.Float, nullable=False) kr_plan = db.Column(db.Integer, nullable=False) kr_fact = db.Column(db.Integer, nullable=False) box_plan = db.Column(db.Integer, nullable=False) box_fact = db.Column(db.Integer, nullable=False) ops_plan = db.Column(db.Integer, nullable=False) ops_fact = db.Column(db.Integer, nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete='cascade'), nullable=False) rating_id = db.relationship('Rating', secondary='association', back_populates='employees', cascade="all,delete") @property def pos_ratio(self): if self.pos_plan == 0: return 100 else: return round(100 * self.pos_fact / self.pos_plan, 2) @property def nps_ratio(self): if self.nps_plan == 0: return 100 else: return round(100 * self.nps_fact / self.nps_plan, 2) @property def refund_fz_ratio(self): if self.refund_fz is False: return 100 else: return 0 @property def fz_ratio(self): if self.fz_plan == 0: return 100 else: return round(100 * self.fz_fact / self.fz_plan, 2) @property def sms_ratio(self): if self.sms_plan == 0: return 100 else: return round(100 * self.sms_fact / self.sms_plan, 2) @property def kr_ratio(self): if self.kr_plan == 0: return 100 else: return round(100 * self.kr_fact / self.kr_plan, 2) @property def box_ratio(self): if self.box_plan == 0: return 100 else: return round(100 * self.box_fact / self.box_plan, 2) @property def ops_ratio(self): if self.ops_plan == 0: return 100 else: return round(100 * self.ops_fact / self.ops_plan, 2) @property def fio(self): return f'{self.last_name} {self.first_name} {self.middle_name}' def __repr__(self): return f'{self.last_name} {self.first_name} {self.middle_name}' def pretty_format(self, num): locale.setlocale(locale.LC_ALL, '') locale._override_localeconv = {'mon_thousands_sep': ' '} return locale.format('%.0f', num, grouping=True) def total_ratio(self, **kwargs): pos_weight = kwargs.get('pos_weight') nps_weight = kwargs.get('nps_weight') fz_weight = kwargs.get('fz_weight') refund_fz_weight = kwargs.get('refund_fz_weight') sms_weight = kwargs.get('sms_weight') kr_weight = kwargs.get('kr_weight') box_weight = kwargs.get('box_weight') ops_weight = kwargs.get('ops_weight') ratio = self.pos_ratio*pos_weight+self.nps_ratio*nps_weight+\ self.fz_ratio*fz_weight+self.refund_fz_ratio*refund_fz_weight+\ self.sms_ratio*sms_weight+self.kr_ratio*kr_weight+\ self.box_ratio*box_weight+self.ops_ratio*ops_weight ratio = round(ratio / 100, 2) return ratio
class CS(db.Model, CRUDMixin): __tablename__ = 'employees' id = db.Column(db.Integer, primary_key=True) first_name = db.Column(db.String(100), unique=False, index=True) last_name = db.Column(db.String(100), unique=False, index=True) middle_name = db.Column(db.String(100), unique=False, index=True) pos_plan = db.Column(db.Integer, nullable=False) pos_fact = db.Column(db.Integer, nullable=False) nps_plan = db.Column(db.Float, nullable=False) nps_fact = db.Column(db.Float, nullable=False) refund_fz = db.Column(db.Boolean, nullable=False) fz_plan = db.Column(db.Float, nullable=False) fz_fact = db.Column(db.Float, nullable=False) sms_plan = db.Column(db.Float, nullable=False) sms_fact = db.Column(db.Float, nullable=False) kr_plan = db.Column(db.Integer, nullable=False) kr_fact = db.Column(db.Integer, nullable=False) box_plan = db.Column(db.Integer, nullable=False) box_fact = db.Column(db.Integer, nullable=False) ops_plan = db.Column(db.Integer, nullable=False) ops_fact = db.Column(db.Integer, nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete='cascade'), nullable=False) def __repr__(self): return f'{self.last_name} {self.first_name} {self.middle_name}' @property def fio(self): return f'{self.last_name} {self.first_name} {self.middle_name}' @property def serialize(self): return { 'first_name': self.first_name, 'last_name': self.last_name, 'middle_name': self.middle_name, 'pos_plan': self.pos_plan, 'pos_fact': self.pos_fact, 'nps_plan': self.nps_plan, 'nps_fact': self.nps_fact, 'refund_fz': self.refund_fz, 'fz_plan': self.fz_plan, 'fz_fact': self.fz_fact, 'sms_plan': self.sms_plan, 'sms_fact': self.sms_fact, 'kr_plan': self.kr_plan, 'kr_fact': self.kr_fact, 'box_plan': self.box_plan, 'box_fact': self.box_fact, 'ops_plan': self.ops_plan, 'ops_fact': self.ops_fact, 'user_id': self.user_id } def pretty_format(self, num): locale.setlocale(locale.LC_ALL, '') locale._override_localeconv = {'mon_thousands_sep': ' '} return locale.format('%.0f', num, grouping=True)
""" List of all the association tables in the database, references within the classes they belong to in the association object """ # pylint: disable=maybe-no-member from main_app import db ing_att_assc = db.Table( 'ing_att_assc', db.metadata, db.Column('ing_id', db.Integer, db.ForeignKey('ingredients.ing_id')), db.Column('att_id', db.Integer, db.ForeignKey('attributes.att_id'))) ing_rec_assc = db.Table( 'ing_rec_assc', db.metadata, db.Column('ing_id', db.Integer, db.ForeignKey('ingredients.ing_id')), db.Column('rec_id', db.Integer, db.ForeignKey('recipes.id')))