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 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 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 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 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 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 ProjectSchedule(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
type = db.Column(db.String(128))
begin_time = db.Column(db.DateTime)
end_time = db.Column(db.DateTime)
begin_time_create = db.Column(db.DateTime)
end_time_create = db.Column(db.DateTime)
status = db.Column(db.String(128))
update_status_time = db.Column(db.DateTime)
reson = db.Column(db.String(128))
desc = db.Column(db.String(256))
members = db.relationship("ProjectScheduleMember", backref=db.backref("schedule"))
project_id = db.Column(db.Integer, db.ForeignKey("project.id"))
def __init__(self, _dict):
for k, v in _dict.items():
if k == "members":
self.members = [Database.to_cls(ProjectScheduleMember, m) for m in _dict["members"]]
elif "time" in k:
setattr(self, k, datetime.strptime(v, "%Y-%m-%d"))
else:
setattr(self, k, v)
self.update_status_time = datetime.now().strftime("%Y-%m-%d")
@staticmethod
def _to_dict(self):
_dict = self.to_dict()
_dict["members"] = [m.to_dict() for m in self.members]
# _dict["_status"] = Project._schedule_status(self.status,self.end_time_create, self.end_time)
return _dict
@staticmethod
def add(_dict):
if ProjectSchedule.query \
.filter(ProjectSchedule.type == _dict["type"]) \
.filter(ProjectSchedule.project_id == _dict["project_id"]).count():
raise ExceptionEx("该阶段已添加")
_dict["begin_time_create"] = _dict["begin_time"]
_dict["end_time_create"] = _dict["end_time"]
schedule = ProjectSchedule(_dict)
db.session.add(schedule)
db.session.commit()
return True
@staticmethod
def edit(_dict):
ps = Database.to_cls(ProjectSchedule, _dict)
ProjectHistory.add(ps.project_id, PROJECT.EDIT_SCHEDULE(ps.type), _dict)
db.session.commit()
return True
@staticmethod
def edit_members(_dict):
ps = ProjectSchedule.query.filter(ProjectSchedule.id == _dict["schedule_id"]).one()
ps.members = [Database.to_cls(ProjectScheduleMember, m) for m in _dict["members"]]
ProjectHistory.add(ps.project_id, PROJECT.EDIT_MEMBER(ps.type), _dict)
db.session.commit()
class Project(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128), unique=True)
desc = db.Column(db.String(256))
tag = db.Column(db.String(256))
type_id = db.Column(db.Integer, db.ForeignKey("ref.id"))
summarize = db.Column(db.Text)
begin_time = db.Column(db.DateTime)
end_time = db.Column(db.DateTime)
demand_uid = db.Column(db.String(128), db.ForeignKey("user.uid"))
develop_uid = db.Column(db.String(128), db.ForeignKey("user.uid"))
test_uid = db.Column(db.String(128), db.ForeignKey("user.uid"))
release_uid = db.Column(db.String(128), db.ForeignKey("user.uid"))
create_uid = db.Column(db.String(128), db.ForeignKey("user.uid"))
man_day = db.Column(db.Integer)
resource = db.Column(db.Text)
docs = db.relationship("ProjectDoc", backref=db.backref("project"))
schedules = db.relationship("ProjectSchedule", backref=db.backref("project"))
historys = db.relationship("ProjectHistory", backref=db.backref("project"))
def __init__(self, _dict):
for k, v in _dict.items():
if "time" in k:
setattr(self, k, datetime.strptime(v, "%Y-%m-%d"))
else:
setattr(self, k, v)
self.create_uid = session[USER_SESSION]["uid"]
@staticmethod
def edit(_dict):
proj = Database.to_cls(Project, _dict)
ProjectHistory.add(proj.id, PROJECT.EDIT_PROJ, _dict)
db.session.commit()
return True
@staticmethod
def edit_doc(_dict):
ps = Project.query.filter(Project.id == _dict["project_id"]).one()
ps.docs = [Database.to_cls(ProjectDoc, d) for d in _dict["docs"]]
ProjectHistory.add(ps.id, PROJECT.EDIT_DOC, _dict)
db.session.commit()
@staticmethod
def add(_dict):
from bmp.models.user import User
if Project.query.filter(Project.name == _dict["name"]).count():
raise ExceptionEx("项目名 %s 已存在" % _dict["name"])
uids = User.uids()
for uid in [_dict[u] for u in _dict if "_uid" in u]:
if uid not in uids:
raise ExceptionEx("用户 %s 不存在" % uid)
proj = Project(_dict)
db.session.add(proj)
db.session.commit()
return proj
@staticmethod
def delete(pid):
proj = Project.query.filter(Project.id == pid).one()
db.session.delete(proj)
db.session.commit()
return True
@staticmethod
def _schedule_status(stat, src_time, dst_time):
status = PROJECT.STATUS_NEW
if not (src_time and dst_time):
return status
if stat != PROJECT.STATUS_FINISH:
if src_time == dst_time:
status = PROJECT.STATUS_ON_TIME
elif src_time > dst_time:
status = PROJECT.STATUS_ON_TIME
else:
status = PROJECT.STATUS_DELAY
else:
if src_time == dst_time:
status = PROJECT.STATUS_FINISH
elif src_time > dst_time:
status = PROJECT.STATUS_AHEAD
else:
status = PROJECT.STATUS_DELAY
return status
@staticmethod
def _to_dict(self):
_dict = self.to_dict()
_dict["schedules"] = [ProjectSchedule._to_dict(s) for s in self.schedules]
_dict["historys"] = [h.to_dict() for h in self.historys]
_dict["docs"] = [d.to_dict() for d in self.docs]
_dict["status"] = PROJECT.STATUS_NEW
for sche in _dict["schedules"]:
if sche["type"] == "release":
_dict["status"] = Project._schedule_status(sche["status"], _dict["end_time"], sche["end_time"])
return _dict
@staticmethod
def get(pid):
return Project._to_dict(Project.query.filter(Project.id == pid).one())
@staticmethod
def select(page=0, pre_page=None):
return Project.query.paginate(page, pre_page, False).to_page(Project._to_dict)
@staticmethod
def search(submit, page, pre_page):
def check(s):
if submit.__contains__(s):
return submit[s]
return False
query = Project.query
if check("name"):
query = query.filter(Project.name == check("name"))
if check("status") and (check("status") != PROJECT.STATUS_NEW):
query = query.join(ProjectSchedule).filter(ProjectSchedule.type == "release")
if check("status") == PROJECT.STATUS_ON_TIME:
query = query \
.filter(Project.end_time >= ProjectSchedule.end_time) \
.filter(ProjectSchedule.status != PROJECT.STATUS_FINISH)
elif check("status") == PROJECT.STATUS_AHEAD:
query = query \
.filter(Project.end_time > ProjectSchedule.end_time) \
.filter(ProjectSchedule.status == PROJECT.STATUS_FINISH)
elif check("status") == PROJECT.STATUS_FINISH:
query = query \
.filter(Project.end_time == ProjectSchedule.end_time) \
.filter(ProjectSchedule.status == PROJECT.STATUS_FINISH)
else:
query = query.filter(Project.end_time < ProjectSchedule.end_time)
elif check("status"):
proj_ids = [ps.project_id for ps in
ProjectSchedule.query
.filter(ProjectSchedule.type == "release")
.filter(ProjectSchedule.project_id != None)
.filter(ProjectSchedule.end_time != None).all()]
query = query.filter(~Project.id.in_(proj_ids))
return query.paginate(page, pre_page, False).to_page(Project._to_dict)
class Purchase(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
approvals = db.relationship("PurchaseApproval")
contract = db.relationship("Contract",
uselist=False,
backref=db.backref("purchase"))
imgs = db.relationship("PurchaseImg")
goods = db.relationship("PurchaseGoods", backref=db.backref("purchase"))
supplier = db.relationship("Supplier",
secondary=purchase_supplier,
backref=db.backref("purchases"),
uselist=False)
cur_approval_type = db.Column(db.String(128))
is_finished = db.Column(db.Boolean, default=False)
is_draft = db.Column(db.Boolean, default=True)
use = db.Column(db.Text)
reson = db.Column(db.String(256))
apply_uid = db.Column(db.String(128),
db.ForeignKey("user.uid"),
nullable=False)
apply_businessCategory = db.Column(db.String(128), nullable=False)
apply_time = db.Column(db.DateTime, nullable=False)
def __eq__(self, other):
return self.id == other.id
def __init__(self, submit):
goods, supplier, imgs, contract = submit["goods"], submit[
"supplier"], submit["imgs"], submit["contract"]
if not submit.__contains__("id"):
self.cur_approval_type = PURCHASE.FLOW_ONE
self.apply_time = datetime.now()
self.apply_businessCategory = session[USER_SESSION][
"businessCategory"]
self.apply_uid = session[USER_SESSION]["uid"]
self.goods = [Database.to_cls(PurchaseGoods, g) for g in goods]
self.supplier = supplier
if isinstance(imgs, list):
self.imgs = [Database.to_cls(PurchaseImg, img) for img in imgs]
if contract: self.contract = contract
self.use = submit["use"]
if submit.__contains__("reson"):
self.reson = submit["reson"]
else:
self.reson = ""
@staticmethod
def add(submit):
purchase = Purchase(submit)
db.session.add(purchase)
db.session.commit()
return purchase
@staticmethod
def get(id):
from bmp.models.user import Group
purchase = Purchase.query.filter(Purchase.id == id).one()
purchase.cur_approval_type_desc = Group.get(
purchase.cur_approval_type).desc
return Purchase._to_dict(purchase, ["cur_approval_type_desc"])
@staticmethod
def _to_dict(self, cols=[]):
_dict = self.to_dict(cols)
_dict["approvals"] = [a.to_dict() for a in self.approvals]
if self.contract:
_dict["contract"] = self.contract.to_dict()
_dict["imgs"] = [img.to_dict() for img in self.imgs]
_dict["goods"] = [PurchaseGoods._to_dict(g) for g in self.goods]
if self.supplier:
_dict["supplier"] = self.supplier.to_dict()
return _dict
@staticmethod
def __is_superior(uid, apply_uid):
ldap = Ldap()
if uid == ldap.get_2nd_manager(apply_uid):
return True
return False
@staticmethod
def finished(page=1, pre_page=20):
from bmp.models.user import User
uid = session[USER_SESSION]["uid"]
group = set(User.get(uid)["group"]).intersection(PURCHASE.FLOW)
page = Purchase.query \
.join(PurchaseApproval) \
.filter(or_(Purchase.apply_uid == uid,
PurchaseApproval.uid == uid,
PurchaseApproval.type.in_(group))) \
.filter(Purchase.is_draft == False) \
.filter(Purchase.is_finished == True) \
.order_by(Purchase.apply_time.desc()).paginate(page, pre_page)
return page.to_page(Purchase._to_dict)
@staticmethod
def unfinished(user_groups):
from bmp.models.user import Group, User
purchases = []
uid = session[USER_SESSION]["uid"]
group = set(User.get(uid)["group"]).intersection(PURCHASE.FLOW)
group_map = {}
for g in Group.select(to_dict=False):
group_map[g.name.upper()] = g.desc
for purchase in Purchase.query \
.filter(Purchase.is_draft == False) \
.filter(Purchase.is_finished == False).order_by(Purchase.apply_time.desc()).all():
approvals = purchase.approvals
apply_uid = purchase.apply_uid
cur_approval_type = purchase.cur_approval_type
purchase.cur_approval_type_desc = ""
purchase.approval_enable = False
is_append = False
if group_map.__contains__(cur_approval_type.upper()):
purchase.cur_approval_type_desc = group_map[
cur_approval_type.upper()]
if uid in [purchase.apply_uid] + [a.uid for a in approvals] \
or group.intersection([a.type for a in approvals]):
purchases.append(purchase)
is_append = True
if cur_approval_type == PURCHASE.FLOW_ONE:
if Purchase.__is_superior(uid, apply_uid):
purchase.approval_enable = True
if not is_append:
purchases.append(purchase)
elif uid in user_groups[cur_approval_type]:
purchase.approval_enable = True
if not is_append:
purchases.append(purchase)
else:
continue
return [
Purchase._to_dict(p, ["approval_enable", "cur_approval_type_desc"])
for p in purchases
]
@staticmethod
def passed(page=1, pre_page=20):
return Purchase.query \
.join(PurchaseApproval, PurchaseApproval.purchase_id == Purchase.id) \
.filter(Purchase.is_finished == True) \
.filter(PurchaseApproval.status != PURCHASE.FAIL) \
.order_by(Purchase.apply_time.desc()) \
.paginate(page, pre_page, False).to_page(Purchase._to_dict)
@staticmethod
def drafts(page=1, pre_page=20):
page = Purchase.query \
.filter(Purchase.apply_uid == session[USER_SESSION]["uid"]) \
.filter(Purchase.is_draft == True) \
.order_by(Purchase.apply_time.desc()) \
.paginate(page, pre_page, False)
return page.to_page(Purchase._to_dict)
@staticmethod
def delete(pid):
db.session.delete(Purchase.query.filter(Purchase.id == pid).one())
db.session.commit()
@staticmethod
def edit(submit):
purchase = Database.to_cls(Purchase, submit)
db.session.commit()
@staticmethod
def approval(pid):
purchase = Purchase.query.filter(Purchase.id == pid).one()
purchase.is_draft = False
db.session.commit()
return True
@staticmethod
def search(submit, page=None, pre_page=None):
from bmp.models.asset import Category
def check(s):
if submit.__contains__(s):
return submit[s]
return False
query = Purchase.query \
.join(PurchaseGoods, PurchaseGoods.purchase_id == Purchase.id) \
.join(purchase_goods_category) \
.join(PurchaseApproval) \
.join(Category) \
.filter(Purchase.is_finished == True) \
.filter(PurchaseApproval.status != PURCHASE.FAIL)
if check("apply_businessCategory"):
query = query.filter(Purchase.apply_businessCategory ==
submit["apply_businessCategory"])
if check("apply_uid"):
query = query.filter(Purchase.apply_uid == submit["apply_uid"])
if check("apply_time_begin") and check("apply_time_end"):
beg = datetime.strptime(submit["apply_time_begin"], "%Y-%m-%d")
end = datetime.strptime(submit["apply_time_end"], "%Y-%m-%d")
query = query.filter(Purchase.apply_time.between(beg, end))
if check("goods"):
parent = Category.query.filter(
Category.name == submit["goods"]).one()
childs = [
c.id for c in Category.query.filter(
Category.parent_id == parent.id).all()
]
query = query.filter(Category.id.in_(childs))
if check("price_begin") and check("price_end"):
goods = PurchaseGoods.query.filter(
PurchaseGoods.purchase_id != None).all()
pgoods = []
for g in goods:
total = g.price * g.amount
if total >= int(submit["price_begin"]) and total <= int(
submit["price_end"]):
pgoods.append(g.id)
query = query.filter(PurchaseGoods.id.in_(pgoods))
if page == None:
return [Purchase._to_dict(p) for p in query.all()]
return query.order_by(Purchase.apply_time.desc()).paginate(
page, pre_page, False).to_page(Purchase._to_dict)
@staticmethod
def export(submit):
# 申请人 申请部门 申请时间 物品 规格 数量 总价 审批人
_export = []
for purchase in Purchase.search(submit):
for g in purchase["goods"]:
_dict = collections.OrderedDict()
_dict["采购编号"] = str(purchase["id"])
_dict["总价"] = g["amount"] * g["price"]
_dict["数量"] = g["amount"]
_dict["规格"] = str(g["spec"]["name"])
_dict["物品"] = str(g["category"]["name"])
_dict["申请时间"] = time.format(purchase["apply_time"], "%Y-%m-%d")
_dict["申请部门"] = str(purchase["apply_businessCategory"])
_dict["申请人"] = str(purchase["apply_uid"])
_export.append(_dict)
return _export
@staticmethod
def between(beg, end):
return [
Purchase._to_dict(p)
for p in Purchase.query
.filter(Purchase.is_finished == True) \
.filter(Purchase.is_draft == False) \
.filter(Purchase.apply_time >= beg) \
.filter(Purchase.apply_time <= end).all()
]
class Idc_host(BaseModel, db.Model): # 主机信息
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
ip = db.Column(db.String(128))
type_id = db.Column(db.Integer, db.ForeignKey("ref.id"))
desc = db.Column(db.String(256))
cate = db.Column(db.String(128))
host_kernel = db.Column(db.Text)
cpu_processor = db.Column(db.Text)
default_gateway = db.Column(db.Text)
time_zone = db.Column(db.Text)
processor_cores = db.Column(db.Text)
product_name = db.Column(db.Text)
host_lang = db.Column(db.Text)
memory_total = db.Column(db.Text)
dns = db.Column(db.Text)
serial_number = db.Column(db.Text)
host_interfaces = db.relationship("Idc_host_interface")
host_disks = db.relationship("Idc_host_disk")
host_os = db.Column(db.Text)
processor_vcpus = db.Column(db.Text)
host_name = db.Column(db.Text)
ssh_info = db.Column(db.Text)
quick_code = db.Column(db.Text)
end_date = db.Column(db.DateTime)
system_time = db.Column(db.DateTime)
ps_info = db.relationship("Idc_host_ps")
@staticmethod
def _to_dict(self):
_dict = self.to_dict()
_dict["host_interfaces"] = [i.to_dict() for i in self.host_interfaces]
_dict["host_disks"] = [d.to_dict() for d in self.host_disks]
_dict["ps_info"] = [ps.to_dict() for ps in self.ps_info]
return _dict
@staticmethod
def __update(submit):
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, submit["ip"], False)
return json.loads(info.replace("u'", "'").replace("'", "\""))
if not submit.__contains__("ip"): # 更新描述信息
idc_host = Database.to_cls(Idc_host, submit)
return idc_host
submit["ssh_info"] = exec_script(
"/root/csfscript/host_info/get_ssh_info.py"
)["host_ssh_info"].replace("\n", " ").replace(" ", " ")
submit["system_time"] = datetime.strptime(
exec_script("/root/csfscript/host_info/get_system_time.py")
["system_time"], "%Y-%m-%d %I:%M:%S %p")
submit.update(
exec_script("/root/csfscript/host_info/get_host_info.py"))
host_interfaces = submit.pop("host_interfaces")
host_disks = submit.pop("host_disks")
for key in submit:
if isinstance(submit[key], list):
submit[key] = ",".join(submit[key])
idc_host = Database.to_cls(Idc_host, submit)
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()
idc_host.host_interfaces = [
Database.to_cls(Idc_host_interface, _dict)
for _dict in host_interfaces
]
idc_host.host_disks = [
Database.to_cls(Idc_host_disk, _dict) for _dict in host_disks
]
return idc_host
@classmethod
def edit(cls, _dicts, auto_commit=True):
idc_host = Idc_host.__update(_dicts)
db.session.commit()
return True
@classmethod
def add(cls, _dicts, auto_commit=True):
results = []
if not isinstance(_dicts, list):
_dicts = [_dicts]
for _dict in _dicts:
try:
result = {
"ip": _dict["ip"],
"type_id": _dict["type_id"],
"success": False,
"error": ""
}
results.append(result)
if Idc_host.query \
.filter(Idc_host.ip == _dict["ip"]) \
.filter(Idc_host.type_id == _dict["type_id"]) \
.count():
result["error"] = "%s 已经存在" % _dict["ip"]
continue
idc_host = Idc_host.__update(_dict)
db.session.add(idc_host)
result["success"] = True
except Exception, e:
traceback.print_exc()
log.exception(e)
db.session.commit()
return results
class Group(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128), unique=True)
desc = db.Column(db.String(128))
is_buildin = db.Column(db.Boolean, default=False)
users = db.relationship("User",
secondary=user_group,
backref=db.backref("groups"))
def __init__(self, name, desc):
self.name = name
self.desc = desc
@staticmethod
def join(name, users):
group = Group.query.filter(Group.name == name).one()
if users:
group.users = User.query.filter(User.uid.in_(users)).all()
else:
group.users = []
db.session.commit()
return True
@staticmethod
def edit(name, new_name, new_desc):
name, new_name = name.upper(), new_name.upper()
group = Group.query.filter(Group.name == name).one()
if name != new_name and group.is_buildin:
raise ExceptionEx("内建组禁止修改组名")
group.name = new_name
group.desc = new_desc
db.session.commit()
return True
@staticmethod
def add(name, desc):
if Group.query.filter(Group.name == name).count():
return False
db.session.add(Group(name, desc))
db.session.commit()
return True
@staticmethod
def delete(name):
group = Group.query.filter(Group.name == name).one()
if group.is_buildin:
raise ExceptionEx("禁止删除内建组")
db.session.delete(group)
db.session.commit()
return True
@staticmethod
def get(name):
return Group.query.filter(Group.name.like(name)).one()
@staticmethod
def _to_dict(group):
g = group.to_dict()
g["users"] = [u.uid for u in group.users]
return g
@staticmethod
def select(name="%", to_dict=True):
if to_dict:
return [
Group._to_dict(g)
for g in Group.query.filter(Group.name.like(name)).all()
]
return Group.query.filter(Group.name.like(name)).all()
@staticmethod
def get_descs():
descs = {}
for g in Group.query.all():
descs[g.name] = g.desc
return descs
@staticmethod
def get_users(name):
g = Group.get(name)
return g.users
