class Completion(db.Model, BaseModelMixin):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User',
backref=db.backref('completion_user',
lazy='dynamic'),
foreign_keys=[user_id])
time = db.Column(db.String(7))
rate = db.Column(db.Float)
creator_id = db.Column(db.Integer, db.ForeignKey('user.id'))
creator = db.relationship('User',
backref=db.backref('completion_creator',
lazy='dynamic'),
foreign_keys=[creator_id])
create_time = db.Column(db.DateTime)
__mapper_args__ = {'order_by': time.desc()}
def __init__(self, user, time, rate=None, creator=None, create_time=None):
self.user = user
self.creator = creator
self.time = time
self.rate = rate or 0.0
self.create_time = datetime.date.today()
class ItemType(db.Model):
"""
A type of item, like a long sword or a rope.
"""
id = db.Column(db.Integer, primary_key=True)
stackable = db.Column(db.Boolean, default=True)
name = db.Column(db.Text, default='New Item')
description = db.Column(db.Text, default='description...')
weight = db.Column(db.Float)
value = db.Column(db.Integer) # Base value of this item in coins
def __str__(self):
return self.name
def __serialize__(self):
o = {'id': self.id, 'name': self.name, 'stackable': self.stackable}
if self.description is not None:
o['description'] = self.description
if self.value is not None:
o['value'] = self.value
if self.weight is not None:
o['weight'] = self.weight
return o
class Booking(db.Model):
__tablename__ = "bookings"
id = db.Column(db.Integer, primary_key=True)
phone = db.Column(db.String(50), nullable=False)
name = db.Column(db.String(50), nullable=False)
time = db.Column(db.String, nullable=False)
weekday = db.Column(db.String(100), nullable=False)
teacher = db.relationship("Teacher")
teacher_id = db.Column(db.Integer, db.ForeignKey('teachers.id'))
@classmethod
def add(cls, **kwargs) -> 'Booking':
new_entry = cls(phone=kwargs.get('phone'),
name=kwargs.get('name'),
time=kwargs.get('time'),
weekday=kwargs.get('weekday'),
teacher=kwargs.get('teacher'))
db.session.add(new_entry)
return new_entry
def commit(self):
db.session.commit()
class MenuOrderItemModel(db.Model):
__tablename__ = "menuorderitems"
id = db.Column(db.Integer, primary_key=True)
order_no = db.Column(db.Integer, db.ForeignKey('menuorder.id'))
menu_item_id = db.Column(db.Integer, db.ForeignKey('menuitem.id'))
menu_qty = db.Column(db.Integer, nullable=False)
menu_amount = db.Column(db.Integer, nullable=False)
choice = db.Column(db.Integer, nullable=True)
menuorder = db.relationship('MenuOrderModel')
menuitem = db.relationship('MenuItemModel')
def __init__(self, order_no, menu_item_id, menu_qty, menu_amount, choice):
self.order_no = order_no
self.menu_item_id = menu_item_id
self.menu_qty = menu_qty
self.menu_amount = menu_amount
self.choice = choice
def json(self):
return {
'id': self.id,
'order_no': self.order_no,
'menu_item_id': self.menu_item_id,
'menu_qty': self.menu_qty,
'menu_amount': self.menu_amount,
'choice': self.choice
}
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
class BlogModel(db.Model):
__tablename__ = "blog"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(128), nullable=False)
content = db.Column(db.Text, nullable=False)
created_at = db.Column(db.DateTime)
modified_at = db.Column(db.DateTime)
owner_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
owner = db.relationship("UserModel")
def save(self) -> None:
db.session.add(self)
db.session.commit()
def update(self, data) -> None:
for key, item in data.items():
setattr(self, key, item)
self.modified_at = datetime.datetime.utcnow()
db.session.commit()
def delete(self) -> None:
db.session.delete(self)
db.session.commit()
@classmethod
def get_all_blogs(cls) -> List["BlogModel"]:
return cls.query.all()
@classmethod
def find_blog_by_id(cls, _id: int) -> "BlogModel":
return cls.query.get(_id)
def __repr__(self):
return f"<id {self.id}>"
class Notice(db.Model, BaseModelMixin):
__tablename__ = 'notice'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100))
emails = db.Column(db.Text(), default=json.dumps([]))
content = db.Column(db.Text(), default="")
creator_id = db.Column(db.Integer, db.ForeignKey('user.id'))
creator = db.relationship('User',
backref=db.backref('notice_creator',
lazy='dynamic'),
foreign_keys=[creator_id])
create_time = db.Column(db.DateTime)
__mapper_args__ = {'order_by': create_time.desc()}
def __init__(self, title, emails, content, creator, create_time=None):
self.title = title
self.emails = emails
self.content = content
self.creator = creator
self.create_time = create_time or datetime.date.today()
@property
def create_time_cn(self):
return self.create_time.strftime('%Y-%m-%d %H:%M')
class SalaryUser(db.Model):
'''
员工注册
'''
__tablename__ = 'db_salary_user'
id = db.Column(db.Integer,
nullable=False,
primary_key=True,
index=True,
autoincrement=True)
salary_user_id = db.Column(db.String(36),
index=True,
nullable=False,
unique=True)
id_card = db.Column(db.String(255),
index=True,
nullable=False,
unique=True)
phone = db.Column(db.BigInteger, index=True, nullable=False, unique=True)
openid = db.Column(db.String(255), index=True, nullable=False, unique=True)
create_time = db.Column(db.DateTime,
index=True,
default=datetime.datetime.now)
__table_args__ = {'useexisting': True, 'mysql_engine': 'InnoDB'}
def to_json(self):
dict = self.__dict__
if "_sa_instance_state" in dict:
del dict["_sa_instance_state"]
if "create_time" in dict:
dict["create_time"] = dict["create_time"].strftime(
'%Y-%m-%d %H:%M:%S')
return dict
def __repr__(self):
return '<SalaryUser %r>' % self.salary_user_id
class LHDRemotePledgeAddress(db.Model):
__tablename__ = 'pool_lhd_pledge_ro'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
# 用户account_key
account_key = db.Column(db.String(64), index=True)
# 用户远程抵押地址
address = db.Column(db.String(64), index=True)
# 1可用，0禁止
status = db.Column(db.Integer)
create_time = db.Column(db.TIMESTAMP(),
server_default=func.current_timestamp())
update_time = db.Column(db.TIMESTAMP(),
server_default=func.current_timestamp())
def to_dict(self):
remote_pledge_dict = {
"account_key": self.account_key,
"address": self.address,
"status": self.status,
"create_time": str(self.create_time),
}
return remote_pledge_dict
class Menu(db.Model):
'''
菜单
'''
__tablename__ = 'db_menu'
id = db.Column(db.Integer, nullable=False, primary_key=True, index=True, autoincrement=True)
menu_id = db.Column(db.String(36), index=True, nullable=False, unique=True)
pid = db.Column(db.String(36), nullable=False, index=True, default='0')
name = db.Column(db.String(64), index=True, nullable=False, unique=True)
title = db.Column(db.String(64), nullable=False, unique=True)
path = db.Column(db.String(255), nullable=False, unique=True)
icon = db.Column(db.String(255), nullable=False)
mark = db.Column(db.String(255), nullable=False, unique=True)
component = db.Column(db.String(255), nullable=False)
componentPath = db.Column(db.String(255), nullable=False)
cache = db.Column(db.Boolean, index=True, default=True)
sort = db.Column(db.SmallInteger, index=True, default=1)
disable = db.Column(db.Boolean, index=True, default=False)
interfaces = db.relationship('Interface',
secondary=InterfaceToMenu,
backref=db.backref('menus', lazy='dynamic'),
lazy='dynamic')
__table_args__ = (table_args())
def to_json(self):
dict = self.__dict__
if "_sa_instance_state" in dict:
del dict["_sa_instance_state"]
return dict
def __repr__(self):
return '<Menu %r>' % self.title
from models import db
import datetime
import json
def table_args():
return {
'useexisting': True,
'mysql_engine': 'InnoDB',
'mysql_charset': 'utf8'
}
InterfaceToMenu = db.Table(
'db_interface_to_menu',
db.Column('menu_id', db.String(36), db.ForeignKey('db_menu.menu_id', ondelete='CASCADE')),
db.Column('interface_id', db.String(36), db.ForeignKey('db_interface.interface_id', ondelete='CASCADE')),
useexisting=True,
mysql_engine='InnoDB',
mysql_charset='utf8'
)
InterfaceToRole = db.Table(
'db_interface_to_role',
db.Column('role_id', db.String(36), db.ForeignKey('db_role.role_id', ondelete='CASCADE')),
db.Column('interface_id', db.String(36), db.ForeignKey('db_interface.interface_id', ondelete='CASCADE')),
useexisting=True,
mysql_engine='InnoDB',
mysql_charset='utf8'
)
class searchAdAgentInvoice(db.Model, BaseModelMixin):
__tablename__ = 'searchAd_bra_agent_invoice'
id = db.Column(db.Integer, primary_key=True)
client_order_id = db.Column(
db.Integer, db.ForeignKey('searchAd_bra_client_order.id')) # 客户合同
client_order = db.relationship('searchAdClientOrder',
backref=db.backref('agentinvoices',
lazy='dynamic'))
agent_id = db.Column(db.Integer, db.ForeignKey('searchAd_agent.id'))
agent = db.relationship('searchAdAgent',
backref=db.backref('agentinvoices',
lazy="dynamic"))
company = db.Column(db.String(100)) # 公司名称
tax_id = db.Column(db.String(100)) # 税号
address = db.Column(db.String(120)) # 公司地址
phone = db.Column(db.String(80)) # 联系电话
bank_id = db.Column(db.String(100)) # 银行账号
bank = db.Column(db.String(100)) # 开户行
detail = db.Column(db.String(200)) # 发票内容
money = db.Column(db.Float) # 发票金额
pay_money = db.Column(db.Float) # 打款金额
invoice_type = db.Column(db.Integer) # 发票类型
invoice_status = db.Column(db.Integer) # 发票状态
invoice_num = db.Column(db.String(200), default='') # 发票号
creator_id = db.Column(db.Integer, db.ForeignKey('user.id'))
creator = db.relationship('User',
backref=db.backref(
'searchAd_created_agent_invoice',
lazy='dynamic'))
add_time = db.Column(db.DateTime) # 开具发票时间
pay_time = db.Column(db.DateTime) # 打款时间
create_time = db.Column(db.DateTime) # 添加时间
bool_pay = db.Column(db.Boolean) # 是否已打款
bool_invoice = db.Column(db.Boolean) # 是否开具发票
__mapper_args__ = {'order_by': create_time.desc()}
def __init__(self,
client_order,
agent,
company="",
tax_id="",
address="",
phone="",
bank_id="",
bank="",
detail="",
invoice_num="",
money=0.0,
pay_money=0.0,
invoice_type=INVOICE_TYPE_NORMAL,
invoice_status=AGENT_INVOICE_STATUS_NORMAL,
creator=None,
create_time=None,
add_time=None,
pay_time=None,
bool_pay=False,
bool_invoice=True):
self.client_order = client_order
self.agent = agent
self.company = company
self.tax_id = tax_id
self.address = address
self.phone = phone
self.bank_id = bank_id
self.bank = bank
self.detail = detail
self.money = money
self.pay_money = pay_money
self.invoice_type = invoice_type
self.invoice_status = invoice_status
self.creator = creator
self.create_time = create_time or datetime.date.today()
self.add_time = add_time or datetime.date.today()
self.pay_time = pay_time or datetime.date.today()
self.bool_pay = bool_pay
self.bool_invoice = bool_invoice
self.invoice_num = invoice_num
def __repr__(self):
return '<searchAdAgentInvoice %s>' % (self.id)
@property
def create_time_cn(self):
return self.create_time.strftime("%Y-%m-%d %H:%M:%S")
@property
def add_time_cn(self):
return self.add_time.strftime("%Y-%m-%d")
@property
def pay_time_cn(self):
return self.pay_time.strftime("%Y-%m-%d")
@property
def invoice_type_cn(self):
return INVOICE_TYPE_CN[self.invoice_type]
@classmethod
def get_agent_invoices_status(cls, status):
return cls.query.filter_by(invoice_status=status)
def get_invoice_pas_by_status(self, status):
return [
k for k in searchAdAgentInvoicePay.query.filter_by(
agent_invoice=self) if k.pay_status == status
]
@property
def get_pay_money(self):
return sum([
k.money for k in searchAdAgentInvoicePay.query.filter_by(
agent_invoice=self)
if k.pay_status == AGENT_INVOICE_STATUS_PASS
])
@property
def get_unpay_money(self):
return self.money - self.get_pay_money
@property
def get_apply_pay_money(self):
return sum([
k.money for k in searchAdAgentInvoicePay.query.filter_by(
agent_invoice=self) if k.pay_status in
[AGENT_INVOICE_STATUS_APPLY, AGENT_INVOICE_STATUS_AGREE]
])
@property
def pay_invoice_money(self):
return sum([
k.money for k in searchAdAgentInvoicePay.query.filter_by(
agent_invoice=self)
])
class searchAdInvoice(db.Model, BaseModelMixin):
__tablename__ = 'searchAd_bra_invoice'
id = db.Column(db.Integer, primary_key=True)
client_order_id = db.Column(
db.Integer, db.ForeignKey('searchAd_bra_client_order.id')) # 客户合同
client_order = db.relationship('searchAdClientOrder',
backref=db.backref('invoices',
lazy='dynamic'))
company = db.Column(db.String(100)) # 公司名称
tax_id = db.Column(db.String(100)) # 税号
address = db.Column(db.String(120)) # 公司地址
phone = db.Column(db.String(80)) # 联系电话
bank_id = db.Column(db.String(50)) # 银行账号
bank = db.Column(db.String(100)) # 开户行
detail = db.Column(db.String(200)) # 发票内容
money = db.Column(db.Float) # 发票金额
invoice_type = db.Column(db.Integer) # 发票类型
invoice_status = db.Column(db.Integer) # 发表状态
invoice_num = db.Column(db.String(200), default='') # 发票号
creator_id = db.Column(db.Integer, db.ForeignKey('user.id'))
creator = db.relationship('User',
backref=db.backref('searchAd_created_invoice',
lazy='dynamic'))
back_time = db.Column(db.DateTime)
create_time = db.Column(db.DateTime)
__mapper_args__ = {'order_by': create_time.desc()}
def __init__(self,
client_order,
company="",
tax_id="",
address="",
phone="",
bank_id="",
bank="",
detail="",
invoice_num="",
money=0.0,
invoice_type=INVOICE_TYPE_NORMAL,
invoice_status=INVOICE_STATUS_NORMAL,
creator=None,
create_time=None,
back_time=None):
self.client_order = client_order
self.company = company
self.tax_id = tax_id
self.address = address
self.phone = phone
self.bank_id = bank_id
self.bank = bank
self.detail = detail
self.money = money
self.invoice_type = invoice_type
self.invoice_status = invoice_status
self.creator = creator
self.create_time = create_time or datetime.date.today()
self.back_time = back_time or datetime.date.today()
self.invoice_num = invoice_num
def __repr__(self):
return '<searchAdInvoice %s>' % (self.id)
@property
def create_time_cn(self):
return self.create_time.strftime("%Y-%m-%d")
@property
def back_time_cn(self):
if self.back_time:
return self.back_time.strftime("%Y-%m-%d")
else:
return ""
@property
def invoice_type_cn(self):
return INVOICE_TYPE_CN[self.invoice_type]
@property
def invoice_status_cn(self):
return INVOICE_STATUS_CN[self.invoice_status]
@classmethod
def get_invoices_status(cls, status):
return cls.query.filter_by(invoice_status=status)
class Term(db.Model):
__tablename__ = "terms"
term_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
location = db.Column(db.String, nullable=False)
from models import db
from datetime import datetime
likes = db.Table(
'likes',
db.Column('post_id',
db.Integer,
db.ForeignKey('post.id'),
primary_key=True),
db.Column('user_id',
db.Integer,
db.ForeignKey('user.id'),
primary_key=True))
# Comments = db.Table('Comments',
# db.Column('post_id', db.Integer, db.ForeignKey('post.id'), primary_key=True),
# db.Column('user_id', db.Integer, db.ForeignKey('user.id'), primary_key=True),
# db.Column('commenttext',db.String(50))
# )
class Comment(db.Model):
__tablename__ = 'Comment'
post_id = db.Column(db.Integer,
db.ForeignKey('post.id'),
primary_key=True,
unique=False)
user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
primary_key=True,
unique=False)
comments = db.Column(db.String(100))
class IncomeMixin(BaseModel):
__abstract__ = True
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
# 用户id
account_key = db.Column(db.String(36))
# 区块收益bhd数量
amount = db.Column(db.DECIMAL(32, 16))
# 实际获取数量
actual_amount = db.Column(db.DECIMAL(32, 16))
# 挖出区块高度
height = db.Column(db.INTEGER)
# 矿工抵押率
mortgage_rate = db.Column(db.DECIMAL(32, 16))
# 类型
type = db.Column(db.INTEGER)
# 容量
capacity = db.Column(db.DECIMAL(32, 16))
# 是否已经计算收益
is_add_asset = db.Column(db.SmallInteger)
create_time = db.Column(db.TIMESTAMP(), default=datetime.now)
update_time = db.Column(db.TIMESTAMP(), default=datetime.now)
def __init__(self,
account_key,
amount,
income_type,
is_add_asset=0,
capacity=0):
self.account_key = account_key
self.amount = amount
self.actual_amount = amount
self.mortgage_rate = 1
self.type = income_type
self.is_add_asset = is_add_asset
self.capacity = capacity
def __setattr__(self, key, value):
super().__setattr__(key, value)
if key != "update_time":
self.update_time = datetime.now()
def to_dict(self):
income_record_dict = {
"account_key": self.account_key,
"amount": self.amount,
"actual_amount": self.actual_amount,
"height": self.height,
"mortgage_rate": self.mortgage_rate,
"create_time": str(self.create_time),
"is_add_asset": self.is_add_asset,
"capacity": self.capacity,
"type": self.type,
}
return income_record_dict
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 20/6/5 19:07
# @Author : xjm
# @Site :
# @File : user.py
# @Software: PyCharm
from werkzeug.security import check_password_hash
from models import db
from datetime import datetime
# 模型之间的关系不需要创建第三个模型类实现第三张关系表创建
# 创建用户和角色的关系表
user_role = db.Table('t_user_role',
db.Column('uid', db.Integer, db.ForeignKey('t_user.id', name='user_fk')),
db.Column('rid', db.Integer, db.ForeignKey('t_role.id', name='role_fk')))
class BaseModel(db.Model):
__abstract__ = True # 作用：不会作为普通模型的创建对应的表(抽象模型)
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(20), unique=True, nullable=False)
# 继承BaseModel：
class Role(BaseModel): # 用户角色
__tablename__ = 't_role' # 设置数据库中的表名(默认为当前类名的小写)
def __repr__(self):
return '<Role %r>' % self.name
class Option(db.Model):
key = db.Column(db.String(256), primary_key=True)
value = db.Column(db.PickleType)
class Document(db.Model):
'''
附件
'''
__tablename__ = 'db_document'
id = db.Column(db.Integer, nullable=False, primary_key=True, index=True, autoincrement=True)
document_id = db.Column(db.String(36), index=True, nullable=False, unique=True)
admin_id = db.Column(db.String(36), index=True, nullable=False)
name = db.Column(db.String(64), index=True, nullable=False)
path = db.Column(db.String(255), nullable=False)
status = db.Column(db.SmallInteger, index=True, default=1) # 1=图片 2=附件 3=头像
ext = db.Column(db.String(64), nullable=False)
size = db.Column(db.Integer, nullable=False)
deleted = db.Column(db.Boolean, index=True, default=False) # True = 回收站
create_time = db.Column(db.DateTime, index=True, default=datetime.datetime.now)
folder_id = db.Column(db.String(36), db.ForeignKey('db_folder.folder_id', ondelete='CASCADE'))
__table_args__ = (table_args())
def to_json(self):
dict = self.__dict__
if "_sa_instance_state" in dict:
del dict["_sa_instance_state"]
if "create_time" in dict:
dict["create_time"] = dict["create_time"].strftime('%Y-%m-%d %H:%M:%S')
return dict
def __repr__(self):
return '<Document %r>' % self.name
class Artist(db.Model):
__tablename__ = 'Artist'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
city = db.Column(db.String(120))
state = db.Column(db.String(120))
phone = db.Column(db.String(120))
genres = db.Column(db.String(120))
image_link = db.Column(db.String(500))
facebook_link = db.Column(db.String(120))
# TODO: implement any missing fields, as a database migration using Flask-Migrate
website = db.Column(db.String(120))
seeking_venue = db.Column(db.Boolean, nullable=False, default=False)
seeking_description = db.Column(db.String(120))
venues = db.relationship('Venue', secondary='shows')
shows = db.relationship('Show', backref=('artists'))
def to_dict(self):
""" Returns a dictinary of artists """
return {
'id': self.id,
'name': self.name,
'city': self.city,
'state': self.state,
'phone': self.phone,
'genres': self.genres.split(','), # convert string to list
'image_link': self.image_link,
'facebook_link': self.facebook_link,
'website': self.website,
'seeking_venue': self.seeking_venue,
'seeking_description': self.seeking_description,
}
def __repr__(self):
return f'<Artist {self.id} {self.name}>'
class ModelHome(db.Model):
__tablename__ = "model_home"
home_name = db.Column(db.String(32), primary_key=True)
home_create_datetime = db.Column(db.DateTime, nullable=False)
home_create_name = db.Column(db.DateTime, nullable=False)
class Post(CommentMixin, TimestampMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.Text, nullable=False)
name = db.Column(db.Text, nullable=False)
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship(Category,
back_populates='posts',
lazy='subquery')
tags = db.relationship(Tag,
secondary=tags_assoc,
lazy='subquery',
back_populates='posts')
def comment_loc(self) -> str:
return '.'.join(['posts', str(self.id)])
def update_from_dict(self, modify):
json_dict = self.to_dict()
json_dict.update(modify)
model_dict = Post._json_to_model_dict(json_dict)
print(model_dict)
self.name = model_dict['name']
self.category = model_dict['category']
self.tags = model_dict['tags']
self.text = model_dict['text']
self.updated = datetime.utcnow()
def to_dict(self):
return {
'name': self.name,
'category': self.category.name,
'tags': [x.name for x in self.tags],
'updated': rfc3339(self.updated),
'text': self.text
}
def to_excerpt_dict(self):
return {
'name': self.name,
'category': self.category.name,
'tags': [x.name for x in self.tags],
'updated': rfc3339(self.updated),
'excerpt': self.text[:option.get_option(Config.excerptLength)]
}
@staticmethod
def from_dict(d: dict):
d = Post._json_to_model_dict(d)
# noinspection PyArgumentList
return Post(**d)
@staticmethod
def _json_to_model_dict(d: dict, auto_create=True):
d = deepcopy(d)
try:
category_model = Category.query.filter_by(name=d['category']).one()
except NoResultFound as e:
if auto_create:
category_model = Category(name=d['category'])
else:
raise e
d['category'] = category_model
def tag_transform(x):
try:
return Tag.query.filter_by(name=x).one()
except NoResultFound:
if auto_create:
return Tag(name=x)
else:
raise e
d['tags'] = [tag_transform(x) for x in d['tags']]
return d
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
posts = db.relationship('Post', back_populates='category', lazy=True)
class Admin(db.Model):
'''
管理员
'''
__tablename__ = 'db_admin'
id = db.Column(db.Integer, nullable=False, primary_key=True, index=True, autoincrement=True)
admin_id = db.Column(db.String(36), index=True, nullable=False, unique=True)
username = db.Column(db.String(64), index=True, nullable=False, unique=True)
password = db.Column(db.String(32), nullable=False)
nickname = db.Column(db.String(64), default=None)
email = db.Column(db.String(255), default=None)
sex = db.Column(db.SmallInteger, default=1)
avatar = db.Column(db.String(255), default=None)
disable = db.Column(db.Boolean, index=True, default=False)
create_time = db.Column(db.DateTime, index=True, default=datetime.datetime.now)
update_time = db.Column(db.DateTime, default=datetime.datetime.now, onupdate=datetime.datetime.now)
role_id = db.Column(db.String(36), db.ForeignKey('db_role.role_id', ondelete='CASCADE'))
__table_args__ = (table_args())
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return str(self.admin_id)
def to_json(self):
dict = self.__dict__
if "_sa_instance_state" in dict:
del dict["_sa_instance_state"]
if "update_time" in dict:
dict["update_time"] = dict["update_time"].strftime('%Y-%m-%d %H:%M:%S')
if "create_time" in dict:
dict["create_time"] = dict["create_time"].strftime('%Y-%m-%d %H:%M:%S')
return dict
def __repr__(self):
return '<admin %r>' % self.username
class Headquarters(db.Model):
__tablename__ = 'headquarters'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String())
description = db.Column(db.String())
size = db.Column(db.Integer, db.ForeignKey('headquarters_size.id'))
toughness = db.Column(db.Integer)
cost = db.Column(db.Integer)
shared = db.Column(db.Boolean)
addon = db.Column(db.Boolean)
feature = db.Column(db.Boolean)
all = db.Column(db.Boolean)
current = db.Column(db.Boolean)
any = db.Column(db.Boolean)
var = db.Column(db.Boolean)
none = db.Column(db.Boolean)
show = db.Column(db.Boolean)
approved = db.Column(db.Boolean)
base = db.Column(db.Boolean)
def format(self):
return {
'id': self.id,
'name': self.name,
'description': self.description,
'size': self.size,
'toughness': self.toughness,
'cost': self.cost,
'shared': self.shared,
'addon': self.addon,
'feature': self.feature,
'all': self.all,
'current': self.current,
'any': self.any,
'var': self.var,
'none': self.none,
'show': self.show,
'approved': self.approved,
'base': self.base
}
class BaseModel(db.Model):
__abstract__ = True # 作用：不会作为普通模型的创建对应的表(抽象模型)
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(20), unique=True, nullable=False)
SEVENTY_FIVE = 75
HUNDERD = 100
ERROR = 101
OCCUPY_RESOURCE_PRECENT_CN = {
EMPTY: "",
TWENTY_FIVE: "twenty-five",
FIFTY: "fifty",
SEVENTY_FIVE: "seventy-five",
HUNDERD: "hundred",
ERROR: "error"
}
ad_position_unit_table = db.Table(
'searchAd_ad_position_unit',
db.Column('position_id', db.Integer, db.ForeignKey('ad_position.id')),
db.Column('unit_id', db.Integer, db.ForeignKey('ad_unit.id')))
class searchAdMedium(db.Model, BaseModelMixin, AttachmentMixin, CommentMixin):
__tablename__ = 'searchAd_medium'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
abbreviation = db.Column(db.String(100))
owner_id = db.Column(db.Integer, db.ForeignKey('team.id'))
owner = db.relationship('Team',
backref=db.backref('searchAd_mediums',
lazy='dynamic'))
tax_num = db.Column(db.String(100)) # 税号
address = db.Column(db.String(100)) # 地址
class Transactions(db.Model):
id = db.Column(db.Integer, primary_key=True)
payment_method_id = db.Column(db.Integer,
db.ForeignKey('payment_method.id',
ondelete='CASCADE'),
nullable=False,
default=1)
shipment_method_id = db.Column(db.Integer,
db.ForeignKey('shipment_method.id',
ondelete='CASCADE'),
nullable=False,
default=1)
insurance_method_id = db.Column(db.Integer,
db.ForeignKey('insurance_method.id',
ondelete='CASCADE'),
nullable=False,
default=1)
shipment_price = db.Column(db.Float, default=100)
insurance_price = db.Column(db.Float, default=0)
total = db.Column(db.Float)
payment_status = db.Column(db.Integer, nullable=True)
receiver_name = db.Column(db.String(50))
receiver_phone = db.Column(db.String(14))
receiver_address = db.Column(db.String(500))
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime, default=db.func.current_timestamp())
def __repr__(self):
return "<Transactions %r>" % self.id
class searchAdMedium(db.Model, BaseModelMixin, AttachmentMixin, CommentMixin):
__tablename__ = 'searchAd_medium'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
abbreviation = db.Column(db.String(100))
owner_id = db.Column(db.Integer, db.ForeignKey('team.id'))
owner = db.relationship('Team',
backref=db.backref('searchAd_mediums',
lazy='dynamic'))
tax_num = db.Column(db.String(100)) # 税号
address = db.Column(db.String(100)) # 地址
phone_num = db.Column(db.String(100)) # 电话
bank = db.Column(db.String(100)) # 银行
bank_num = db.Column(db.String(100)) # 银行号
rebates = db.relationship('searchAdMediumRebate')
__mapper_args__ = {'order_by': id.desc()}
def __init__(self,
name,
owner,
abbreviation=None,
tax_num="",
address="",
phone_num="",
bank="",
bank_num=""):
self.name = name
self.owner = owner
self.abbreviation = abbreviation or ""
self.tax_num = tax_num
self.address = address
self.phone_num = phone_num
self.bank = bank
self.bank_num = bank_num
@classmethod
def name_exist(cls, name):
is_exist = searchAdMedium.query.filter_by(name=name).count() > 0
return is_exist
@property
def current_framework(self):
return framework_generator(self.id)
@property
def tax_info(self):
return {
'tax_num': self.tax_num or '',
'address': self.address or '',
'phone_num': self.phone_num or '',
'bank': self.bank or '',
'bank_num': self.bank_num or '',
'abbreviation': self.abbreviation or ''
}
def sale_money_report_by_month(self, month):
month_day = datetime.datetime.now().replace(month=month,
day=1,
hour=0,
minute=0,
second=0,
microsecond=0)
return sum([
k.sale_money
for k in searchAdMediumOrderExecutiveReport.query.join(Order).
filter(searchAdOrder.medium_id == self.id,
searchAdMediumOrderExecutiveReport.month_day == month_day)
if k.status == 1
])
def sale_money_report_by_year(self):
start_month_day = datetime.datetime.now().replace(month=1,
day=1,
hour=0,
minute=0,
second=0,
microsecond=0)
end_month_day = start_month_day.replace(month=12,
day=1,
hour=0,
minute=0,
second=0,
microsecond=0)
return sum([
k.sale_money for k in
searchAdMediumOrderExecutiveReport.query.join(Order).filter(
searchAdOrder.medium_id == self.id,
searchAdMediumOrderExecutiveReport.month_day >=
start_month_day,
searchAdMediumOrderExecutiveReport.month_day <= end_month_day)
if k.status == 1
])
def medium_money2_report_by_month(self, month):
month_day = datetime.datetime.now().replace(month=month,
day=1,
hour=0,
minute=0,
second=0,
microsecond=0)
return sum([
k.medium_money2
for k in searchAdMediumOrderExecutiveReport.query.join(Order).
filter(searchAdOrder.medium_id == self.id,
searchAdMediumOrderExecutiveReport.month_day == month_day)
if k.status == 1
])
def medium_money2_report_by_year(self):
start_month_day = datetime.datetime.now().replace(month=1,
day=1,
hour=0,
minute=0,
second=0,
microsecond=0)
end_month_day = start_month_day.replace(month=12,
day=1,
hour=0,
minute=0,
second=0,
microsecond=0)
return sum([
k.medium_money2 for k in
searchAdMediumOrderExecutiveReport.query.join(Order).filter(
searchAdOrder.medium_id == self.id,
searchAdMediumOrderExecutiveReport.month_day >=
start_month_day,
searchAdMediumOrderExecutiveReport.month_day <= end_month_day)
if k.status == 1
])
def rebate_by_year(self, year):
rebate = [k for k in self.rebates if k.year.year == int(year)]
if len(rebate) > 0:
return rebate[0].rebate
return 0
def medium_path(self):
return url_for('searchAd_client.medium_detail', medium_id=self.id)
class searchAdAgent(db.Model, BaseModelMixin, AttachmentMixin, CommentMixin):
__tablename__ = 'searchAd_agent'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
group_id = db.Column(db.Integer, db.ForeignKey('searchAd_bra_group.id'))
group = db.relationship('searchAdGroup',
backref=db.backref('agents', lazy='dynamic'))
tax_num = db.Column(db.String(100)) # 税号
address = db.Column(db.String(100)) # 地址
phone_num = db.Column(db.String(100)) # 电话
bank = db.Column(db.String(100)) # 银行
bank_num = db.Column(db.String(100)) # 银行号
rebates = db.relationship('searchAdAgentRebate')
def __init__(self,
name,
group=None,
tax_num="",
address="",
phone_num="",
bank="",
bank_num=""):
self.name = name
self.group = group
self.tax_num = tax_num
self.address = address
self.phone_num = phone_num
self.bank = bank
self.bank_num = bank_num
@classmethod
def name_exist(cls, name):
is_exist = searchAdAgent.query.filter_by(name=name).count() > 0
return is_exist
@property
def current_framework(self):
return framework_generator(self.id)
@property
def tax_info(self):
return {
'tax_num': self.tax_num or '',
'address': self.address or '',
'phone_num': self.phone_num or '',
'bank': self.bank or '',
'bank_num': self.bank_num or ''
}
def inad_rebate_by_year(self, year):
rebate = [k for k in self.rebates if k.year.year == int(year)]
if len(rebate) > 0:
return rebate[0].inad_rebate
return 0
def douban_rebate_by_year(self, year):
rebate = [k for k in self.rebates if k.year.year == int(year)]
if len(rebate) > 0:
return rebate[0].douban_rebate
return 0
def get_client_order_count(self):
return searchAdClientOrder.query.filter_by(agent_id=self.id).count()
# def get_douban_order_count(self):
# return DoubanOrder.query.filter_by(agent_id=self.id).count()
# def get_framework_order_count(self):
# return len([k for k in FrameworkOrder.all() if self in k.agents])
def get_agent_invoice_count(self):
return searchAdAgentInvoice.query.filter_by(agent_id=self.id).count()
def agent_path(self):
return url_for('searchAd_client.agent_detail', agent_id=self.id)
class AggregateLog(db.Model):
id = db.Column(db.Integer, primary_key=True)
from_time = db.Column(db.DateTime, nullable=False, index=True)
to_time = db.Column(db.DateTime, nullable=False, index=True)
day_of_month = db.Column(db.Integer, nullable=False)
day_of_week = db.Column(db.Integer, nullable=False)
hour_of_day = db.Column(db.Integer, nullable=False)
minute_of_hour = db.Column(db.Integer, nullable=False)
# Let this column hold a map of all sites accessed
# Where
# key = website name
# Value = times accessed
dns_queries = db.Column(db.JSON, nullable=False)
total_dns_queries = db.Column(db.Integer, nullable=False)
# Let this column hold a map of all hosts seen
# Where
# key = host's MAC address
# value = number of times seen in the 15 minute window of this aggregation
hosts = db.Column(db.JSON, nullable=False)
total_hosts = db.Column(db.Integer, nullable=False)
# The value of the last occupancy-status flag maybe?
# Or a pctage duration for which the home was occupied during this 15 minute window
# Use a percentage -- If this is problematic, it can be rounded to a bit value
occupied = db.Column(db.Float, nullable=False)
