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}
