class Role(db.Model):
"""Hold Role Details."""
__tablename__ = 'sec_roles'
role_id = db.Column(db.Integer, primary_key=True)
role_name = db.Column(db.String(50), nullable=False, unique=True)
role_description = db.Column(db.String(255), nullable=False)
users = db.relationship('User', secondary='sec_users_roles',
backref=db.backref('users', lazy='dynamic'))
menus = db.relationship('navigation.models.Menu',
secondary='nav_roles_menus',
backref=db.backref('roles', lazy='dynamic'))
is_active = db.Column(db.Boolean(), nullable=False, server_default='1')
created_by = db.Column(db.Integer)
created_datetime = db.Column(db.DateTime, default=datetime.now())
modified_by = db.Column(db.Integer)
last_modified_datetime = db.Column(db.DateTime, nullable=True)
is_default = db.Column(db.Boolean(), default=False)
def __init__(self, role_name, role_description, created_by):
"""Create a new role."""
self.role_name = role_name
self.role_description = role_description
self.created_by = created_by
self.created_datetime = datetime.now()
def __repr__(self):
"""Represent an instance of the class."""
return self.role_name
class School(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), unique=True)
slug = db.Column(db.String(120), index=True)
domains = db.Column(JSON, default=[])
is_demo = db.Column(db.Boolean(), default=False)
redeem_prize_email = db.Column(db.String(120))
launchable = db.Column(db.Boolean(), default=True)
is_destroyed = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def __init__(self,
name,
domains=[],
is_demo=False,
redeem_prize_email=None,
launchable=True):
self.name = name
self.slug = slugify(name, separator='-', to_lower=True)
self.domains = domains
self.is_demo = is_demo
self.redeem_prize_email = redeem_prize_email
self.launchable = launchable
def __repr__(self):
return '<School id={}, name={}, slug={}, domains={}, is_demo={}, redeem_prize_email={}, launchable={}, is_destroyed={}, created_at={}>'.format(
self.id, self.name, self.slug, self.domains, self.is_demo,
self.redeem_prize_email, self.launchable, self.is_destroyed,
self.created_at)
def active_users(self):
return [u for u in self.users if not u.is_destroyed]
def active_challenges(self):
return [c for c in self.challenges if not c.is_destroyed]
class RoleMenu(db.Model):
"""Hold the Role Menu Details."""
__tablename__ = 'nav_roles_menus'
role_menu_id = db.Column(db.Integer, primary_key=True)
menu_id = db.Column(db.Integer, db.ForeignKey('nav_menus.menu_id'),
nullable=False, primary_key=True)
role_id = db.Column(db.Integer, db.ForeignKey('sec_roles.role_id'),
nullable=False, primary_key=True)
can_view = db.Column(db.Boolean(), nullable=False, server_default='True')
can_create = db.Column(db.Boolean(), nullable=False, server_default='0')
can_edit = db.Column(db.Boolean(), nullable=False, server_default='0')
can_delete = db.Column(db.Boolean(), nullable=False, server_default='0')
is_active = db.Column(db.Boolean(), nullable=False, server_default='True')
created_by = db.Column(db.Integer)
created_datetime = db.Column(db.DateTime, default=datetime.now())
modified_by = db.Column(db.Integer)
last_modified_datetime = db.Column(db.DateTime, nullable=True)
def __init__(self, menu_id, role_id, created_by):
"""Create a new role menu combination."""
self.menu_id = menu_id
self.role_id = role_id
self.created_by = created_by
self.created_datetime = datetime.now()
self.can_view = True
class DeviceModel(ModelBase):
__tablename__ = 'devices'
uuid = db.Column(db.String(80), primary_key=True, nullable=False)
network_uuid = db.Column(db.String,
db.ForeignKey('networks.uuid'),
nullable=False)
name = db.Column(db.String(80), nullable=False)
enable = db.Column(db.Boolean(), nullable=False)
fault = db.Column(db.Boolean(), nullable=True)
history_enable = db.Column(db.Boolean(), nullable=False, default=False)
tags = db.Column(db.String(320), nullable=True)
points = db.relationship('PointModel',
cascade="all,delete",
backref='device',
lazy=True)
__table_args__ = (UniqueConstraint('name', 'network_uuid'), )
def __repr__(self):
return f"Device(uuid = {self.uuid})"
@validates('tags')
def validate_tags(self, _, value):
"""
Rules for tags:
- force all tags to be lower case
- if there is a gap add an underscore
- no special characters
"""
if value is not None:
try:
return validate_json(value)
except ValueError:
raise ValueError('tags needs to be a valid JSON')
return value
@validates('name')
def validate_name(self, _, value):
if not re.match("^([A-Za-z0-9_-])+$", value):
raise ValueError(
"name should be alphanumeric and can contain '_', '-'")
return value
@classmethod
def find_by_name(cls, network_name: str, device_name: str):
results = cls.query.filter_by(name=device_name) \
.join(NetworkModel).filter_by(name=network_name) \
.first()
return results
def set_fault(self, is_fault: bool):
self.fault = is_fault
db.session.commit()
class User(db.Model, BaseMixin, UserMixin, ReprMixin):
email = db.Column(db.String(127), unique=True, nullable=False)
password = db.Column(db.String(255), default='', nullable=False)
name = db.Column(db.String(127), nullable=True)
mobile_number = db.Column(db.String(20), unique=True, nullable=False)
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(45))
current_login_ip = db.Column(db.String(45))
login_count = db.Column(db.Integer)
roles = db.relationship('Role', back_populates='users', secondary='user_role')
retail_shops = db.relationship('RetailShop', back_populates='users', secondary='user_retail_shop', lazy='dynamic')
@hybrid_property
def name(self):
return '{0}'.format(self.user_profile.first_name) + (' {0}'.format(self.user_profile.last_name)) \
if self.user_profile.first_name else ''
@hybrid_property
def retail_shop_ids(self):
return [i[0] for i in self.retail_shops.with_entities(RetailShop.id).all()]
@hybrid_property
def brand_ids(self):
return set([i[0] for i in self.retail_shops.with_entities(RetailShop.retail_brand_id).all()])
class Menu(db.Model):
"""Hold Navigation Menu details."""
__tablename__ = 'nav_menus'
menu_id = db.Column(db.Integer, primary_key=True)
menu_url = db.Column(db.String(80), nullable=False, unique=True)
menu_name = db.Column(db.String(80), nullable=False, unique=True)
menu_text = db.Column(db.Text, nullable=False)
menu_roles = db.relationship('users.models.Role',
secondary='nav_roles_menus',
backref=db.backref('menus_roles',
lazy='dynamic'))
is_active = db.Column(db.Boolean(), nullable=False, server_default='1')
created_datetime = db.Column(db.DateTime, default=datetime.now())
created_by = db.Column(db.Integer)
last_modified_datetime = db.Column(db.DateTime, nullable=True)
modified_by = db.Column(db.Integer)
def __init__(self, menu_name, menu_url, menu_text, created_by):
"""Set up a new menu url."""
self.menu_url = menu_url
self.menu_name = menu_name
self.menu_text = menu_text
self.is_active = True
self.created_datetime = datetime.now()
self.confirmation_sent_at = self.created_datetime
self.created_by = created_by
def __repr__(self):
"""Represent an instance of the class."""
return self.menu_name
class Customer(BaseMixin, db.Model, ReprMixin):
email = db.Column(db.String(55), nullable=True)
name = db.Column(db.String(55), nullable=False)
active = db.Column(db.Boolean())
number = db.Column(db.String(20), nullable=False)
loyalty_points = db.Column(db.Integer, default=0)
organisation_id = db.Column(db.ForeignKey('organisation.id'), index=True)
organisation = db.relationship('Organisation',
foreign_keys=[organisation_id])
addresses = db.relationship('Address', secondary='customer_address')
orders = db.relationship('Order', uselist=True, lazy='dynamic')
transactions = db.relationship('CustomerTransaction',
uselist=True,
lazy='dynamic')
UniqueConstraint(number, name, organisation_id)
@hybrid_property
def total_orders(self):
return self.orders.with_entities(func.coalesce(func.Count(Order.id),
0)).scalar()
@hybrid_property
def total_billing(self):
return self.orders.with_entities(
func.coalesce(func.Sum(Order.total), 0)).scalar()
@hybrid_property
def amount_due(self):
return self.orders.with_entities(func.coalesce(func.Sum(Order.total), 0) -
func.coalesce(func.Sum(Order.amount_paid), 0)).scalar() - \
self.transactions.with_entities(func.coalesce(func.Sum(CustomerTransaction.amount), 0)).scalar()
class User(db.Model, BaseMixin, ReprMixin, UserMixin):
__repr_fields__ = ['id', 'username', 'email', 'mobile_number', 'roles']
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(40), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
mobile_number = db.Column(db.String(20),
unique=True,
nullable=False,
index=True)
password = db.Column(db.String(60), nullable=False)
where_from = db.Column(db.String(20), nullable=False)
where_to = db.Column(db.String(20), nullable=False)
previous_salary = db.Column(db.Integer, nullable=False)
expected_salary = db.Column(db.Integer, nullable=False)
active = db.Column(db.Boolean(), default=False)
confirmed_at = db.Column(db.DateTime(), default=datetime.utcnow)
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(45))
current_login_ip = db.Column(db.String(45))
login_count = db.Column(db.Integer)
roles = db.relationship('Role',
back_populates='users',
secondary='user_role')
class User(db.Model):
__tablename__ = 'users'
# __table_args__ = (
# db.ForeignKeyConstraint(
# ["person_id"],
# ["person.id"],
# ),
# )
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
person_id = db.Column(db.Integer, db.ForeignKey('person.id'), nullable=False)
username = db.Column(db.String(40), nullable=False, unique=True, index=True)
password = db.Column(db.String(128), nullable=False)
is_admin = db.Column(db.Boolean())
creation_date = db.Column(db.DateTime(), nullable=False, default=datetime.datetime.utcnow())
modification_date = db.Column(db.DateTime(), nullable=False, default=datetime.datetime.utcnow())
userProfileSystem = db.relationship("UserProfileSystem", back_populates="users")
person = db.relationship("Person", back_populates="users")
def __init__(self, username, password, is_admin, person_id):
bcrypt = Bcrypt(current_app)
self.username = username
self.password = bcrypt.generate_password_hash(password).decode('utf-8')
self.is_admin = is_admin
self.person_id = person_id
def compare_password(self, password):
bcrypt = Bcrypt(current_app)
return bcrypt.check_password_hash(self.password, password)
def __repr__(self):
return f'<User: {self.username}'
class Winner(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
index=True,
nullable=False)
user = db.relationship('User', backref='winners')
prize_id = db.Column(db.Integer,
db.ForeignKey('prize.id'),
index=True,
nullable=False)
prize = db.relationship('Prize', backref='winners')
is_destroyed = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def __init__(self, user=None, prize=None, prize_id=None):
if prize_id:
self.prize_id = prize_id
else:
self.prize = prize
self.user = user
def __repr__(self):
return '<Winner id={}, user_id={}, prize_id={}, is_destroyed={}, created_at={}>'.format(
self.id, self.user_id, self.prize_id, self.is_destroyed,
self.created_at)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
login = db.Column(db.String(120), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
path_to_img = db.Column(db.String(255), unique=True, nullable=True)
active = db.Column(db.Boolean(), nullable=False, default=False)
first_name = db.Column(db.String(100), unique=False, nullable=True)
last_name = db.Column(db.String(100), unique=False, nullable=True)
registration_date = db.Column(db.DATE, unique=False, nullable=False)
roles = db.relationship('Role',
secondary=user_role,
lazy=False,
backref=db.backref('users', lazy=True))
result = db.relationship('Result', backref='user', lazy=True)
courses = db.relationship('Course',
secondary=user_course,
lazy=False,
backref=db.backref('courses', lazy=True))
created_courses = db.relationship('Course',
secondary=user_create_course,
lazy=False,
backref=db.backref('created_courses',
lazy=True))
class Prize(db.Model):
id = db.Column(db.Integer, primary_key=True)
challenge_id = db.Column(db.Integer,
db.ForeignKey('challenge.id'),
index=True,
nullable=False)
challenge = db.relationship('Challenge', backref='prizes')
sponsor_id = db.Column(db.Integer,
db.ForeignKey('sponsor.id'),
index=True,
nullable=False)
sponsor = db.relationship('Sponsor', backref='prizes')
name = db.Column(db.String(240), nullable=False)
count = db.Column(db.Integer, default=1)
is_destroyed = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def __init__(self, challenge, sponsor, name, count):
self.challenge = challenge
self.sponsor = sponsor
self.name = name
self.count = count
def __repr__(self):
return '<Prize id={}, challenge_id={}, sponsor_id={}, count={} is_destroyed={}, created_at={}>'.format(
self.id, self.challenge_id, self.sponsor_id, self.count,
self.is_destroyed, self.created_at)
class CheckInAnswer(db.Model):
id = db.Column(db.Integer, primary_key=True)
check_in_question_id = db.Column(db.Integer,
db.ForeignKey('check_in_question.id'),
index=True,
nullable=False)
check_in_question = db.relationship('CheckInQuestion',
backref='check_in_answers')
user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
index=True,
nullable=False)
user = db.relationship('User', backref='check_in_answers')
text = db.Column(db.Text(), nullable=False)
is_destroyed = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def __init__(self,
user,
text,
check_in_question=None,
check_in_question_id=None):
if check_in_question_id:
self.check_in_question_id = check_in_question_id
else:
self.check_in_question = check_in_question
self.user = user
self.text = text
def __repr__(self):
return '<CheckInAnswer id={}, check_in_question_id={}, user_id={}, is_destroyed={}, created_at={}>'.format(
self.id, self.check_in_question_id, self.user_id,
self.is_destroyed, self.created_at)
class Rider(BaseMixin, ReprMixin, UserMixin, db.Model):
__repr_fields__ = ['id', 'first_name']
email = db.Column(db.String(127), unique=True, nullable=True, index=True)
password = db.Column(db.String(255), nullable=True)
first_name = db.Column(db.String(55), nullable=False)
last_name = db.Column(db.String(55), nullable=True)
mobile_number = db.Column(db.String(20),
unique=True,
nullable=False,
index=True)
company_name = db.Column(db.String(55), nullable=True)
counter = db.Column(db.Integer, nullable=True, default=0)
picture = db.Column(db.Text(), nullable=True, index=True)
active = db.Column(db.Boolean(), default=False)
confirmed_at = db.Column(db.DateTime(), default=datetime.utcnow)
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(45))
current_login_ip = db.Column(db.String(45))
login_count = db.Column(db.Integer)
device_limit = db.Column(db.Integer, nullable=True, default=0)
devices = db.relationship('Device',
back_populates='riders',
secondary='rider_device')
class User(BaseMixin, db.Model, UserMixin, ReprMixin):
email = db.Column(db.String(127), unique=True, nullable=False)
password = db.Column(db.String(255), default='', nullable=False)
username = db.Column(db.String(127), nullable=True)
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(45))
current_login_ip = db.Column(db.String(45))
login_count = db.Column(db.Integer)
roles = db.relationship('Role',
back_populates='users',
secondary='user_role')
permissions = db.relationship('Permission',
back_populates='users',
secondary='user_permission')
user_profile = db.relationship("UserProfile",
uselist=False,
back_populates="user",
cascade='all, delete-orphan',
lazy='subquery')
def has_permission(self, permission):
if isinstance(permission, str):
return permission in (permission.name
for permission in self.permissions)
else:
return permission in self.permissions
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), unique=True, nullable=False)
email = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(254), nullable=False)
is_admin = db.Column(db.Boolean(), default=False)
uuid = db.Column(db.String(36), unique=True)
def __init__(self, name, email, password, is_admin=False):
self.name = name
self.email = email
self.password = generate_password_hash(password)
self.is_admin = is_admin
self.uuid = str(uuid.uuid4())
def __repr__(self):
return f'User({self.username}, {self.email}, {self.uuid})'
@classmethod
def find_by_name(cls, name):
return cls.query().filter_by(name=name).first()
@classmethod
def find_by_uuid(cls, uuid):
return cls.query().filter_by(uuid=uuid).first()
class Order(BaseMixin, db.Model, ReprMixin):
__repr_fields__ = ['id', 'customer_id']
edit_stock = db.Column(db.Boolean(), default=True)
sub_total = db.Column(db.Float(precision=2), default=0, nullable=True)
total = db.Column(db.Float(precision=2), default=0, nullable=True)
amount_paid = db.Column(db.Float(precision=2), default=0, nullable=True)
auto_discount = db.Column(db.Float(precision=2), default=0, nullable=True)
is_void = db.Column(db.Boolean(), default=False)
invoice_number = db.Column(db.Integer)
reference_number = db.Column(db.String(12), nullable=True)
customer_id = db.Column(UUID, db.ForeignKey('customer.id'), nullable=True, index=True)
user_id = db.Column(UUID, db.ForeignKey('user.id'), nullable=False, index=True)
address_id = db.Column(UUID, db.ForeignKey('address.id'), nullable=True, index=True)
retail_shop_id = db.Column(UUID, db.ForeignKey('retail_shop.id'), nullable=False, index=True)
current_status_id = db.Column(UUID, db.ForeignKey('status.id'), nullable=True, index=True)
items = db.relationship('Item', uselist=True, back_populates='order', lazy='dynamic', cascade="all, delete-orphan")
customer = db.relationship('Customer', foreign_keys=[customer_id])
created_by = db.relationship('User', foreign_keys=[user_id])
address = db.relationship('Address', foreign_keys=[address_id])
retail_shop = db.relationship('RetailShop', foreign_keys=[retail_shop_id])
discounts = db.relationship('Discount', secondary='order_discount', uselist=True)
denominations = db.relationship('Denomination', secondary='order_denomination', uselist=False)
current_status = db.relationship('Status', uselist=False, foreign_keys=[current_status_id])
time_line = db.relationship('Status', secondary='order_status')
@hybrid_property
def total_discount(self):
return sum([discount.value if discount.type == 'VALUE' else float(self.total*discount/100)
for discount in self.discounts])
@hybrid_property
def items_count(self):
return self.items.with_entities(func.Count(Item.id)).scalar()
@items_count.expression
def items_count(cls):
return select([func.Count(Item.id)]).where(Item.order_id == cls.id).as_scalar()
@hybrid_property
def amount_due(self):
if self.total and self.amount_paid:
return self.total - self.amount_paid
return self.total
class Role(BaseMixin, RoleMixin, ReprMixin, db.Model):
name = db.Column(db.String(80), unique=True, index=True)
description = db.Column(db.String(255))
is_hidden = db.Column(db.Boolean(), default=False, index=True)
users = db.relationship('User',
back_populates='roles',
secondary='user_role')
class User(BaseMixin, UserMixin, ReprMixin, db.Model):
email = db.Column(db.String(127), unique=True, nullable=False)
password = db.Column(db.String(255), default='', nullable=False)
name = db.Column(db.String(55), nullable=False)
mobile_number = db.Column(db.String(20), unique=True, nullable=False)
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(45))
current_login_ip = db.Column(db.String(45))
login_count = db.Column(db.Integer)
organisation_id = db.Column(db.ForeignKey('organisation.id'), index=True)
organisation = db.relationship('Organisation',
foreign_keys=[organisation_id],
back_populates='users')
roles = db.relationship('Role',
back_populates='users',
secondary='user_role')
permissions = db.relationship('Permission',
back_populates='users',
secondary='user_permission',
lazy='dynamic')
stores = db.relationship('Store',
back_populates='users',
secondary='user_store',
lazy='dynamic')
@hybrid_property
def store_ids(self):
return [i[0] for i in self.stores.with_entities(Store.id).all()]
@store_ids.expression
def store_ids(self):
return select([
UserStore.store_id
]).where(UserStore.user_id == self.id).label('store_ids').limit(1)
@hybrid_method
def has_shop_access(self, shop_id):
return db.session.query(
UserStore.query.filter(
UserStore.store_id == shop_id,
UserStore.user_id == self.id).exists()).scalar()
@hybrid_method
def has_permission(self, permission):
return db.session.query(
self.permissions.filter(
Permission.name == permission).exists()).scalar()
@hybrid_property
def is_owner(self):
return self.has_role('owner')
class Product(BaseMixin, db.Model, ReprMixin):
name = db.Column(db.String(127), unique=True, nullable=False, index=True)
description = db.Column(db.JSON(), nullable=True)
sub_description = db.Column(db.Text(), nullable=True)
is_disabled = db.Column(db.Boolean(), default=False)
url = db.Column(db.Text())
drug_schedule = db.Column(db.String(55))
drug_type = db.Column(db.String(55))
dosage = db.Column(db.String(55))
formulation_types = db.Column(db.String(55))
price = db.Column(NUMERIC(8, 2), default=0)
prescription_required = db.Column(db.Boolean(), default=False)
therapeutic_name = db.Column(db.String(255), nullable=True)
is_loose = db.Column(db.Boolean(), default=False)
barcode = db.Column(db.String(13), nullable=True, unique=True)
brand_id = db.Column(db.ForeignKey('brand.id'), index=True, nullable=False)
taxes = db.relationship('Tax', back_populates='products', secondary='product_tax')
tags = db.relationship('Tag', back_populates='products', secondary='product_tag')
brand = db.relationship('Brand', foreign_keys=[brand_id], uselist=False, back_populates='products')
stocks = db.relationship('Stock', uselist=True, cascade="all, delete-orphan", lazy='dynamic')
# distributors = db.relationship('Distributor', back_populates='products', secondary='product_distributor')
combos = db.relationship('Combo', back_populates='products', secondary='combo_product', lazy='dynamic')
salts = db.relationship('Salt', back_populates='products', secondary='product_salt', lazy='dynamic')
product_salts = db.relationship('ProductSalt', lazy='dynamic', back_populates='product')
@hybrid_property
def short_code(self):
return re.sub(r'[AEIOU ]', '', self.name, flags=re.IGNORECASE)[:5]
@hybrid_property
def brand_name(self):
return self.brand.name
@brand_name.expression
def brand_name(self):
return select([Brand.name]).where(Brand.id == self.brand_id).as_scalar()
class Project(db.Model):
__tablename__ = 'Projects'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(100), nullable=False, unique=True)
description = db.Column(db.String(100), nullable=False)
completed = db.Column(db.Boolean(), default=False)
user_stories = db.Column(db.String(100), nullable=True)
actions = db.relationship('Action', backref='Users')
class PointStoreModelMixin(object):
value = db.Column(db.Float(), nullable=True)
value_original = db.Column(db.Float(), nullable=True)
value_raw = db.Column(db.String(), nullable=True)
fault = db.Column(db.Boolean(), default=False, nullable=False)
fault_message = db.Column(db.String())
ts = db.Column(db.DateTime,
server_default=db.func.now(),
onupdate=db.func.now())
class Chat(db.Model, BaseMixin):
sender_id = db.Column(db.Integer, db.ForeignKey('user.id'))
receiver_id = db.Column(db.Integer, db.ForeignKey('user.id'))
message = db.Column(db.Text(), nullable=False, default='')
is_read = db.Column(db.Boolean(False))
read_on = db.Column(db.TIMESTAMP, default=None)
sender = db.relationship('User', lazy='subquery', foreign_keys=[sender_id])
receiver = db.relationship('User', lazy='subquery', foreign_keys=[receiver_id])
class DgfObject(db.Model):
""" Data gouv fr objects Model """
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
suspicious = db.Column(db.Boolean())
read = db.Column(db.Boolean())
deleted = db.Column(db.Boolean())
dgf_type = db.Column(
db.Enum('user',
'community_resource',
'organization',
'dataset',
'reuse',
name='dgf_type'))
dgf_id = db.Column(db.String(255), nullable=False)
comments = db.relationship('Comment', backref='dgf_object', lazy='dynamic')
def __repr__(self):
return f"<Dgf {self.dgf_type} with id {self.dgf_id}>"
class PointStoreModelMixin(db.Model):
__abstract__ = True
value = db.Column(db.Float(), nullable=True)
value_original = db.Column(db.Float(), nullable=True)
value_raw = db.Column(db.String(), nullable=True)
fault = db.Column(db.Boolean(), default=False, nullable=False)
fault_message = db.Column(db.String())
ts_value = db.Column(db.DateTime())
ts_fault = db.Column(db.DateTime())
class User(BaseMixin, ReprMixin, UserMixin, db.Model):
__repr_fields__ = ['id', 'first_name']
email = db.Column(db.String(127), unique=True, nullable=True, index=True)
password = db.Column(db.String(255), nullable=True)
first_name = db.Column(db.String(55), nullable=False)
last_name = db.Column(db.String(55), nullable=True)
mobile_number = db.Column(db.String(20),
unique=True,
nullable=False,
index=True)
business_name = db.Column(db.String(55), nullable=True)
counter = db.Column(db.Integer, nullable=True, default=0)
#picture = db.Column(db.Text(), nullable=True, index=True)
active = db.Column(db.Boolean(), default=False)
confirmed_at = db.Column(db.DateTime(), default=datetime.utcnow)
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(45))
current_login_ip = db.Column(db.String(45))
login_count = db.Column(db.Integer)
parent_id = db.Column(db.ForeignKey('user.id'), nullable=True)
parent = db.relationship('User',
foreign_keys=[parent_id],
uselist=False,
remote_side='User.id')
children = db.relationship(
'User',
remote_side='User.parent_id',
lazy='dynamic',
order_by="User.first_name",
)
roles = db.relationship('Role',
back_populates='users',
secondary='user_role')
devices = db.relationship('Device',
back_populates='users',
secondary='user_device')
@hybrid_property
def get_children_list(self):
beginning_getter = User.query.with_entities(User.id) \
.filter(User.id == self.id).cte(name='children_for', recursive=True)
with_recursive = beginning_getter.union_all(
User.query.with_entities(
User.id).filter(User.parent_id == beginning_getter.c.id))
return [i[0] for i in db.session.query(with_recursive).all()]
@hybrid_property
def get_immediate_children_list(self):
return [i[0] for i in self.children.with_entities(User.id).all()]
class Item(BaseMixin, db.Model, ReprMixin):
__repr_fields__ = ['id', 'order_id', 'product_id']
name = db.Column(db.String(55))
unit_price = db.Column(db.Float(precision=2))
quantity = db.Column(db.Float(precision=2))
discount = db.Column(db.FLOAT(precision=2), default=0, nullable=False)
stock_adjust = db.Column(db.Boolean(), default=False)
order_id = db.Column(db.ForeignKey('order.id'), nullable=True, index=True)
stock_id = db.Column(db.ForeignKey('stock.id'), nullable=True, index=True)
order = db.relationship('Order',
foreign_keys=[order_id],
single_parent=True,
back_populates='items',
cascade="all, delete-orphan")
taxes = db.relationship('ItemTax',
uselist=True,
cascade='all, delete-orphan',
back_populates='item')
stock = db.relationship('Stock',
foreign_keys=[stock_id],
single_parent=True,
back_populates='order_items')
@hybrid_property
def total_price(self):
return float(self.unit_price * self.quantity)
@hybrid_property
def discounted_total_price(self):
return float(self.discounted_unit_price * self.quantity)
@hybrid_property
def discounted_unit_price(self):
return float(self.unit_price - (self.unit_price * self.discount) / 100)
@hybrid_property
def discount_amount(self):
return float((self.total_price * self.discount) / 100)
@hybrid_property
def is_combo(self):
return self.combo_id is not None
@hybrid_property
def store_id(self):
return self.order.store_id
@store_id.expression
def store_id(self):
return select([Order.store_id
]).where(Order.id == self.order_id).as_scalar()
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
firstName = db.Column(db.String(128), nullable=False)
lastName = db.Column(db.String(128), nullable=False)
username = db.Column(db.String(128), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
isActive = db.Column(db.Boolean(), default=False, nullable=False)
def __init__(self, username, email, firstName, lastName, password):
self.username = username
self.email = email
self.firstName = firstName
self.lastName = lastName
self.password = bcrypt.generate_password_hash(password).decode()
def convert_json(self):
return {
"id": self.id,
"username": self.username,
"email": self.email,
"firstName": self.firstName,
"lastName": self.lastName,
"isActive": self.isActive
}
def encode_auth_token(self):
try:
payload = {
'exp':
datetime.datetime.utcnow() + datetime.timedelta(
days=current_app.config.get('TOKEN_EXPIRATION_DAYS'),
seconds=current_app.config.get(
'TOKEN_EXPIRATION_SECONDS')),
'iat':
datetime.datetime.utcnow(),
'sub':
self.id
}
return jwt.encode(payload,
current_app.config.get('SECRET_KEY'),
algorithm='HS256')
except Exception as e:
return e
@staticmethod
def decode_auth_token(token):
try:
payload = jwt.decode(token, current_app.config.get('SECRET_KEY'))
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired.'
except jwt.InvalidTokenError:
return 'Invalid token.'
class User(db.Model):
# TODO: combine email_verification_sent and email_verified into one Integer "status" column
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), index=True, unique=True)
name = db.Column(db.String(120), nullable=False)
hashed_pw = db.Column(db.String(120), nullable=True)
gender = db.Column(db.String(120), nullable=True)
age = db.Column(db.Integer, nullable=True)
email_verified = db.Column(db.Boolean(), default=False)
email_verification_secret = db.Column(db.String(64))
email_verification_sent = db.Column(db.Boolean(), default=False)
school_id = db.Column(db.Integer,
db.ForeignKey('school.id'),
index=True,
nullable=False)
school = db.relationship('School', backref='users')
is_admin = db.Column(db.Boolean(), default=False)
reset_pw_secret = db.Column(db.String(64))
meta = db.Column(JSON, default={})
is_destroyed = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def __init__(self,
email,
name,
school,
hashed_pw=None,
is_admin=False,
meta={}):
self.email = email
self.name = name
self.school = school
self.hashed_pw = hashed_pw
self.is_admin = is_admin
self.email_verification_secret = auth_util.fresh_secret()
self.meta = meta
def __repr__(self):
return '<User id={}, email={}, name={}, email_verified={}, email_verification_sent={}, school_id={}, is_admin={}, meta={}, is_destroyed={}, created_at={}>'.format(
self.id, self.email, self.name, self.email_verified,
self.email_verification_sent, self.school_id, self.is_admin,
self.meta, self.is_destroyed, self.created_at)
class User(UserMixin, db.Model):
"""Simple User Details."""
id = db.Column(db.Integer, primary_key=True)
oauth_site = db.Column(db.String(250), nullable=False)
social_id = db.Column(db.String(250), nullable=False)
user_name = db.Column(db.String(250))
is_authenticated = db.Column(db.Boolean(),
nullable=False,
default=False,
server_default='f')
