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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 Icp(BaseModel, db.Model): # 备案信息
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
type = db.Column(db.String(128))
company = db.Column(db.String(128))
company_type = db.Column(db.String(128))
no = db.Column(db.String(128))
site = db.Column(db.String(128))
main_page = db.Column(db.String(128))
chk_time = db.Column(db.DateTime)
domain = db.Column(db.Text, default="")
elb = db.Column(db.Text)
ip = db.Column(db.Text)
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 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 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 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 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"))
class Cert(BaseModel, db.Model): # ssl证书
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128))
sp = db.Column(db.String(128))
end_time = db.Column(db.DateTime)
class Category(BaseModel, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128))
parent_id = db.Column(db.Integer)
is_del = db.Column(db.Boolean, default=False)
@classmethod
def add(cls, _dicts, auto_commit=True):
query = Category.query \
.filter(Category.parent_id == _dicts["parent_id"]) \
.filter(Category.name == _dicts["name"])
if query.filter(Category.is_del == False).count():
raise ExceptionEx("分类%s已经存在" % _dicts["name"])
if query.filter(Category.is_del == True).count():
category = query.one()
category.is_del = False
else:
db.session.add(Category(_dicts))
db.session.commit()
return True
@staticmethod
def __delete(id):
category = Category.query.filter(Category.parent_id == id)
for child in category.all():
Category.__delete(child.id)
category = Category.query.filter(Category.id == id).one()
category.is_del = True
@classmethod
def delete(cls, _ids, auto_commit=True):
Category.__delete(_ids)
@staticmethod
def __select_sub(parent_id):
sub = []
for c in Category.query \
.filter(Category.is_del == False) \
.filter(Category.parent_id == parent_id).all():
c.child = Category.__select_sub(c.id)
sub.append(c.to_dict(["child"]))
return sub
@staticmethod
def select_sub(parent_id):
return Category.__select_sub(parent_id)
@staticmethod
def get_parent_ids(_id):
ids = []
category = Category.query.filter(Category.id == _id).one()
if not category.parent_id:
return []
ids.extend(Category.get_parent_ids(category.parent_id))
return ids
@staticmethod
def get_child_ids(_id):
categorys = Category.query.filter(Category.parent_id == _id).all()
if not categorys:
return []
ids = [c.id for c in categorys]
for category in categorys:
ids.extend(Category.get_child_ids(category.id))
return ids
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()
