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')))