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 ReleaseAddress(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(256))
addr = db.Column(db.String(256))
type = db.Column(db.String(128)) # d_host s_host
def __init__(self, _dict):
self.name = _dict["name"]
self.addr = _dict["addr"]
self.type = _dict["type"]
@staticmethod
def add(submit):
ra = ReleaseAddress(submit)
db.session.add(ra)
db.session.commit()
return True
@staticmethod
def delete(aid):
ra = ReleaseAddress.query.filter(ReleaseAddress.id == aid).one()
db.session.delete(ra)
db.session.commit()
return True
@staticmethod
def _to_dict(self):
return self.to_dict()
@staticmethod
def select(page=0, pre_page=None):
return ReleaseAddress.query.paginate(page, pre_page).to_page(ReleaseAddress._to_dict)
class Fund(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
date = db.Column(db.DateTime)
value = db.Column(db.Float)
def _to_dict(self):
ret = self.to_dict()
ret["date"] = self.date.strftime("%Y-%m-%d")
return ret
class Ref(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)
parent_id = db.Column(db.Integer, default=0)
is_del = db.Column(db.Boolean, default=False)
def __init__(self, name, type, parent_id):
self.name = name
self.type = type
self.parent_id = parent_id
@staticmethod
def select(type):
refs = Ref.query.filter(
Ref.type.like(type)).filter(Ref.is_del != True).all()
return [ref.to_dict() for ref in refs]
@staticmethod
def map(type):
refs = {}
for ref in Ref.select(type):
refs[ref["id"]] = ref["name"]
return refs
@staticmethod
def add(name, type, parent_id=0):
query = Ref.query \
.filter(Ref.type == type) \
.filter(Ref.name == name) \
.filter(Ref.parent_id == parent_id)
if query.filter(Ref.is_del != True).count():
raise ExceptionEx("该分类已存在")
if query.filter(Ref.is_del).count():
ref = query.filter(Ref.is_del).one()
ref.is_del = False
else:
db.session.add(Ref(name, type, parent_id))
db.session.commit()
@staticmethod
def delete(rid):
ref = Ref.query.filter(Ref.id == rid).one()
ref.is_del = True
db.session.commit()
@staticmethod
def get(id):
return Ref.query.filter(Ref.id == id).one().to_dict()
@staticmethod
def _to_dict(self):
return self.to_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 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 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 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 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 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 Supplier(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128), unique=True)
connector = db.Column(db.String(128))
interfaceor = db.Column(db.String(128))
tel = db.Column(db.String(128))
addr = db.Column(db.String(128))
create_time = db.Column(db.DateTime)
last_time = db.Column(db.DateTime)
path = db.Column(db.String(256))
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 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 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 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 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 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 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 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 Upload(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128))
uuid = db.Column(db.String(128), unique=True)
def __init__(self, name, uuid):
self.uuid = uuid
self.name = name
@staticmethod
def add(name, uuid):
db.session.add(Upload(name, uuid))
db.session.commit()
@staticmethod
def get_name(uuid):
if not Upload.query.filter(Upload.uuid == uuid).count():
return ""
return Upload.query.filter(Upload.uuid == uuid).one().name
@staticmethod
def _to_dict(self):
return self.to_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 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 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 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 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 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 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 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"))
