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