class Doc(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
database = db.Column(db.String(128))
table = db.Column(db.String(256))
env = db.Column(db.String(128))
pkey = db.Column(db.String(256))
init_len = db.Column(db.String(128))
max_len = db.Column(db.String(128))
desc = db.Column(db.Text)
example = db.Column(db.Text)
mainten_uid = db.Column(db.Text)
opt_uid = db.Column(db.Text)
create_uid = db.Column(db.String(128), db.ForeignKey("user.uid"))
create_time = db.Column(db.DateTime)
modify_uid = db.Column(db.String(128), db.ForeignKey("user.uid"))
modify_time = db.Column(db.DateTime)
is_del = db.Column(db.Boolean, default=False)
historys = db.relationship("DocHistory")
fields = db.relationship("DocField")
indexs = db.relationship("DocIndex")
def _to_dict(self):
_dict = self.to_dict()
_dict["indexs"] = [i.to_dict() for i in self.indexs]
_dict["fields"] = [f.to_dict() for f in self.fields]
return _dict
class ProjectScheduleMember(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
uid = db.Column(db.String(128), db.ForeignKey("user.uid"))
schedule_id = db.Column(db.Integer, db.ForeignKey("project_schedule.id"))
def __init__(self, _dict):
self.uid = _dict["uid"]
@staticmethod
def _to_dict(self):
return self.to_dict()
class ReleaseService(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128), nullable=False)
type = db.Column(db.String(128), nullable=False)
database = db.Column(db.String(128))
table = db.Column(db.String(128))
databases = db.relationship("ReleaseDatabase")
release_id = db.Column(db.Integer, db.ForeignKey("release.id"))
@staticmethod
def _to_dict(self):
service = self.to_dict()
service["databases"] = [ReleaseDatabase._to_dict(d) for d in self.databases]
return service
def __init__(self, _dict):
self.name = _dict["name"]
self.type = _dict["type"]
databases = [d for d in _dict["database"].split("|") if d != ""]
tables = [t for t in _dict["table"].split("|") if t != ""]
if len(databases) != len(tables):
raise ExceptionEx("表格式错误")
def format_database(database, table):
_database = {"name": database.strip()}
def format_tables(table):
return [{"name": t.strip()} for t in table.split(",")]
_database["table"] = [t for t in format_tables(table)]
return _database
_dict["database"] = [format_database(databases[i], tables[i]) for i in range(0, len(databases))]
self.databases = [Database.to_cls(ReleaseDatabase, t) for t in _dict["database"]]
class ProjectNotice(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
type = db.Column(db.String(128))
txt = db.Column(db.Text)
uid = db.Column(db.String(128), db.ForeignKey("user.uid"))
time = db.Column(db.DateTime)
def __init__(self, _dict):
for k, v in _dict.items():
setattr(self, k, v)
self.uid = session[USER_SESSION]["uid"]
self.time = datetime.now()
@staticmethod
def add(_dict):
notice = ProjectNotice(_dict)
db.session.add(notice)
db.session.commit()
return notice
@staticmethod
def _to_dict(self):
return self.to_dict()
@staticmethod
def select(page=0, pre_page=None):
return ProjectNotice.query.paginate(page, pre_page, False).order_by(ProjectNotice.time.asc()).to_page(
ProjectNotice._to_dict)
class DocHistory(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
opt = db.Column(db.String(128))
type = db.Column(db.String(128))
content = db.Column(db.Text)
create_uid = db.Column(db.String(128), db.ForeignKey("user.uid"))
create_time = db.Column(db.DateTime)
doc_id = db.Column(db.Integer, db.ForeignKey("doc.id"))
def _to_dict(self):
hist = self.to_dict()
hist["content"] = json.loads(hist["content"])
return hist
class LogSqlalchemy(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
action = db.Column(db.Text)
table = db.Column(db.Text)
object = db.Column(db.Text)
uid = db.Column(db.String(128), db.ForeignKey("user.uid"))
create_time = db.Column(db.DateTime)
class Idc_host_ps(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
cpu_usage = db.Column(db.Text)
cmd = db.Column(db.Text)
pid = db.Column(db.Text)
mem_usage = db.Column(db.Text)
user = db.Column(db.Text)
ports = db.Column(db.Text)
idc_host_id = db.Column(db.Integer, db.ForeignKey("idc_host.id"))
def __init__(self, submit):
submit["ports"] = ",".join(submit["ports"])
BaseModel.__init__(self, submit)
@classmethod
def add(cls, _dicts, auto_commit=True):
idc_host = Idc_host.query.filter(Idc_host.id == _dicts).one()
client = Client(app.config["SSH_IDC_HOST"], app.config["SSH_IDC_USER"],
app.config["SSH_IDC_PASSWORD"])
def exec_script(path):
info = client.exec_script(path, idc_host.ip, False)
return json.loads(info.replace("u'", "'").replace("'", "\""))
idc_host.ps_info = [
Database.to_cls(Idc_host_ps, _dict) for _dict in exec_script(
"/root/csfscript/host_info/get_ps_info.py")
]
Idc_host_ps.query.filter(Idc_host_ps.idc_host_id == None).delete()
db.session.commit()
return True
class DocField(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
no = db.Column(db.Integer)
name = db.Column(db.String(128))
type = db.Column(db.String(128))
desc = db.Column(db.String(128))
doc_id = db.Column(db.Integer, db.ForeignKey("doc.id"))
class Idc_host_disk(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
device = db.Column(db.Text)
mount = db.Column(db.Text)
size_available = db.Column(db.Text)
size_total = db.Column(db.Text)
idc_host_id = db.Column(db.Integer, db.ForeignKey("idc_host.id"))
class DocIndex(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
no = db.Column(db.Integer)
name = db.Column(db.String(128))
field = db.Column(db.String(128))
desc = db.Column(db.String(128))
is_unique = db.Column(db.Boolean)
doc_id = db.Column(db.Integer, db.ForeignKey("doc.id"))
class Idc_host_interface(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
mac_address = db.Column(db.Text)
interface_name = db.Column(db.Text)
ip_address = db.Column(db.Text)
ip_address_mask = db.Column(db.Text)
ip_address_mt = db.Column(db.Text)
idc_host_id = db.Column(db.Integer, db.ForeignKey("idc_host.id"))
class PurchaseGoods(db.Model): # 采购物品
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
price = db.Column(db.Float)
spec = db.relationship("Category",
secondary=purchase_goods_spec,
backref=db.backref("specs"),
uselist=False)
amount = db.Column(db.Integer)
purchase_id = db.Column(db.Integer, db.ForeignKey("purchase.id"))
category = db.relationship("Category",
secondary=purchase_goods_category,
backref=db.backref("goods"),
uselist=False)
def __init__(self, _dict):
from bmp.models.asset import Category
self.category = Category.query.filter(
Category.id == _dict["category_id"]).one()
self.price = _dict["price"]
self.spec = Category.query.filter(
Category.id == _dict["spec_id"]).one()
self.amount = _dict["amount"]
@staticmethod
def _to_dict(self, inc_purchase=False):
_dict = self.to_dict()
category = self.category
spec = self.spec
purchase = self.purchase
if category:
_dict["category"] = category.to_dict()
if spec:
_dict["spec"] = spec.to_dict()
for k, v in purchase.to_dict().items():
if not _dict.__contains__(k):
_dict[k] = v
return _dict
@staticmethod
def between(beg, end):
return [
PurchaseGoods._to_dict(p, True)
for p in PurchaseGoods.query.join(Purchase).join(
PurchaseApproval, PurchaseApproval.purchase_id ==
PurchaseGoods.purchase_id).filter(
PurchaseApproval.status != PURCHASE.FAIL).filter(
Purchase.is_finished == True).filter(
Purchase.is_draft == False).filter(
Purchase.apply_time >= beg).filter(
Purchase.apply_time <= end).all()
]
class ReleaseTable(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128))
release_database_id = db.Column(db.Integer, db.ForeignKey("release_database.id"))
def __init__(self, _dict):
self.name = _dict["name"]
@staticmethod
def _to_dict(self):
return self.to_dict()
class AccessDeployHistory(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
create_uid = db.Column(db.String(128), db.ForeignKey("user.uid"))
create_time = db.Column(db.DateTime)
type = db.Column(db.String(128))
detail = db.Column(db.Text)
def _to_dict(self):
hist = self.to_dict()
hist["detail"] = json.loads(hist["detail"])
return hist
class ReleaseLog(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
content = db.Column(db.Text)
release_id = db.Column(db.Integer, db.ForeignKey("release.id"))
def __init__(self, content):
self.content = content["content"]
@staticmethod
def _to_dict(self):
return self.to_dict()
class ReleaseApproval(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
type = db.Column(db.String(128))
uid = db.Column(db.String(128), db.ForeignKey("user.uid"), nullable=False)
status = db.Column(db.String(128), nullable=False)
reson = db.Column(db.String(128))
desc = db.Column(db.String(128))
options = db.Column(db.String(128))
release_id = db.Column(db.Integer, db.ForeignKey("release.id"))
def __init__(self, _dict=None):
self.type = _dict["type"]
self.status = _dict["status"]
self.reson = _dict["reson"]
self.desc = _dict["desc"]
self.options = _dict["options"]
self.uid = _dict["uid"]
@staticmethod
def edit(id, submit):
approval = ReleaseApproval.query.filter(
ReleaseApproval.release_id == id,
ReleaseApproval.type == submit["type"])
if approval.count():
raise ExceptionEx("%s 已审批" % submit["type"])
_approval = ReleaseApproval(submit)
_approval.release_id = id
release = Release.query.filter(Release.id == id).one()
if _approval.status == RELEASE.FAIL or len(release.approvals) == 2:
release.is_finished = True
db.session.add(_approval)
db.session.commit()
return True
@staticmethod
def _to_dict(self):
return self.to_dict()
class ReportTeam(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128))
is_del = db.Column(db.Boolean, default=False)
create_uid = db.Column(db.String(128), db.ForeignKey("user.uid"))
editors = db.relationship("ReportEditor")
@staticmethod
def _to_dict(self):
_dict=self.to_dict()
_dict["editors"] = [ReportEditor._to_dict(editor) for editor in self.editors]
return _dict
class Access(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
type = db.Column(db.String(128))
status = db.Column(db.String(128))
content = db.Column(db.Text)
copy_to_uid = db.Column(db.Text, default="")
approval_uid = db.Column(db.String(128), db.ForeignKey("user.uid"))
approval_time = db.Column(db.DateTime)
approval_reson = db.Column(db.String(256))
apply_uid = db.Column(db.String(128), db.ForeignKey("user.uid"))
dept = db.Column(db.String(128), default="")
apply_time = db.Column(db.DateTime)
apply_reson = db.Column(db.String(256))
@staticmethod
def _to_dict(self):
_dict = self.to_dict()
_dict["apply_user"] = User.get(_dict["apply_uid"])
_dict["content"] = json.loads(_dict["content"])
return _dict
class ProjectHistory(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
fields = db.Column(db.Text)
modify_uid = db.Column(db.String(128), db.ForeignKey("user.uid"))
modify_time = db.Column(db.DateTime)
project_id = db.Column(db.Integer, db.ForeignKey("project.id"))
def __init__(self, _dict):
self.fields = json.dumps(_dict)
self.project_id = _dict["project_id"]
self.modify_uid = session[USER_SESSION]["uid"]
self.modify_time = datetime.now()
@staticmethod
def add(pid, action, _dict):
_dict["action"] = action
_dict["project_id"] = pid
ph = ProjectHistory(_dict)
db.session.add(ph)
@staticmethod
def _to_dict(self):
return self.to_dict()
class ReleaseDatabase(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128))
tables = db.relationship("ReleaseTable")
release_service_id = db.Column(db.Integer, db.ForeignKey("release_service.id"))
@staticmethod
def _to_dict(self):
database = self.to_dict()
database["tables"] = [t.to_dict() for t in self.tables]
return database
def __init__(self, _dict):
self.name = _dict["name"]
self.tables = [Database.to_cls(ReleaseTable, t) for t in _dict["table"]]
class Report(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
score = db.Column(db.Integer, default=0)
prog = db.Column(db.Integer, default=0)
schedule = db.Column(db.Text)
schedule_next = db.Column(db.Text)
issues = db.relationship("ReportIssue")
team_id = db.Column(db.Integer, db.ForeignKey("report_team.id"))
create_time = db.Column(db.DateTime)
feedback = db.Column(db.String(256))
@staticmethod
def _to_dict(self):
_dict = self.to_dict()
_dict["issues"] = [ReportIssue._to_dict(issue) for issue in self.issues]
return _dict
class LeaveEvent(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
desc = db.Column(db.String(128), default="", nullable=True)
type_id = db.Column(db.Integer, db.ForeignKey("ref.id"))
begin_time = db.Column(db.DateTime)
end_time = db.Column(db.DateTime)
@staticmethod
def between(beg, end):
query = LeaveEvent.query \
.filter(or_(
and_(LeaveEvent.begin_time >= beg, LeaveEvent.end_time <= end, LeaveEvent.begin_time <= end,
LeaveEvent.end_time >= beg),
and_(LeaveEvent.begin_time <= beg, LeaveEvent.end_time >= beg),
and_(LeaveEvent.begin_time <= end, LeaveEvent.end_time >= end)))
return [LeaveEvent._to_dict(l) for l in query.all()]
class PurchaseImg(db.Model): # 比价图片
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
b64 = db.Column(db.Text)
desc = db.Column(db.String(128))
path = db.Column(db.String(256))
purchase_id = db.Column(db.Integer, db.ForeignKey("purchase.id"))
def __init__(self, _dict):
if _dict.__contains__("b64"):
self.b64 = _dict["b64"]
else:
self.b64 = ""
self.desc = _dict["desc"]
self.path = _dict["path"]
@staticmethod
def _to_dict(self):
return self.to_dict()
class Contract(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
desc = db.Column(db.String(128))
begin_time = db.Column(db.DateTime)
end_time = db.Column(db.DateTime)
purchase_id = db.Column(db.Integer, db.ForeignKey("purchase.id"))
path = db.Column(db.String(256)) # 合同文件路径
@staticmethod
def _to_dict(contract):
_dict = contract.to_dict()
from bmp.models.purchase import Purchase
purchase = contract.purchase
if purchase:
purchase = Purchase._to_dict(purchase)
purchase.pop("imgs")
purchase.pop("contract")
_dict["purchase"] = purchase
return _dict
class ProjectDoc(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
url = db.Column(db.String(1024))
project_id = db.Column(db.Integer, db.ForeignKey("project.id"))
def __init__(self, _dict):
self.url = _dict["url"]
if _dict.__contains__("project_id"):
self.project_id = _dict["project_id"]
@staticmethod
def add(submit):
db.session.add(ProjectDoc(submit))
db.session.commit()
@staticmethod
def delete(pid):
doc = ProjectDoc.query.filter(ProjectDoc.id == pid).one()
db.session.delete(doc)
db.session.commit()
@staticmethod
def _to_dict(self):
return self.to_dict()
class ReportEditor(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
editor_uid = db.Column(db.String(128), db.ForeignKey("user.uid"))
team_id = db.Column(db.Integer, db.ForeignKey("report_team.id"))
class Release(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
project = db.Column(db.String(128), nullable=False)
content = db.Column(db.String(256))
copy_to_uid = db.Column(db.String(128), db.ForeignKey("user.uid"))
release_time = db.Column(db.DateTime, nullable=False)
apply_uid = db.Column(db.String(128), db.ForeignKey("user.uid"), nullable=False)
apply_group = db.Column(db.String(128), nullable=False)
apply_time = db.Column(db.DateTime, nullable=False)
_from = db.Column(db.String(128), nullable=False)
to = db.Column(db.String(256), nullable=False)
approvals = db.relationship("ReleaseApproval")
service = db.relationship("ReleaseService", uselist=False)
log = db.relationship("ReleaseLog", uselist=False)
release_type = db.Column(db.String(64), default="")
is_draft = db.Column(db.Boolean, default=True)
is_finished = db.Column(db.Boolean, default=False)
is_deployed = db.Column(db.Boolean, default=False)
is_deploying = db.Column(db.Boolean, default=False)
deploy_time = db.Column(db.DateTime)
deploy_times = db.Column(db.Integer, default=0)
def __init__(self, _dict):
for k, v in _dict.items():
if "release_time" == k:
setattr(self, k, datetime.strptime(v, "%Y-%m-%d %H:%M"))
elif "service" == k:
self.service = Database.to_cls(ReleaseService, v)
else:
setattr(self, k, v)
@staticmethod
def _to_dict(release, show_log=False):
_release = release.to_dict()
_release["approvals"] = [a.to_dict() for a in release.approvals]
_release["service"] = ReleaseService._to_dict(release.service)
if show_log:
log = release.log
if log:
_release["log"] = log.content
else:
_release["log"] = ""
return _release
@staticmethod
def get_log(rid):
release = Release.query.filter(Release.id == rid).one()
log = release.log
if not log: return ""
return log.content.replace("\n", "\r")
@staticmethod
def add_log(rid, log_path):
with open(log_path) as log:
__dict = {"content": log.read()}
release = Release.query.filter(Release.id == rid).one()
query_log = ReleaseLog.query.filter(ReleaseLog.release_id == rid)
if query_log.count():
__dict["id"] = query_log.one().id
release.log = Database.to_cls(ReleaseLog, __dict)
db.session.commit()
return True
@staticmethod
def select(page, pre_page):
page = Release.query.order_by(Release.apply_time.desc()).paginate(page, pre_page)
return page.to_page(Release._to_dict)
@staticmethod
def unfinished(page, pre_page):
page = Release.query \
.filter(Release.is_finished == False) \
.filter(or_(Release.is_draft == None, Release.is_draft == False)) \
.order_by(Release.apply_time.desc()) \
.paginate(page, pre_page)
return page.to_page(Release._to_dict)
@staticmethod
def drafts(page, pre_page):
page = Release.query \
.filter(Release.is_finished == False) \
.filter(Release.is_draft == True) \
.filter(Release.apply_uid == session[USER_SESSION]["uid"]) \
.order_by(Release.apply_time.desc()) \
.paginate(page, pre_page)
return page.to_page(Release._to_dict)
@staticmethod
def self(page, pre_page):
page = Release.query \
.filter(Release.is_finished == False) \
.filter(or_(Release.is_draft == None, Release.is_draft == False)) \
.filter(Release.apply_uid == session[USER_SESSION]["uid"]) \
.order_by(Release.apply_time.desc()) \
.paginate(page, pre_page)
return page.to_page(Release._to_dict)
@staticmethod
def deployed(page, pre_page):
page = Release.query \
.filter(Release.is_deployed == True) \
.order_by(Release.apply_time.desc()) \
.paginate(page, pre_page)
return page.to_page(Release._to_dict)
@staticmethod
def undeployed(page, pre_page):
page = Release.query \
.join(ReleaseApproval) \
.join(ReleaseService) \
.filter(ReleaseService.name == RELEASE_SERVICE.DATA_BASE) \
.filter(Release.is_finished == False) \
.filter(ReleaseApproval.type == RELEASE.FLOW_TEST) \
.filter(ReleaseApproval.status == RELEASE.PASS) \
.filter(Release.is_deployed == False) \
.order_by(Release.apply_time.desc()) \
.paginate(page, pre_page)
return page.to_page(Release._to_dict)
@staticmethod
def finished(page, pre_page):
page = Release.query \
.filter(Release.is_finished == True) \
.order_by(Release.apply_time.desc()) \
.paginate(page, pre_page)
return page.to_page(Release._to_dict)
@staticmethod
def between(begin, end):
return [Release._to_dict(release) for release in
Release.query.filter(Release.apply_time.between(begin, end)).all()]
@staticmethod
def get(rid):
return Release._to_dict(Release.query.filter(Release.id == rid).one())
@staticmethod
def add(submit):
from bmp.models.user import User
user = User.query.filter(User.uid == session[USER_SESSION]["uid"]).one()
release = Database.to_cls(Release, submit)
release.approvals = []
release.apply_uid = user.uid
if user.groups:
release.apply_group = user.groups[0].name
else:
release.apply_group = DEFAULT_GROUP.GUEST
release.apply_time = datetime.now()
db.session.add(release)
db.session.commit()
return release
@staticmethod
def edit(submit):
release = Database.to_cls(Release, submit)
db.session.commit()
return release
@staticmethod
def approval(id, submit):
approvals = ReleaseApproval.query.filter(
ReleaseApproval.release_id == id,
ReleaseApproval.type == submit["type"]).all()
if not approvals:
_approval = ReleaseApproval(submit)
_approval.release_id = id
db.session.add(_approval)
db.session.commit()
return True
_approval = approvals[0]
_approval.status = submit["status"]
_approval.reson = submit["reson"]
_approval.options = submit["options"]
db.session.commit()
return True
@staticmethod
def deploy(rid):
release = Release.query.filter(Release.id == rid).one()
release.is_deployed = True
db.session.commit()
return True
@staticmethod
def delete(pid):
release = Release.query.filter(Release.id == pid).one()
if not release.is_draft:
raise ExceptionEx("该申请已提交,无法删除")
db.session.delete(release)
db.session.commit()
class Stock(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
no = db.Column(db.String(128), unique=True)
category = db.relationship("Category",
secondary=stock_category,
backref=db.backref("stocks"),
uselist=False)
spec = db.relationship("Category",
secondary=stock_spec_category,
uselist=False)
purchase_id = db.Column(db.Integer, db.ForeignKey("purchase.id"))
stock_in_type = db.Column(db.String(128))
stock_in_uid = db.Column(db.String(128), db.ForeignKey("user.uid"))
stock_in_time = db.Column(db.DateTime)
warranty_time = db.Column(db.DateTime)
opts = db.relationship("StockOpt", backref=db.backref("stock"))
@staticmethod
def search(submit, page=None, pre_page=None):
from bmp.models.user import User
from bmp.models.purchase import Purchase
def check(s):
if submit.__contains__(s):
return submit[s]
return False
query = Stock.query \
.order_by(Stock.stock_in_time.desc()) \
.join(stock_category) \
.join(Category)
if check("status"):
if check("status") == STOCK.TYPE:
stock_ids = [
s.stock_id for s in StockOpt.query.filter(
StockOpt.status.in_(["", SCRAP.TYPE])).all()
]
query = query.join(User, Stock.stock_in_uid ==
User.uid).filter(~Stock.id.in_(stock_ids))
else:
query = query \
.join(StockOpt, Stock.id == StockOpt.stock_id) \
.join(User, StockOpt.uid == User.uid) \
.filter(StockOpt.status.in_(["", SCRAP.TYPE])) \
.filter(StockOpt.type == check("status"))
else:
query = query.join(User, Stock.stock_in_uid == User.uid)
if check("uid"):
query = query.filter(User.uid == submit["uid"])
if check("businessCategory"):
query = query.filter(
User.businessCategory == submit["businessCategory"])
if check("no"):
query = query.filter(Stock.no == submit["no"])
if check("stock_in_time_begin") and check("stock_in_time_end"):
beg = datetime.strptime(submit["stock_in_time_begin"], "%Y-%m-%d")
end = datetime.strptime(submit["stock_in_time_end"], "%Y-%m-%d")
query = query.filter(Stock.stock_in_time.between(beg, end))
if check("warranty_time_begin") and check("warranty_time_end"):
beg = datetime.strptime(submit["warranty_time_begin"], "%Y-%m-%d")
end = datetime.strptime(submit["warranty_time_end"], "%Y-%m-%d")
query = query.filter(Stock.stock_in_time.between(beg, end))
if check("category_id"):
ids = Category.get_child_ids(
submit["category_id"]) + [submit["category_id"]]
print(ids)
query = query.filter(Category.id.in_(ids))
if check("price_start") and check("price_end"):
query = query \
.join(Purchase, Purchase.id == Stock.purchase_id) \
.filter(Purchase.goods.price.between(
submit["price_start"], submit["price_end"]))
if page == None:
return [Stock._to_dict(p) for p in query.all()]
return query.paginate(page, pre_page, False).to_page(Stock._to_dict)
@staticmethod
def export(submit):
# 固定资产编号 入库时间 申请人 名称 状态 详细
_export = []
for stockopt in Stock.search(submit):
_dict = {}
stock = stockopt["stock"]
_dict["名称"] = stock["category"]["name"]
_dict["规格"] = stock["spec"]["name"]
_dict["入库时间"] = time.format(stock["stock_in_time"], "%Y-%m-%d")
_dict["固定资产编号"] = stock["no"]
_export.append(_dict)
return _export
def __init__(self, _dict):
BaseModel.__init__(self)
for k, v in _dict.items():
if k == "category_id":
query = Category.query.filter(Category.id == v)
if not query.count():
raise ExceptionEx("不存在的商品id")
self.category = query.one()
if k == "spec_id":
query = Category.query.filter(Category.id == v)
if not query.count():
raise ExceptionEx("不存在的规格id")
self.spec = query.one()
if "time" in k:
setattr(self, k, datetime.strptime(v, "%Y-%m-%d"))
elif k == "id":
pass
else:
setattr(self, k, v)
@classmethod
def add(cls, _dicts, auto_commit=True):
'''
固定资产编号 格式固定一下
部门+年+月+0001
比如：IT2015050001
:param auto_commit:
:return:
'''
if not _dicts.__contains__("no") or Stock.query \
.filter(Stock.no == _dicts["no"]).count():
raise ExceptionEx("库存编号已存在")
if not _dicts.__contains__("category_id"):
raise ExceptionEx("名称不能为空")
def create_no():
businessCategory = session[USER_SESSION]["businessCategory"]
today = datetime.strptime(_dicts["stock_in_time"], "%Y-%m-%d")
year, month = today.year, today.month
beg = datetime(year, month, 1)
if month == 12:
end = datetime(year, month, 31)
else:
end = datetime(year, month + 1, 1) - timedelta(days=1)
stocks = [
int(s.no[-4:]) for s in Stock.query.filter(
Stock.stock_in_time.between(beg, end)).all()
]
stocks.append(0)
return "%s%d%02d%04d" % (businessCategory.upper(), year, month,
max(stocks) + 1)
_dicts["no"] = create_no()
stock = Stock(_dicts)
db.session.add(stock)
if auto_commit:
db.session.commit()
else:
db.session.flush()
return stock
@classmethod
def edit(cls, _dicts, auto_commit=True):
if Stock.query.filter(Stock.no == _dicts["no"]).count():
raise ExceptionEx("库存编号已存在")
stock = Database.to_cls(Stock, _dicts)
if auto_commit:
db.session.commit()
else:
db.session.flush()
return stock
@staticmethod
def _to_dict(self, show_opt=False):
_dict = self.to_dict()
category = self.category
spec = self.spec
_dict["status"] = ""
if spec: _dict["spec"] = spec.to_dict()
if category: _dict["category"] = category.to_dict()
opts = self.opts
for opt in opts:
if opt.status.strip() in ["", SCRAP.TYPE]:
_dict["status"] = opt.type
if show_opt:
_dict["opts"] = [opt.to_dict() for opt in opts]
return _dict
@classmethod
def get(cls, _id, _filters=None):
return Stock._to_dict(Stock.query.filter(Stock.id == _id).one(), True)
@classmethod
def select(cls, page=None, pre_page=None, _filters=None, _orders=None):
query = Stock.query.order_by(Stock.stock_in_time.desc())
if _filters:
opts = StockOpt.query.filter(
StockOpt.status.in_(["", SCRAP.PASS, SCRAP.TYPE])).all()
in_opts = [opt.stock_id for opt in opts]
query = query.filter(~Stock.id.in_(in_opts))
page = query.paginate(page, pre_page)
return page.to_page(Stock._to_dict)
class ReportIssue(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
issue = db.Column(db.String(256))
checked = db.Column(db.Boolean)
report_id = db.Column(db.Integer, db.ForeignKey("report.id"))
class StockOpt(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
type = db.Column(db.String(64))
uid = db.Column(db.String(128), db.ForeignKey("user.uid"))
time = db.Column(db.DateTime)
reson = db.Column(db.String(128))
remark = db.Column(db.String(128))
status = db.Column(db.String(128))
update_time = db.Column(db.DateTime)
stock_id = db.Column(db.Integer, db.ForeignKey("stock.id"))
approval_uid = db.Column(db.String(128),
db.ForeignKey("user.uid"),
default="",
nullable=True)
approval_time = db.Column(db.DateTime, nullable=True)
approval_remark = db.Column(db.String(128), nullable=True)
def __init__(self, _dict):
if not _dict.__contains__("id"):
_dict["status"] = ""
elif _dict["type"] == SCRAP.TYPE:
_dict["approval_uid"] = session[USER_SESSION]["uid"]
_dict["approval_time"] = datetime.now().strftime("%Y-%m-%d")
_dict["update_time"] = datetime.now().strftime("%Y-%m-%d")
else:
_dict["update_time"] = datetime.now().strftime("%Y-%m-%d")
if not _dict.__contains__("stock_id"):
raise ExceptionEx("库存不能为空")
elif not Stock.query.filter(Stock.id == _dict["stock_id"]).count():
raise ExceptionEx("库存不存在")
BaseModel.__init__(self, _dict)
@staticmethod
def _to_dict(self):
stock = Stock._to_dict(self.stock, False)
opt = self.to_dict()
opt["stock"] = stock
return opt
@staticmethod
def approvals(page, pre_page): # todo 添加报废的审批组
page = StockOpt.query \
.filter(StockOpt.type == SCRAP.TYPE) \
.filter(StockOpt.status.in_(["", SCRAP.PASS, SCRAP.FAIL])).paginate(page, pre_page)
return page.to_page(StockOpt._to_dict)
@staticmethod
def search(submit, page=None, pre_page=None):
from bmp.models.user import User
from bmp.models.purchase import Purchase
# 固定资产编号 入库时间 申请人 申请部门 物品类别 价格范围 物品状态
def check(s):
if submit.__contains__(s):
return submit[s]
return False
query = StockOpt.query \
.order_by(StockOpt.time.desc()) \
.order_by(StockOpt.update_time.desc()) \
.join(User, User.uid == StockOpt.uid) \
.join(Stock, Stock.id == StockOpt.stock_id) \
.join(stock_category) \
.join(Category) \
.filter(StockOpt.status.in_(["", SCRAP.TYPE]))
if check("no"):
query = query.filter(Stock.no == submit["no"])
if check("stock_in_time_begin") and check("stock_in_time_end"):
beg = datetime.strptime(submit["stock_in_time_begin"], "%Y-%m-%d")
end = datetime.strptime(submit["stock_in_time_end"], "%Y-%m-%d")
query = query.filter(Stock.stock_in_time.between(beg, end))
if check("uid"):
query = query.filter(User.uid == submit["uid"])
if check("businessCategory"):
query = query.filter(
User.businessCategory == submit["businessCategory"])
if check("category_id"):
ids = Category.get_child_ids(
submit["category_id"]) + [submit["category_id"]]
query = query.filter(Category.id.in_(ids))
if check("price_start") and check("price_end"):
query = query \
.join(Purchase, Purchase.id == Stock.purchase_id) \
.filter(Purchase.goods.price.between(
submit["price_start"], submit["price_end"]))
if check("status"):
query = query.filter(StockOpt.type == check("status"))
if page == None:
return [StockOpt._to_dict(p) for p in query.all()]
return query.paginate(page, pre_page, False).to_page(StockOpt._to_dict)
@staticmethod
def export(submit):
# 固定资产编号 入库时间 申请人 名称 状态 详细
_export = []
for stockopt in StockOpt.search(submit):
_dict = {}
stock = stockopt["stock"]
_dict["状态"] = stockopt["status"]
_dict["名称"] = stock["category"]["name"]
_dict["申请人"] = stockopt["uid"]
_dict["入库时间"] = time.format(stock["stock_in_time"], "%Y-%m-%d")
_dict["固定资产编号"] = stock["no"]
_export.append(_dict)
return _export
