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