class Discount(db.Model): __tablename__ = 'discounts' id = db.Column( db.Integer, primary_key = True, autoincrement = True ) name = db.Column( db.String(50) nullable = False ) discount_type = db.Column( db.String(50) ) amount = db.Column( db.Float nullable = False ) requires_coupon = db.Column( db.Boolean, server_default="0" ) start_date = db.Column( db.Date ) end_date = db.Column( db.Date ) products = db.relationship( 'Product', backref = 'discount', lazy = 'joined' )
class UserModel(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80)) password = db.Column(db.String(80)) def __init__(self, username, password): self.username = username self.password = password def save_to_db(self): db.session.add(self) db.session.commit() def check_password(self, password): return hmac.compare_digest(self.password, password) @classmethod def find_by_username(cls, username): return cls.query.filter_by(username=username).first() @classmethod def find_by_id(cls, _id): return cls.query.filter_by(id=_id).first()
class Article(db.Model): __tablename__ = 'articles' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(255), nullable=False) source = db.Column(db.String(255), nullable=False) date = db.Column(db.DateTime, nullable=False) url = db.Column(db.String(255), nullable=False) author = Column(Integer, ForeignKey("authors.id")) sentences_count = db.Column(db.Integer) shares_count = db.Column(db.Integer) keywords = db.relationship( 'Keyword', secondary=articles_keywords, primaryjoin=(articles_keywords.c.article_id == id), backref=db.backref('articles', lazy='dynamic'), lazy='dynamic') def __init__(self, title, source, date, url, sentences_count) -> None: self.title = title self.source = source self.date = date self.url = url self.sentences_count = sentences_count def __repr__(self) -> Text: return '<title {}'.format(self.title)
class User(db.Model): id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(500), nullable=False) pw = db.Column(db.String(500), nullable=False) def add(self): db.session.add(self) db.session.commit() def get_id(self): return self.id def is_authenticated(self): return True def is_active(self): return True def is_anonymous(self): return False def checkIfRegistered(self, email): return self.query.filter_by(email=email).first() @staticmethod def hashPassword(password): return sha256(password.encode('utf8')).hexdigest()
class DSAttach(db.Model): __table_args__ = {"schema": "ds"} __tablename__ = 'ds_attach' attach_id = db.Column(db.Integer, primary_key=True) file_name = db.Column(db.String(512)) file_url = db.Column(db.String(2014)) file_type = db.Column(db.String(2014)) ver = db.Column(db.String(30)) committer = db.Column(db.String(30)) update_time = db.Column(db.Date) commit_time = db.Column(db.Date) micro_ver = db.Column(db.Integer) # 微版本 def __repr__(self): return '<Attach %r>' % self.file_name def to_dict(self, auto_convert_time=True): d = {} for column in self.__table__.columns: attr = getattr(self, column.name) if auto_convert_time and type(attr) in (datetime.datetime, datetime.time): d[column.name] = attr.strftime("%Y-%m-%d %H:%M:%S") else: d[column.name] = attr return d
class Card(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) holder_name = db.Column(db.String(100), nullable=False) number = db.Column(db.String(50), nullable=False) expiration_date = db.Column(db.String(10), nullable=False) cvv = db.Column(db.String(10), nullable=False) brand = db.Column(db.String(50), nullable=False)
class Channel(db.Model): __tablename__ = "channels" chnl_no = db.Column(db.String(12), primary_key=True) chnl_name = db.Column(db.String(200), nullable=False) chnl_cat_1 = db.Column(db.SmallInteger, nullable=False) chnl_cat_2 = db.Column(db.SmallInteger, nullable=False) chnl_cat_3 = db.Column(db.SmallInteger, nullable=False) # 经纬度,默认 -1,表示非线下渠道 longitude = db.Column(db.String(20), nullable=False, default='-1') latitude = db.Column(db.String(20), nullable=False, default='-1') contract_life = db.Column(db.Date, nullable=False) # 归属分公司,线上渠道是否不归属于分公司?(可使用默认值0) city_code = db.Column(db.String(8), nullable=False, index=True, default='0') # 下一层级渠道 sub_channels = db.relationship( # 关联的模型,自关联 'Channel', # 关联的表,定义的 channel_relation 表,存储各个渠道之间的关系 secondary='channel_relation', primaryjoin=(channel_relation.c.sup_chnl_no == chnl_no), secondaryjoin=(channel_relation.c.sub_chnl_no == chnl_no), backref=db.backref('sup_channel', lazy='dynamic'), lazy='dynamic')
class User(UserMixin, db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(16), index=True, unique=True) password_hash = db.Column(db.String(128)) def set_password(self, password): self.password_hash = self.get_password_hash(password) def get_password_hash(self, password): return generate_password_hash(password) def verify_password(self, password): result = check_password_hash(self.password_hash, password) return result @staticmethod def register(username, password): user = User(username=username) user.set_password(password) db.session.add(user) db.session.commit() return user def __repr__(self): return '<User {0}>'.format(self.username)
class ProductType(db.Model): __tablename__ = 'product_types' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80)) description = db.Column(db.String(80)) products = db.relationship('Product', lazy='dynamic') def __init__(self, _id, name, description): self.id=_id self.name = name self.description = description @classmethod def find_by_name(cls, name): return cls.query.filter_by(name=name).first() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit() @classmethod def init_data(cls): cls(1, "Food", "To calm the hunger").save_to_db() cls(2, "Drinks", "To refresh yourself").save_to_db() cls(3, "Desserts", "At last").save_to_db()
class UserModel(db.Model): """ This class represents the users table. """ __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(length=125)) first_name = db.Column(db.String(length=125)) last_name = db.Column(db.String(length=125)) email = db.Column(db.String(length=255)) last_updated = db.Column(db.DateTime, server_default=db.func.now(), onupdate=db.func.now()) def __repr__(self): return '<id: {}>'.format(self.id) def save(self): db.session.add(self) db.session.commit() def update(self, user_id, model): user = self.query.filter_by(id=user_id).first() user.username = model['username'] user.first_name = model['first_name'] user.last_name = model['last_name'] user.email = model['email'] db.session.commit()
class IssueModel(db.Model): """ This class represents the issues table. """ __tablename__ = 'issues' id = db.Column(db.Integer, primary_key=True) project_id = db.Column(db.Integer, db.ForeignKey('projects.id')) name = db.Column(db.String(length=255)) description = db.Column(db.String(length=500)) priority_level = db.Column(db.Integer) assigned_to_user_id = db.Column(db.Integer) created_by_user_id = db.Column(db.Integer, db.ForeignKey('users.id')) status = db.Column(db.Enum(StatusType)) last_updated = db.Column(db.DateTime, server_default=db.func.now(), onupdate=db.func.now()) def __repr__(self): return '<id: {}>'.format(self.id) def save(self): db.session.add(self) db.session.commit() def update(self, issue_id, model): issue = self.query.filter_by(id=issue_id).first() issue.project_id = model['project_id'] issue.name = model['name'] issue.description = model['description'] issue.priority_level = model['priority_level'] issue.assigned_to_user_id = model['assigned_to_user_id'] issue.created_by_user_id = model['created_by_user_id'] issue.status = model['status'] db.session.commit()
class User(Base): __tablename__ = 'account' userId = db.Column(db.String(144), nullable=False) fullName = db.Column(db.String(144), nullable=False) email = db.Column(db.String(144), nullable=False) #role = db.Column(db.String(255), nullable=False) def __init__(self, userId, fullName, email): #def __init__ (self, userId, fullName, email, role): self.userId = userId self.fullName = fullName self.email = email #self.role = role def get_id(self): return self.id def get_userId(self): return self.userId def is_active(self): return True def is_anonymous(self): return False def is_authenticated(self): return True def getRole(self): return self.role
class User_admin(db.Model): """ This class represents the user-admin table """ __tablename__ = 'user_admin' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(255), unique=True) password = db.Column(db.String(255), unique=True) def __init__(self, username, password): """initialize with name""" self.username = username self.password = password def save(self): db.session.add(self) db.session.commit() @staticmethod def get_all(): return User_admin.query.all() def delete(self): db.session.delete(self) db.session.commit() def __repr__(self): return "<User_admin: {}>".format(self.username)
class Conferences(db.Model): """This class represents the conference table.""" __tablename__ = 'conferences' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(255)) location = db.Column(db.String(255)) date_created = db.Column(db.DateTime, default=db.func.current_timestamp()) date_start = db.Column(db.DateTime, default=db.func.current_timestamp()) signup_until = db.Column(db.DateTime) date_modified = db.Column(db.DateTime, default=db.func.current_timestamp(), onupdate=db.func.current_timestamp()) def __init__(self, name): """initialize with name.""" self.name = name def save(self): db.session.add(self) db.session.commit() @staticmethod def get_all(): return Conferences.query.all() def delete(self): db.session.delete(self) db.session.commit() def __repr__(self): return "<Conferences: {}>".format(self.name)
class Key(db.Model, json.Serialisable): __tablename__ = 'key' id = db.Column(db.Integer, primary_key=True) public_key = db.Column(db.String()) private_key = db.Column(db.String()) def json_format(self): jsondata = {} def append(name, parameter): value = parameter(self) if value is not None: jsondata[name] = value append('id', lambda obj: obj.id) append('private_key', lambda obj: obj.private_key) append('public_key', lambda obj: obj.public_key) return jsondata def object_hook(dct): _id = dct.get('id') _private_key = dct.get('private_key') _public_key = dct.get('public_key') key = Key() key.id = _id key.private_key = _private_key key.public_key = _public_key return key
class MineDetail(AuditMixin, db.Model): __tablename__ = "mine_detail" mine_guid = db.Column(UUID(as_uuid=True), db.ForeignKey('mine_identity.mine_guid'), primary_key=True) mine_no = db.Column(db.String(10), primary_key=True, unique=True) mine_name = db.Column(db.String(60), nullable=False) mineral_tenure_xref = db.relationship('MineralTenureXref', backref='mine_detail', lazy=True) def __repr__(self): return '<MineDetail %r>' % self.mine_guid def save(self): db.session.add(self) try: db.session.commit() except: db.session.rollback() def json(self): return { 'mine_name': self.mine_name, 'mine_no': self.mine_no, 'mineral_tenure_xref': [item.json() for item in self.mineral_tenure_xref] } @classmethod def find_by_mine_no(cls, _id): return cls.query.filter_by(mine_no=_id).first()
class Users(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) login = db.Column(db.String(80), nullable=False, unique=True) password = db.Column(db.String(128), nullable=False, unique=True) def hash_password(self, password): self.password = generate_password_hash(password) def verify_password(self, password): return check_password_hash(self.password, password) def generate_auth_token(self, expiration = 600): s = Serializer(current_app.config['SECRET_KEY'], expires_in = expiration) return s.dumps({ 'id': self.id }) @staticmethod def verify_auth_token(token): s = Serializer(current_app.config['SECRET_KEY']) try: data = s.loads(token) except SignatureExpired: return None # valid token, but expired except BadSignature: return None # invalid token user = Users.query.get(data['id']) return user
class Attribute(db.Model): id = db.Column( db.Integer, primary_key = True, autoincrement = True ) name = db.Column( db.String(100), nullable = False ) description = db.Column( db.Text ) identifier_code = db.Column( db.String(3) ) attribute_value = db.relationship( 'AttributeValue', backref = 'attribute', lazy = 'joined' ) def __init__(self, *args, **kwargs): if not in kwargs: self.identifier_code = kwargs['name'][0:2].lower() super().__init__(*args, **kwargs)
class User(db.Model): __tablename__ = 'users' id = db.Column(db.BigInteger, primary_key=True, nullable=False) uid = db.Column(db.String(32), unique=True, nullable=False) name = db.Column(db.String(20), nullable=False) age = db.Column(db.Integer) timestamp = db.Column(db.TIMESTAMP, server_default=db.func.current_timestamp(), nullable=False) def __repr__(self): return f'<id: {self.id}>' def save(self): db.session.add(self) db.session.commit() @staticmethod def update(): db.session.commit() def delete(self): db.session.delete(self) db.session.commit()
class Transaction(db.Model): __tablename__ = 'transactions' id = db.Column( db.Integer, primary_key = True, autoincrement = True ) user_id = db_Column( db.Integer, db.ForeignKey('users.id') nullable = False ) shop_id = db.Column( db.Integer, db.ForeignKey('shops.id') nullable = False ) payment_method = db.Column( db.String(50) nullable = False ) pos_ref_number = db.Column( db.String(100) ) status = db.Column( db.String(50) server_default="PENDING" )
class Technology(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(60), nullable=False) description = db.Column(db.String(500), nullable=True) def insert(self): db.session.add(self) db.session.commit() def update(self): db.session.commit() def delete(self): db.session.delete(self) db.session.commit() def is_valid(self): return self.name != '' and self.description != '' def format(self): return { 'id': self.id, 'name': self.name, 'description': self.description, } def __repr__(self): return f'''
class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) public_id = db.Column(db.String(50), unique=True, nullable=False) email = db.Column(db.String(120), unique=True, nullable=False) role = db.Column(db.Integer, nullable=False) password_hash = db.Column(db.String(255), nullable=False) created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False) updated_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False) categories = db.relationship('Category', cascade="all,delete") scheduled_transactions = db.relationship('ScheduledTransaction', cascade="all,delete") def __init__(self, public_id, email, password, role=10): """int role: <user: 10> and <admin: 90>""" self.public_id = public_id self.email = email.lower() self.role = role self.set_password(password) def set_password(self, password): self.password_hash = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.password_hash, password)
class User(UserMixin, db.Model): """ A user of the application """ id = db.Column(db.Integer, primary_key=True) social_id = db.Column(db.String(64), nullable=True, unique=True) username = db.Column(db.String(64), index=True, unique=True) email = db.Column(db.String(120), index=True, unique=True) password_hash = db.Column(db.String(128)) last_seen = db.Column(db.DateTime, default=datetime.utcnow) picture_url = db.Column(db.String(200), nullable=True) def avatar(self, size): if self.picture_url: return self.picture_url digest = md5(self.email.lower().encode('utf-8')).hexdigest() return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format( digest, size) def set_password(self, password): self.password_hash = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.password_hash, password) def __repr__(self): return '<User: {} {}>'.format(self.id, self.username) def __str__(self): return '<User: id={} username={}> email={}'.format( self.id, self.username, self.email)
class Role(db.Model, RoleMixin): id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String(80), unique=True) description = db.Column(db.String(255)) def __str__(self): return self.name
class UserModel(db.Model): __tablename__ = 'usuario' """ Modelo que armazena todos os usuários cadastrados. """ id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(50), nullable=False) password = db.Column(db.String(250), nullable=False) enrolment = db.Column(db.String(25), nullable=False, unique=True) email = db.Column(db.String(50), nullable=False, unique=True) subj_associated = db.relationship('SubuserModel', backref='user_associate') my_subject = db.relationship('SubjectModel', backref='creator') def __init__(self, username, password, enrolment, email): self.username = username self.hash_password(password) self.enrolment = enrolment self.email = email def hash_password(self, password): self.password = pwd_context.encrypt(password) def verify_password(self, password): return pwd_context.verify(password, self.password) # return True or False
class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80)) password = db.Column(db.String(130)) firstname = db.Column(db.String(80)) lastname = db.Column(db.String(80)) address = db.Column(db.String(80)) role_id = db.Column(db.Integer, db.ForeignKey('roles.id')) role = db.relationship('Role') orders = db.relationship('Order', lazy='dynamic') def __init__(self, username, password, firstname, lastname, address, role_id): self.username = username self.password = pbkdf2_sha512.encrypt(password) self.firstname = firstname self.lastname = lastname self.address = address self.role_id = role_id def save_to_db(self): db.session.add(self) db.session.commit() @classmethod def find_by_username(cls, username): return cls.query.filter_by(username=username).first() @classmethod def check_login(cls, username, password): current_user = cls.find_by_username(username) if current_user and pbkdf2_sha512.verify(password, current_user.password): return current_user else: return None @classmethod def find_by_id(cls, _id): return cls.query.filter_by(id=_id).first() @classmethod def create_administrator(cls, username, password, firstname, lastname, address): return cls(username, password, firstname, lastname, address, 1) @classmethod def create_client(cls, username, password, firstname, lastname, address): return cls(username, password, firstname, lastname, address, 2) @classmethod def init_data(cls): cls.create_administrator('admin', '123456', 'admin', 'admin', 'working place').save_to_db() cls.create_client('client', '123456', 'client_firstname', 'client_lastname', 'Street 1').save_to_db()
class UserModel(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80)) password = db.Column(db.String(80)) def __init__(self, username, password): self.username = username self.password = password def json(self): return {'username': self.username, 'password': self.password} def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit() @classmethod def find_by_username(cls, username): return cls.query.filter_by(username=username).first() @classmethod def find_by_id(cls, _id): return cls.query.filter_by(id=_id).first()
class Shop(db.Model): __tablename__ = 'shops' id = db.Column( db.Integer, primary_key = True, autoincrement = True ) name = db.Column( db.String(100), nullable = False ) slug = db.Column( db.String(100), nullable = False ) identifier_code = db.Column( db.String(3), nullable = False ) transactions = db.relationship( 'Transaction', backref = 'shop', lazy = 'joined' ) def __init__(self, *args, **kwaargs): if not 'slug' in kwargs: self.slug = slugify(kwargs['name']) super()__init__(*args, **kwargs)
class UsuarioModel(TimestampMixin, db.Model): __tablename__ = 'usuarios' id = db.Column(db.Integer, primary_key=True) nome = db.Column(db.String(60), nullable=False) email = db.Column(db.String(100), nullable=False) entidades = db.relationship('Entidade', secondary='usuario_entidade')
class UserModel(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) user = db.Column(db.String(255), nullable=False, unique=True) password = db.Column(db.String(255), nullable=False) def __init__(self, user, password): self.user = user self.password = password def get(id): user = session.query(UserModel).filter(UserModel.id == id).first() return user @classmethod def get_by_user(cls, user): user = cls.query.filter_by(user = user).first() return user def add(self): db.session.add(self) db.session.commit() def delete(self): db.session.delete(self) db.session.commit() def as_dict(self): return {c.name: getattr(self, c.name) for c in self.__table__.columns}