class Role(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), nullable=False)
description = db.Column(db.String(200))
def __repr__(self):
return '<Role {}>'.format(self.name)
class Currency(db.Model):
code = db.Column(db.String(3), primary_key=True)
country = db.Column(db.String(50), nullable=False)
rate = db.Column(db.Numeric(12, 6), nullable=False)
# relationships --------------------------------------
stores = db.relationship('Store', backref='currency')
orders = db.relationship('Order', backref='currency')
class User(UserMixin, db.Model):
''' Table of everyone capable of logging in to the system '''
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=True, nullable=False)
email = db.Column(db.String(100), unique=True, nullable=False)
password = db.Column(db.String(200), nullable=False)
active = db.Column(db.Boolean, default=True)
# relationships --------------------------------------
orders = db.relationship('Order', backref='user')
roles = db.relationship(
'Role', secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
stores = db.relationship('Store', backref='user')
@property
def is_authenticated(self):
return True
@property
def is_active(self):
if self.active:
return True
return False
def get_id(self):
return str(self.id)
def __repr__(self):
return '<User {}>'.format(self.name)
class Worker(WorkerMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
def __init__(self, name):
super().__init__(func=partial(complex_task, seconds=5))
self.name = name
class Router(RouterMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
def __init__(self, name):
self.name = name
super().__init__(self.func1, 'hello world')
def func1(self, hello_world):
print(hello_world)
return self.func2('hello moon')
# 'bookmark' functions with the `@set_route` decorator
@set_route
def func2(self, hello_moon):
print(hello_moon)
worker = get_model(Worker, 'routing')
return self.func3('hello star') if worker.job_finished else worker()
@set_route
def func3(self, hello_star):
print(hello_star)
# optionally, reset the router
# you may also want to reset Workers which were called by the Router
self.reset()
get_model(Worker, 'routing').reset()
return 'Function calls finished.'
class OrderLine(db.Model):
id = db.Column(db.Integer, primary_key=True)
order_id = db.Column(db.Integer, db.ForeignKey('order.id'), nullable=False)
product_id = db.Column(db.Integer,
db.ForeignKey('product.id'),
nullable=False)
price = db.Column(db.Numeric(20, 2), nullable=False)
qty = db.Column(db.Integer, default=1, nullable=False)
class Price(db.Model):
__tablename__ = 'price'
id = db.Column(db.Integer, primary_key=True)
value = db.Column(db.Integer)
def __init__(self, value):
self.value = value
class Viewable(db.Model):
id = db.Column(db.Integer, primary_key=True)
image_name = db.Column(db.String(120), nullable=False)
image_id = db.Column(db.Integer, nullable=False)
user_name = db.Column(db.String(120), nullable=False)
timestamp = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
def __repr__(self):
return '<Viewable %r>' % self.image_name + self.user_name
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
ticket_id = db.Column(db.Integer,
db.ForeignKey('ticket.id'),
nullable=False)
message = db.Column(db.String(120), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=func.now())
def __repr__(self):
return '<Comment for %r>' % self.ticket_id
class Comments(db.Model):
id = db.Column(db.Integer, primary_key=True)
parent_image = db.Column(db.Integer, nullable=False)
author = db.Column(db.String(120), nullable=False)
comment_string = db.Column(db.String(255), nullable=False)
timestamp = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
def __repr__(self):
output = ""
output += ("id: " + str(self.id) + ", ")
output += ("parent_image: " + str(self.parent_image) + ", ")
output += ("author: " + self.author + ", ")
output += ("string: " + self.comment_string + ", ")
output += ("timestamp: " + str(self.timestamp))
return '<Comment %r>' % output
class Order(db.Model):
'''
Table of orders: status can be one of
* `cart`: The order havenot been checked-out
* `placed`: It has been checkout, but not yet paid for
* `paid`: It has been fully paid for
* `dispatched`: It has been handed to the dispatcher
* `fulfilled`: It has been delivered to the customer
Note:
* When the `PAYMENT_SPLIT_POINT = 'instant'`, the `dispatched`
and `fulfiled` status are not used.
'''
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
iso_code = db.Column(db.Integer,
db.ForeignKey('currency.code'),
nullable=False)
status = db.Column(db.String(5), default='open', nullable=False)
amount = db.Column(db.String(20))
created_at = db.Column(db.DateTime(), default=datetime.utcnow())
last_modified_at = db.Column(db.DateTime(), default=datetime.utcnow())
# relationship ---------------
orderlines = db.relationship('OrderLine', backref='order')
@classmethod
def cart(cls):
# only products from active stores are made public
return (Order.query.filter(Order.status == 'open'))
class Ticket(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), unique=True, nullable=False)
name = db.Column(db.String(120), nullable=False)
email = db.Column(db.String(120), nullable=False)
subject = db.Column(db.String(120), nullable=False)
message = db.Column(db.String(120), nullable=False)
type = db.Column(db.String(120), nullable=False)
urgency = db.Column(db.String(120), nullable=False)
status = db.Column(db.String(120), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=func.now())
comments = db.relationship('Comment', backref='comments', lazy=True)
def __repr__(self):
return '<id: %r, email: %r, subject: %r>' % (self.id, self.email,
self.subject)
class UserModel(db.Model):
# 定义表名
__tablename__ = 'user'
# 主键必须要加 unique=True，否则会报错
user_id = db.Column(db.String(50), primary_key=True, unique=True)
username = db.Column(db.String(20), unique=True, nullable=False)
password = db.Column(db.String(50), nullable=False)
create_time = db.Column(db.Date, default=datetime.now)
# 序列化: 查询一条数据
def query_one(self):
res = {
'userID': self.user_id,
'userName': self.username,
'password': self.password,
'create_time': self.create_time
}
return res
class Dispatcher(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=True, nullable=False)
charge = db.Column(db.Integer, nullable=False)
phone = db.Column(db.String(15), nullable=False)
email = db.Column(db.String(100), nullable=False)
account_id = db.Column(db.Integer, db.ForeignKey('account_detail.id'))
is_active = db.Column(db.Boolean(), default=True)
# relationships --------------------------------------
stores = db.relationship('Store', backref='dispatcher')
class SuiteModel(db.Model):
# 定义表名
__tablename__ = 'suite'
suite_id = db.Column(db.String(50), primary_key=True, unique=True)
suite_name = db.Column(db.String(30), nullable=False)
remark = db.Column(db.String(50))
is_delete = db.Column(db.Integer, nullable=False, default=0)
create_time = db.Column(db.Date, default=datetime.now)
update_time = db.Column(db.Date,
default=datetime.now,
onupdate=datetime.now)
pro_id = db.Column(db.String(50),
db.ForeignKey('project.project_id'),
nullable=False)
creator = db.Column(db.String(50),
db.ForeignKey('user.user_id'),
nullable=False)
class AccountDetail(db.Model):
id = db.Column(db.Integer, primary_key=True)
account_name = db.Column(db.String(50), nullable=False)
account_num = db.Column(db.Integer, nullable=False)
bank = db.Column(db.String(100), nullable=False)
sub_number = db.Column(db.Integer)
sub_id = db.Column(db.Integer, )
# relationships --------------------------------------
stores = db.relationship('Store', backref='account')
dispatchers = db.relationship('Dispatcher', backref='account')
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), unique=True, nullable=False)
first_name = db.Column(db.String(100), nullable=False)
second_name = db.Column(db.String(100), nullable=False)
password = db.Column(db.String(120), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=func.now())
def __repr__(self):
return '<Email %r>' % self.email
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
first_name = db.Column(db.String(120), nullable=False)
last_name = db.Column(db.String(120), nullable=False)
def __repr__(self):
return '<User %r>' % self.username
class Image(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
timestamp = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
path_to_image = db.Column(db.String(255), nullable=False)
owner = db.Column(db.String(120), nullable=False)
caption = db.Column(db.String(255), nullable=False)
def __repr__(self):
return '<Image %r>' % self.name
class EnvModel(db.Model):
# 定义表名
__tablename__ = 'env'
env_id = db.Column(db.String(50), primary_key=True, unique=True)
env_name = db.Column(db.String(15), nullable=False)
base_url = db.Column(db.String(50), nullable=False)
create_time = db.Column(db.Date, default=datetime.now)
is_delete = db.Column(db.Integer, nullable=False, default=0)
pro_id = db.Column(db.String(50),
db.ForeignKey('project.project_id'),
nullable=False)
creator = db.Column(db.String(50),
db.ForeignKey('user.user_id'),
nullable=False)
class ApiTestReportModel(db.Model):
# 定义表名
__tablename__ = 'api_report'
report_id = db.Column(db.String(50), primary_key=True, unique=True)
report_name = db.Column(db.String(100), nullable=False)
success = db.Column(db.Integer, nullable=False, default=0)
fail = db.Column(db.Integer, nullable=False, default=0)
create_time = db.Column(db.Date, default=datetime.now)
pro_id = db.Column(db.String(50),
db.ForeignKey('project.project_id'),
nullable=False)
task_id = db.Column(db.String(50),
db.ForeignKey('task.task_id'),
nullable=False)
class Product(db.Model):
'''
Table of all Products from all stores.
When `PRODUCT_PRICING = 'localize'`, the product prices
will be converted from their store currencies to the
visitor's currency. 4 currencies (GBP, KES, NGN, USA,
are currently supported, and the applicable one defaults to the
automatically computed ISO CODE based on the visitor's IP location,
and when the detected ISO_CODE is not part of the supported
currencies, the product prices are served in USD.
'''
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
price = db.Column(db.Numeric(20, 2))
description = db.Column(db.String(200))
# Yes, images are stored on the database
# from experience, it is preferrable a scenario like this
image = db.Column(db.BLOB)
store_id = db.Column(db.Integer, db.ForeignKey('store.id'), nullable=False)
is_active = db.Column(db.Boolean, default=False)
created_at = db.Column(db.DateTime(), default=datetime.utcnow())
last_modified_at = db.Column(db.DateTime, default=datetime.utcnow())
# relationships ---------------------------------------------
orderlines = db.relationship('OrderLine', backref='product')
@classmethod
def public(cls):
# only active products are made public
return (Product.query.filter(Product.is_active == 1))
def sale_price(self, product_pricing, to_currency, multi_currency):
'''
Converts price of products to visitor's currency based on scale
'''
if (product_pricing == 'localize' and multi_currency):
scale = (Currency.query.filter_by(code=to_currency).first().rate /
self.store.currency.rate)
return round(self.price * scale, 2)
return self.price
class ProjectModel(db.Model):
# 定义表名
__tablename__ = 'project'
project_id = db.Column(db.String(50), primary_key=True)
project_name = db.Column(db.String(20), unique=True)
remark = db.Column(db.String(50))
is_delete = db.Column(db.Integer, nullable=False, default=0)
create_time = db.Column(db.Date, default=datetime.now)
creator = db.Column(db.String(50), db.ForeignKey('user.user_id'), nullable=False)
# 序列化: 查询一条数据
def query_one(self):
res = {
'projectID': self.project_id,
'projectName': self.project_name,
'remark': self.remark,
'createTime': self.create_time,
'creator': self.creator
}
return res
class TaskModel(db.Model):
# 定义表名
__tablename__ = 'task'
task_id = db.Column(db.String(50), primary_key=True, unique=True)
task_name = db.Column(db.String(6), nullable=False)
create_time = db.Column(db.Date, default=datetime.now)
task_start_time = db.Column(db.BigInteger)
task_end_time = db.Column(db.BigInteger)
task_status = db.Column(db.Integer, nullable=False, default=0)
creator = db.Column(db.String(50),
db.ForeignKey('user.user_id'),
nullable=False)
pro_id = db.Column(db.String(50),
db.ForeignKey('project.project_id'),
nullable=False)
env_id = db.Column(db.String(50),
db.ForeignKey('env.env_id'),
nullable=False)
suite_id = db.Column(db.String(50),
db.ForeignKey('suite.suite_id'),
nullable=False)
ver_id = db.Column(db.String(50),
db.ForeignKey('version.ver_id'),
nullable=False)
'''
Human related models are located here, currently we have:
- Role: Which may be one of Admin | Vendor | Customer
- User: Table of everyone capable of logging in to the system
'''
from datetime import datetime
from flask_security import utils, current_user, UserMixin, RoleMixin
from flask_admin.contrib import sqla
from wtforms.fields import PasswordField
from factory import db
roles_users = db.Table(
'roles_users', db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
db.Column('role_id', db.Integer, db.ForeignKey('role.id')),
)
class Role(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), nullable=False)
description = db.Column(db.String(200))
def __repr__(self):
return '<Role {}>'.format(self.name)
class User(UserMixin, db.Model):
''' Table of everyone capable of logging in to the system '''
class Store(db.Model):
'''
Table of stores information. Key features are:
- A User is permitted to register more than one store
- A Store is given assigned a dispatch ride
'''
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
# Yes, images are stored on the database
# from experience, it is preferrable a scenario like this
logo = db.Column(db.BLOB)
about = db.Column(db.String(150), nullable=False)
iso_code = db.Column(db.Integer,
db.ForeignKey('currency.code'),
nullable=False)
account_id = db.Column(db.Integer, db.ForeignKey('account_detail.id'))
dispatcher_id = db.Column(db.Integer,
db.ForeignKey('dispatcher.id'),
nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
phone = db.Column(db.String(15), nullable=False)
email = db.Column(db.String(100), nullable=False)
created_at = db.Column(db.DateTime(), default=datetime.utcnow())
is_active = db.Column(db.Boolean(), default=True)
# relationships --------------------------------------
products = db.relationship('Product', backref='store')
@classmethod
def public(cls):
# only products from active stores are made public
return (Store.query.filter(Store.is_active == 1))
class TestCaseModel(db.Model):
# 定义表名
__tablename__ = 'testcase'
case_id = db.Column(db.String(50), primary_key=True, unique=True)
case_name = db.Column(db.String(20), nullable=False)
level = db.Column(db.Integer, nullable=False, default=0)
method = db.Column(db.Integer, nullable=False, default=0)
req_url = db.Column(db.String(200), nullable=False, default=None)
header = db.Column(db.String(100), nullable=False, default=None)
body = db.Column(db.Text(500), nullable=True)
case_assert = db.Column(db.Text(500), nullable=False, default=None)
forward = db.Column(db.Text(500), nullable=True)
mock = db.Column(db.Text(500), nullable=True)
remark = db.Column(db.String(200), nullable=True)
create_time = db.Column(db.Date, default=datetime.now)
creator = db.Column(db.String(50), db.ForeignKey('user.user_id'), nullable=False)
pro_id = db.Column(db.String(50), db.ForeignKey('project.project_id'), nullable=False)
