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