def do_delete(self):
res_id = self.params.get("res_id", 0)
logger.info("\t res_id : %s" % res_id)
user_id = self.params.get("user_id", 0)
# user_id = self.handler.current_user.id
resource = self.db.query(Pro_Resource_Apply).filter(Pro_Resource_Apply.id == res_id).first()
if not resource:
return self.failure(ERROR.not_found_err)
# 状态只有-1、-2（即：已撤销、申请被拒绝）可以删除
if resource.status > STATUS_RESOURCE.REVOKED:
return self.failure(ERROR.res_delete_err)
# resource.status = STATUS_RESOURCE.DELETED
# self.db.add(resource)
mail_content = mail_format % {
"pro_name": resource.project.name,
"pro_id": resource.project.id,
"user_name": resource.user.email or resource.user.mobile,
"resource_status": u"已删除",
}
resource.is_enable = False
# resource.status = STATUS_RESOURCE.DELETED
self.db.add(resource)
# self.db.query(Pro_Resource_Apply).filter(Pro_Resource_Apply.id == res_id).delete()
# resource.delete()
self.db.flush()
logger.info("\t resource is deleted")
# sendMail.delay("*****@*****.**", admin_emails, mail_content, mail_content)
# task_post_pro_res_apply_history.delay(status=resource.status, content=mail_content, pro_id=resource.project.id, res_apply_id=resource.id, user_id=user_id)
# from scloud.views.admin.ws.pubsub import r
# r.publish("test_realtime", "notice_checker")
return self.success(data=resource)
def check_form_empty(self):
if self.computer == 0:
return self.failure(ERROR.res_computer_empty_err)
if self.cpu == 0:
return self.failure(ERROR.res_cpu_empty_err)
if self.memory == 0:
return self.failure(ERROR.res_memory_empty_err)
if self.disk == 0:
return self.failure(ERROR.res_disk_empty_err)
if self.disk_amount == 0:
return self.failure(ERROR.res_disk_amount_empty_err)
# if self.disk_backup == 0:
# return self.failure(ERROR.res_disk_backup_empty_err)
if self.disk_backup_amount == 0:
return self.failure(ERROR.res_disk_backup_amount_empty_err)
if self.out_ip == 0:
return self.failure(ERROR.res_out_ip_empty_err)
if self.snapshot == 0:
return self.failure(ERROR.res_snapshot_empty_err)
if self.loadbalance == 0:
return self.failure(ERROR.res_loadbalance_empty_err)
if self.internet_ip == -1:
logger.info(self.internet_ip)
return self.failure(ERROR.res_internet_ip_empty_err)
if self.params.get('period') == 0:
return self.failure(ERROR.res_period_empty_err)
return self.success()
def post(self):
svc = ProfileService(self)
user_res = svc.set_profile()
if isinstance(user_res, Exception):
raise user_res
tmpl_form = self.render_to_string(
"admin/profile/profile/_profile_form.html",
user_res=user_res,
current_user=self.current_user)
user_profile_res = svc.get_profile()
if user_res.return_code == 0:
delattr(self, "_current_user")
self.session["current_user"] = user_res.data
self.save_session()
tmpl = self.render_to_string(
"admin/profile/profile/_profile_index.html")
return simplejson.dumps(
self.success(
data={
"tmpl": tmpl,
"tmpl_form": tmpl_form,
"user": self.current_user.as_dict()
}))
else:
logger.info(tmpl_form)
return simplejson.dumps(
self.failure(return_code=user_res.return_code,
return_message=user_res.return_message,
data={
"tmpl_form": tmpl_form,
"user": user_profile_res.data.as_dict()
}))
def post_user_roles(user_id, role_ids):
result = get_user_roles(user_id)
user_role_obj = result["data"]["role_obj"]
user_role_list = [str(i) for i in user_role_obj.keys()]
# logger.info("============================")
# logger.info(set(role_group_op_list))
# logger.info(set(group_ops))
# logger.info("============================")
need_deletes = set(user_role_list) - set(role_ids)
logger.info(need_deletes)
# role_list = [(g, op) for g, op in [_str.split(".") for _str in role_ids]]
# need_delete_list = [(g, op) for g, op in [_str.split(".") for _str in need_deletes]]
for role_id in role_ids:
instance, created = PT_User_Role.get_or_create(
user_id = int(user_id),
role_id = int(role_id),
)
with DataBaseService({}) as svc:
for role_id in need_deletes:
svc.db.query(
PT_User_Role
).filter(
PT_User_Role.user_id == int(user_id),
PT_User_Role.role_id == int(role_id)
).delete()
data = {
"return_code": 0,
"return_message": u"",
"data": {"roles": result["data"]["roles"]}
}
return data
def do_pay(self):
logger.info("\t [ DO PAY ]")
res_id = self.params.get("res_id", 0)
user_id = self.params.get("user_id", 0)
user_id = self.handler.current_user.id
resource_query = self.db.query(Pro_Resource_Apply).filter(Pro_Resource_Apply.id == res_id)
logger.info("\t [QUERY] : %s" % resource_query)
resource = resource_query.first()
if not resource:
# return self.failure(ERROR.not_found_err)
return NotFoundError()
# 状态不为0（即：不是提交状态），不允许撤销
logger.info("\t [resource.status]: %s" % resource.status)
logger.info("\t [STATUS_RESOURCE.CHECKED]: %s" % STATUS_RESOURCE.CHECKED)
logger.info("\t change to [STATUS_RESOURCE.PAYED]: %s" % STATUS_RESOURCE.PAYED)
if resource.status != STATUS_RESOURCE.CHECKED:
return self.failure(ERROR.res_pay_err)
resource.status = STATUS_RESOURCE.PAYED
self.db.add(resource)
self.db.flush()
mail_html = self.render_to_string("admin/mail/pro_resource_apply_to_admin.html", resource_apply=resource, STATUS_RESOURCE=STATUS_RESOURCE)
mail_title = mail_title_format % {
"user_name": resource.user.email or resource.user.mobile,
"pro_name": resource.project.name,
"res_desc": resource.desc,
"action": u"申请的",
"todo_action": u"资源，已完成支付，请确认收款",
}
sendMail.delay("*****@*****.**", admin_emails, mail_title, mail_html)
task_post_pro_res_apply_history.delay(status=resource.status, content=mail_title, pro_id=resource.project.id, res_apply_id=resource.id, user_id=user_id)
# from scloud.views.admin.ws.pubsub import r
# r.publish("test_realtime", "notice_checker")
return self.success(data=resource)
def wrapper(self, *args, **kwargs):
if not self.current_user:
logger.info("[authenticated]: %s" % self.current_user)
if self.request.method in ("GET", "HEAD", "POST", "CHECK", "XGET"):
url = self.get_login_url()
if "?" not in url:
if urlparse.urlsplit(url).scheme:
# if login url is absolute, make next absolute too
next_url = self.request.full_url()
else:
next_url = self.request.uri
url += "?" + urllib.urlencode(dict(next=next_url))
headers = self.request.headers
x_requested_with = headers.get("X-Requested-With", "")
if x_requested_with == "XMLHttpRequest":
logger.info("return simplejson data: SESSION_FAILD")
if headers.get("X-PJAX"):
self.redirect(url)
else:
return self.write(simplejson.dumps(
{"return_code": -231030, "return_message": u"对不起会话已失效，请重新登录",
"data": {"redirect_url": url}}))
else:
self.redirect(url)
return
raise HTTPError(403)
return method(self, *args, **kwargs)
def get_global_vars(self):
if hasattr(self, "_get_global_vars"):
return self._get_global_vars
logger.info("------[get_apply_global_vars]------")
apply_status = self.status
percent_status = apply_status + 1
if percent_status < 0:
percent_status = 0
progress_percent = '%d%%' % ((percent_status / 4) * 100)
status_desc = pro_resource_apply_status_types.get(apply_status).value
todo_status_desc = pro_resource_apply_status_types.get(
apply_status).todo_value
bg_color = pro_resource_apply_status_types.get(apply_status).bg_color
level = pro_resource_apply_status_types.get(apply_status).level
data = dict(
last_apply=self,
apply_status=apply_status,
percent_status=percent_status,
progress_percent=progress_percent,
status_desc=status_desc,
todo_status_desc=todo_status_desc,
bg_color=bg_color,
level=level,
)
setattr(self, "_get_global_vars", data)
return self._get_global_vars
def check_form_empty(self):
if self.computer == 0:
return self.failure(ERROR.res_computer_empty_err)
if self.cpu == 0:
return self.failure(ERROR.res_cpu_empty_err)
if self.memory == 0:
return self.failure(ERROR.res_memory_empty_err)
if self.disk == 0:
return self.failure(ERROR.res_disk_empty_err)
if self.disk_amount == 0:
return self.failure(ERROR.res_disk_amount_empty_err)
# if self.disk_backup == 0:
# return self.failure(ERROR.res_disk_backup_empty_err)
if self.disk_backup_amount == 0:
return self.failure(ERROR.res_disk_backup_amount_empty_err)
if self.out_ip == 0:
return self.failure(ERROR.res_out_ip_empty_err)
if self.snapshot == 0:
return self.failure(ERROR.res_snapshot_empty_err)
if self.loadbalance == 0:
return self.failure(ERROR.res_loadbalance_empty_err)
if self.internet_ip == -1:
logger.info(self.internet_ip)
return self.failure(ERROR.res_internet_ip_empty_err)
if self.params.get('period') == 0:
return self.failure(ERROR.res_period_empty_err)
return self.success()
def do_delete(self):
res_id = self.params.get("res_id", 0)
logger.info("\t res_id : %s" % res_id)
user_id = self.params.get("user_id", 0)
# user_id = self.handler.current_user.id
resource = self.db.query(Pro_Resource_Apply).filter(
Pro_Resource_Apply.id == res_id).first()
if not resource:
return self.failure(ERROR.not_found_err)
# 状态只有-1、-2（即：已撤销、申请被拒绝）可以删除
if resource.status > STATUS_RESOURCE.REVOKED:
return self.failure(ERROR.res_delete_err)
# resource.status = STATUS_RESOURCE.DELETED
# self.db.add(resource)
mail_content = mail_format % {
"pro_name": resource.project.name,
"pro_id": resource.project.id,
"user_name": resource.user.email or resource.user.mobile,
"resource_status": u"已删除",
}
resource.is_enable = False
# resource.status = STATUS_RESOURCE.DELETED
self.db.add(resource)
# self.db.query(Pro_Resource_Apply).filter(Pro_Resource_Apply.id == res_id).delete()
# resource.delete()
self.db.flush()
logger.info("\t resource is deleted")
# sendMail.delay("*****@*****.**", admin_emails, mail_content, mail_content)
# task_post_pro_res_apply_history.delay(status=resource.status, content=mail_content, pro_id=resource.project.id, res_apply_id=resource.id, user_id=user_id)
# from scloud.views.admin.ws.pubsub import r
# r.publish("test_realtime", "notice_checker")
return self.success(data=resource)
def post(self):
id_list = self.get_arguments("id")
svc = EventService(self, {"id_list": id_list})
del_res = svc.do_del_pro_event()
logger.info(del_res)
if del_res.return_code == 0:
self.add_message(u"事件信息删除成功！", level="success")
publish_notice_checker.delay(self.current_user.id)
else:
self.add_message(u"事件信息删除失败！(%s)(%s)" %
(del_res.return_code, del_res.return_message),
level="warning")
svc = EventService(self, {"user_id": self.current_user.id})
pro_events_res = svc.get_list()
svc = ProjectService(self)
pro_list_res = svc.get_project_list()
if pro_list_res.return_code < 0:
raise SystemError(pro_list_res.return_code,
pro_list_res.return_message)
logger.info(pro_list_res)
data = {
"pro_list_res": pro_list_res,
"pro_events_res": pro_events_res,
"page": self.getPage(pro_events_res.data)
}
tmpl = self.render_to_string("admin/event/index_pjax.html", **data)
return simplejson.dumps(self.success(data=tmpl))
def do_event(self):
logger.info("------ [do_event] ------")
try:
pro_id = int(self.params.get("pro_id"))
except:
return self.failure(ERROR.pro_name_empty_err)
try:
res_apply_id = int(self.params.get("res_apply_id"))
except:
return self.failure(ERROR.res_apply_id_empty_err)
title = self.params.get("title")
content = self.params.get("content")
priority = int(self.params.get("priority", 0))
if not pro_id:
return self.failure(ERROR.pro_name_empty_err)
if not res_apply_id:
return self.failure(ERROR.res_apply_id_empty_err)
if not title:
return self.failure(ERROR.pro_event_title_empty_err)
if not content:
return self.failure(ERROR.pro_event_content_empty_err)
pro_event, created = Pro_Event.get_or_create_obj(
self.db, pro_id=pro_id, res_apply_id=res_apply_id, title=title)
if created:
pro_event.pro_id = pro_id
pro_event.res_apply_id = res_apply_id
pro_event.priority = priority
pro_event.title = title
pro_event.content = content
pro_event.user_id = self.handler.current_user.id
self.db.add(pro_event)
self.db.flush()
else:
return self.failure(ERROR.pro_event_title_duplicate_err)
return self.success(data=pro_event)
def do_reply(self):
event_id = self.params.get("id")
if not event_id:
return self.failure(ERROR.pro_event_id_empty_err)
reply_content = self.params.get("reply_content")
if not reply_content:
return self.failure(ERROR.pro_event_reply_content_empty_err)
pro_event = self.db.query(Pro_Event).filter(
Pro_Event.id == event_id).first()
logger.info(pro_event)
# logger.info("self.handler.current_user.imchecker: %s" % self.handler.current_user.imchecker)
if self.handler.current_user.imchecker:
status = self.params.get("status", 0)
pro_event.status = status
pro_event.checker_id = self.handler.current_user.id
pro_event.check_time = datetime.now()
else:
pro_event.status = STATUS_PRO_TABLES.APPLIED
self.db.add(pro_event)
event_detail, created = Pro_Event_Detail.get_or_create_obj(
self.db, event_id=event_id, content=reply_content)
event_detail.user_id = self.handler.current_user.id
self.db.add(event_detail)
self.db.flush()
return self.success(data=event_detail)
def get_env(self):
logger.info("------[get_env]------")
env_id = self.params.get("env_id")
env = self.db.query(Env_Info).filter(Env_Info.id == env_id).first()
if not env:
raise NotFoundError()
return self.success(data=env)
def do_notice_checker(self, json_message):
logger.info(
"-----------------------------NOTICE CHECKER-----------------------------"
)
svc = PtUserService(self)
pt_users_res = svc.get_list()
user_ids = [
u.id for u in pt_users_res.data
if "pro_resource_apply.check" in u.get_current_perms()
]
for user_id in user_ids:
svc = ActHistoryService(self, {"user_id": user_id})
tasks_res = svc.get_res_tasks()
data = {
"tasks_res": tasks_res,
"imchecker": True,
"STATUS_RESOURCE": STATUS_RESOURCE
}
chat = {
"user_id": user_id,
"html": self.render_to_string("admin/notice/tasks.html",
**data)
}
chat.update(json_message)
logger.error(chat)
EchoWebSocket.send_message(chat)
def get(self, **kwargs):
data = self.get_pro_info_res(kwargs["pro_id"])
applies = data["pro_info_res"].data.pro_resource_applies
svc = ProjectService(self)
pro_list_res = svc.get_project_list()
logger.info(pro_list_res)
# svc = ProUserService(self, {"pro_id": kwargs["pro_id"]})
# pro_users_res = svc.get_list()
# pro_user_res = svc.get_info()
# svc = ApplyPublish(self, {"pro_id": kwargs["pro_id"]})
# pro_publish_res = svc.get_publish()
# svc = ApplyLoadBalance(self, {"pro_id": kwargs["pro_id"]})
# pro_loadbalance_res = svc.get_loadbalance()
# svc = ApplyBackups(self, {"pro_id": kwargs["pro_id"]})
# backups_res = svc.get_backups()
data.update(
pro_list_res=pro_list_res,
pro_id=kwargs["pro_id"]
# pro_users_res=pro_users_res,
# pro_user_res=pro_user_res,
# pro_publish_res=pro_publish_res,
# pro_loadbalance_res=pro_loadbalance_res,
# backups_res=backups_res,
)
if len(applies) > 0:
last_apply = applies[-1]
if not last_apply.start_date:
self.add_message(u"尚未设置云资源启用时间！", level="warning")
return self.render_to_string("admin/guide/step3.html", **data)
else:
return self.render_to_string("admin/guide/step1.html", **data)
def do_online(self, json_message):
user_id = json_message["user_id"]
svc = PtUserService(self, {"user_id": user_id})
pt_user_res = svc.get_info()
pt_user = pt_user_res.data
if not isinstance(pt_user_res, Exception):
logger.info("pt_user: %s" % pt_user)
data = {
"level":
"info",
"content":
u"%s已经上线！" %
(pt_user.username or pt_user.email or pt_user.mobile),
}
try:
html = self.render_to_string("admin/notice/online.html",
**data)
except Exception as e:
logThrown()
html = ""
chat = {"user_id": pt_user.id, "html": html}
chat.update(json_message)
EchoWebSocket.users.update({user_id: self})
EchoWebSocket.send_all(chat)
logger.info("**users: %s" % EchoWebSocket.users)
def do_return(self, check_res):
pro_table = self.args.get("pro_table")
doc = GROUP.get(pro_table).name
# logger.info(doc)
if check_res.return_code == 0:
self.add_message(u"所选申请%s已处理完毕" % doc, level="success")
pro_users = check_res.data
users = {str(u.user_id): u for u in pro_users}
logger.info(users)
action = self.args.get("action")
action_value = "%s, %s" % (STATUS_PRO_TABLES.get(action.lower()).value, STATUS_PRO_TABLES.get(action.lower()).todo_value)
mail_title = u"%s%s" % (doc, action_value)
mail_content = u"%s已处理完毕, 当前状态：%s。处理结果：%s" % (doc, action_value, self.args.get("reason"))
for user_id in users.keys():
publish_notice_user.delay(user_id)
user_email = users.get(str(user_id)).user.email
mail_html = self.render_to_string("admin/mail/pro_table_check_result.html",
mail_content=mail_content,
user_email=user_email,
pro_table=pro_table,
pro_table_obj = users.get(str(user_id))
)
logger.info("[mail to %s]" % [user_email])
sendMail.delay("*****@*****.**", [user_email], mail_title, mail_html)
# sendMail.delay("*****@*****.**", admin_emails, mail_title, mail_html)
if pro_table == "pro_event":
ids = self.args.get("ids")
id_list = [int(i) for i in ids.split(",") if i.strip().isdigit()]
for id in id_list:
svc = EventService(self, {"id": id, "reply_content": STATUS_PRO_TABLES.checked.value, "status": STATUS_PRO_TABLES.CHECKED})
svc.do_reply()
data = self.get_index_page(pro_table)
tmpl = self.render_to_string("admin/check/event_list_pjax.html", **data)
return simplejson.dumps(self.success(data=tmpl))
def reset_password(self):
logger.info("------[reset_password]------")
old_password = self.params.get("old_password")
new_password = self.params.get("new_password")
repeat_password = self.params.get("repeat_password")
current_user = self.handler.current_user
if not current_user:
return self.failure(ERROR.not_found_err)
if not old_password:
return self.failure(ERROR.old_password_empty_err)
if not new_password:
return self.failure(ERROR.new_password_empty_err)
if not repeat_password:
return self.failure(ERROR.repeat_password_empty_err)
if current_user.password != old_password:
return self.failure(ERROR.password_err)
if new_password != repeat_password:
return self.failure(ERROR.repeat_password_err)
user = self.db.query(PT_User).filter(
PT_User.id == current_user.id).first()
if user:
user.password = new_password
self.db.add(user)
self.db.flush()
return self.success(data=user)
else:
return self.failure(ERROR.not_found_err)
def get_global_vars(self):
if hasattr(self, "_get_global_vars"):
return self._get_global_vars
logger.info("------[get_apply_global_vars]------")
apply_status = self.status
percent_status = apply_status + 1
if percent_status < 0:
percent_status = 0
progress_percent = '%d%%' % ((percent_status / 4) * 100)
status_desc = pro_resource_apply_status_types.get(apply_status).value
todo_status_desc = pro_resource_apply_status_types.get(apply_status).todo_value
bg_color = pro_resource_apply_status_types.get(apply_status).bg_color
level = pro_resource_apply_status_types.get(apply_status).level
data = dict(
last_apply = self,
apply_status = apply_status,
percent_status = percent_status,
progress_percent = progress_percent,
status_desc = status_desc,
todo_status_desc = todo_status_desc,
bg_color = bg_color,
level = level,
)
setattr(self,"_get_global_vars", data)
return self._get_global_vars
def post(self):
svc = ApplyLoadBalance(self)
pro_loadbalance_res = svc.do_loadbalance()
pro_id = self.args.get("pro_id")
data = self.get_pro_data(pro_id=pro_id)
# svc = ApplyLoadBalance(self)
# loadbalance_res = svc.get_loadbalance()
# svc = ApplyBackups(self)
# backups_res = svc.get_backups()
data.update(pro_loadbalance_res=pro_loadbalance_res)
logger.info(pro_loadbalance_res)
if pro_loadbalance_res.return_code == 0:
self.add_message(u"负载均衡信息添加成功！%s" % STATUS_PRO_TABLES.get(pro_loadbalance_res.data.status).todo_value, level="success")
tmpl = self.render_to_string("admin/guide/_step_3_balance_detail.html", **data)
publish_notice_checker.delay(self.current_user.id)
mail_title = u"%s申请的负载均衡信息添加成功！待受理" % (
self.current_user.username or self.current_user.email,
)
mail_html = self.render_to_string("admin/mail/pro_balance.html", mail_title=mail_title, **data)
sendMail.delay("*****@*****.**", admin_emails, mail_title, mail_html)
else:
tmpl = self.render_to_string("admin/guide/_step_3_balance.html", **data)
self.add_message(u"负载均衡信息添加失败！(%s)(%s)" % (pro_loadbalance_res.return_code, pro_loadbalance_res.return_message), level="warning")
messages_tmpl = self.render_to_string("admin/base/base_messages.html")
return simplejson.dumps(self.success(data={"tmpl": tmpl, "messages_tmpl": messages_tmpl}))
def wrapper(self, *args, **kwargs):
if not self.current_user:
logger.info("[authenticated]: %s" % self.current_user)
if self.request.method in ("GET", "HEAD", "POST", "CHECK", "XGET"):
url = self.get_login_url()
if "?" not in url:
if urlparse.urlsplit(url).scheme:
# if login url is absolute, make next absolute too
next_url = self.request.full_url()
else:
next_url = self.request.uri
url += "?" + urllib.urlencode(dict(next=next_url))
headers = self.request.headers
x_requested_with = headers.get("X-Requested-With", "")
if x_requested_with == "XMLHttpRequest":
logger.info("return simplejson data: SESSION_FAILD")
if headers.get("X-PJAX"):
self.redirect(url)
else:
return self.write(
simplejson.dumps({
"return_code": -231030,
"return_message": u"对不起会话已失效，请重新登录",
"data": {
"redirect_url": url
}
}))
else:
self.redirect(url)
return
raise HTTPError(403)
return method(self, *args, **kwargs)
def on_finish(self):
# logger.info("\t" + "====[EXIT]====")
# self.svc.__exit__(None, None, None)
# try:
# # transaction = session_dict.get("transaction")
# # logger.error("transaction: %s" % transaction)
# #if transaction:
# # dispatch = session_dict.get("dispatch")
# self.db.commit()
# # self.db.flush()
# logger.info("\t" + "====[COMMIT]====")
# except Exception:
# logThrown()
# self.db.rollback()
# logger.info("\t" + "====[ROLLBACK]====")
# self.db.remove()
self.db.close()
logger.info("\t" + "====[CLOSE]====")
# logger.info(self.db.is_active)
# logger.info("====================== [http method (%s)] ======================" % self.request.method)
# self.db.is_active
# self.db.remove()
# self.db.close()
# logger.info(self.db)
# logger.info(self.db.is_active)
logger.critical("<" + "="*25 + " [finish] " + "="*25 + ">")
def post(self, **kwargs):
svc = ProResourceApplyService(self, kwargs)
delete_res = svc.do_delete()
pro_resource_applies_res = svc.get_list()
svc = ProjectService(self)
pro_list_res = svc.get_project_list()
# svc = ProResourceApplyService(self)
if pro_list_res.return_code < 0:
raise SystemError(pro_list_res.return_code,
pro_list_res.return_message)
logger.info(pro_list_res)
data = dict(pro_list_res=pro_list_res,
page=self.getPage(pro_resource_applies_res.data))
if isinstance(delete_res, Exception):
raise delete_res
# data = self.get_pro_info_res(kwargs["pro_id"])
if delete_res.return_code == 0:
self.add_message(
"云资源[%s-%s]记录删除成功！" %
(delete_res.data.project.name, delete_res.data.desc),
level="success")
publish_notice_checker.delay(self.current_user.id)
else:
self.add_message(
"云资源记录删除失败！(%s)%s" %
(delete_res.return_code, delete_res.return_message),
level="warning")
# logger.info("\t [data]: %s" % data )
# logger.info("\t [data pro_info_res]: %s" % data["pro_info_res"])
tmpl = self.render_to_string("admin/apply/resource/index_pjax.html",
**data)
return simplejson.dumps(self.success(data=tmpl))
def on_finish(self):
# logger.info("\t" + "====[EXIT]====")
# self.svc.__exit__(None, None, None)
# try:
# # transaction = session_dict.get("transaction")
# # logger.error("transaction: %s" % transaction)
# #if transaction:
# # dispatch = session_dict.get("dispatch")
# self.db.commit()
# # self.db.flush()
# logger.info("\t" + "====[COMMIT]====")
# except Exception:
# logThrown()
# self.db.rollback()
# logger.info("\t" + "====[ROLLBACK]====")
# self.db.remove()
self.db.close()
logger.info("\t" + "====[CLOSE]====")
# logger.info(self.db.is_active)
# logger.info("====================== [http method (%s)] ======================" % self.request.method)
# self.db.is_active
# self.db.remove()
# self.db.close()
# logger.info(self.db)
# logger.info(self.db.is_active)
logger.critical("<" + "=" * 25 + " [finish] " + "=" * 25 + ">")
def post(self, **kwargs):
svc = ProResourceApplyService(self, kwargs)
delete_res = svc.do_delete()
pro_resource_applies_res = svc.get_list()
svc = ProjectService(self)
pro_list_res = svc.get_project_list()
# svc = ProResourceApplyService(self)
if pro_list_res.return_code < 0:
raise SystemError(pro_list_res.return_code, pro_list_res.return_message)
logger.info(pro_list_res)
data = dict(
pro_list_res = pro_list_res,
page = self.getPage(pro_resource_applies_res.data)
)
if isinstance(delete_res, Exception):
raise delete_res
# data = self.get_pro_info_res(kwargs["pro_id"])
if delete_res.return_code == 0:
self.add_message("云资源[%s-%s]记录删除成功！"% (delete_res.data.project.name, delete_res.data.desc), level="success")
publish_notice_checker.delay(self.current_user.id)
else:
self.add_message("云资源记录删除失败！(%s)%s"% (delete_res.return_code, delete_res.return_message), level="warning")
# logger.info("\t [data]: %s" % data )
# logger.info("\t [data pro_info_res]: %s" % data["pro_info_res"])
tmpl = self.render_to_string("admin/apply/resource/index_pjax.html", **data)
return simplejson.dumps(self.success(data=tmpl))
def post_user_roles(user_id, role_ids):
result = get_user_roles(user_id)
user_role_obj = result["data"]["role_obj"]
user_role_list = [str(i) for i in user_role_obj.keys()]
# logger.info("============================")
# logger.info(set(role_group_op_list))
# logger.info(set(group_ops))
# logger.info("============================")
need_deletes = set(user_role_list) - set(role_ids)
logger.info(need_deletes)
# role_list = [(g, op) for g, op in [_str.split(".") for _str in role_ids]]
# need_delete_list = [(g, op) for g, op in [_str.split(".") for _str in need_deletes]]
for role_id in role_ids:
instance, created = PT_User_Role.get_or_create(
user_id=int(user_id),
role_id=int(role_id),
)
with DataBaseService({}) as svc:
for role_id in need_deletes:
svc.db.query(PT_User_Role).filter(
PT_User_Role.user_id == int(user_id),
PT_User_Role.role_id == int(role_id)).delete()
data = {
"return_code": 0,
"return_message": u"",
"data": {
"roles": result["data"]["roles"]
}
}
return data
def post(self, **kwargs):
data = self.get_pro_data()
svc = ProResourceApplyService(self, self.args)
pro_resource_apply_res = svc.get_resource()
logger.info("[pro_resource_apply_res] %s" % pro_resource_apply_res)
fee_res = svc.generate_fee()
svc = ProjectService(self)
env_resource_value_res = svc.load_env_resource_values()
env_internet_ip_types_res = svc.load_env_internet_ip_types()
data.update(dict(
fee_res = fee_res,
pro_resource_apply_res = pro_resource_apply_res,
env_internet_ip_types_res = env_internet_ip_types_res,
env_resource_value_res = env_resource_value_res,
))
logger.info(fee_res)
if fee_res.return_code == 0:
self.add_message(u"费用计算成功！单月费用 %s（元/月）×有效期 %s（月）=总费用 %s（元）" % (fee_res.data["unit_fee"], self.args.get('period'), fee_res.data["total_fee"]), level="success")
else:
if fee_res.return_code == ERROR.database_save_err.errcode:
return_messages = fee_res.return_messages
self.add_message(u"费用计算失败！", level="warning")
for msg in return_messages:
self.add_message(u"%s" % msg, level="warning")
else:
self.add_message(u"费用计算失败！ %s(%s)" % (fee_res.return_code, fee_res.return_message), level="warning")
messages_tmpl = self.render_to_string("admin/base/base_messages.html")
tmpl = self.render_to_string("admin/guide/_step_1_res_fee_form.html", **data)
# tmpl = self.render_to_string("admin/apply/resource/add_pjax.html", **data)
return simplejson.dumps(self.success(data={"tmpl": tmpl, "messages_tmpl": messages_tmpl}))
def callback(future):
try:
if self._finished:
logger.info("+++++++++++++++ future.result() +++++++++++++++")
logger.info(future.result())
return future.result()
else:
# logger.info("+++++++++++++++ future.result() +++++++++++++++")
# logger.info(future.result())
self.write(future.result())
except Exception as e:
logThrown()
if isinstance(e, SystemError):
template_string = self.render_to_string("admin/error/500.html", status_code=500, exception=u"系统错误(%s)" % e.code, traceback=e.message)
if self.ajax:
self.write(simplejson.dumps(self.failure(e.code, e.message)))
else:
self.write(template_string)
if isinstance(e, NotFoundError):
template_string = self.render_to_string("admin/error/404.html", status_code=404, exception=u"数据查询异常(%s)" % e.code, traceback=e.message)
if self.ajax:
self.write(simplejson.dumps(self.failure(e.code, e.message)))
else:
self.write(template_string)
else:
template_string = self.render_to_string("admin/error/500.html", status_code=500, exception=u"系统错误", traceback=e.__unicode__())
if self.ajax:
self.write(simplejson.dumps(self.failure(ERROR.system_err.errcode, "(%s)%s:%s" % (ERROR.system_err.errcode, ERROR.system_err.errvalue, e.__unicode__()))))
else:
self.write(template_string)
self.finish()
def do_check(self):
pro_table = self.params.get("pro_table")
action = self.params.get("action")
reason = self.params.get("reason")
actions = [STATUS_PRO_TABLES.get(i).value_en for i in STATUS_PRO_TABLES.keys() if isinstance(i, int)]
if action not in actions:
return self.failure(ERROR.res_do_resource_action_err)
ProTable = self.pro_tables.get(pro_table)
if not ProTable:
return self.failure(ERROR.not_found_err)
ids = self.params.get("ids")
id_list = [int(i) for i in ids.split(",") if i.strip().isdigit()]
logger.info(id_list)
pro_table_objs = []
for id in id_list:
pro_table_obj = self.db.query(
ProTable
).filter(
ProTable.id == id
).first()
if pro_table_obj:
if action == STATUS_PRO_TABLES.checked.value_en:
pro_table_obj.status = STATUS_PRO_TABLES.CHECKED
elif action == STATUS_PRO_TABLES.refused.value_en:
pro_table_obj.status = STATUS_PRO_TABLES.REFUSED
pro_table_obj.reason = reason
pro_table_obj.checker_id = self.handler.current_user.id
pro_table_obj.check_time = datetime.now()
self.db.add(pro_table_obj)
self.db.flush()
pro_table_objs.append(pro_table_obj)
return self.success(data=pro_table_objs)
def post(self):
svc = ApplyBackups(self)
pro_backup_res = svc.do_backups()
pro_id = self.args.get("pro_id")
data = self.get_pro_data(pro_id=pro_id)
# svc = ApplyLoadBalance(self)
# loadbalance_res = svc.get_loadbalance()
# svc = ApplyBackups(self)
# backups_res = svc.get_backups()
data.update(
pro_backup_res=pro_backup_res
) # , loadbalance_res=loadbalance_res, backups_res=backups_res)
logger.info(pro_backup_res)
if pro_backup_res.return_code == 0:
self.add_message(
u"定期备份信息添加成功！%s" %
STATUS_PRO_TABLES.get(pro_backup_res.data.status).todo_value,
level="success")
tmpl = self.render_to_string(
"admin/guide/_step_3_backup_detail.html", **data)
publish_notice_checker.delay(self.current_user.id)
else:
tmpl = self.render_to_string("admin/guide/_step_3_backup.html",
**data)
self.add_message(
u"定期备份信息添加失败！(%s)(%s)" %
(pro_backup_res.return_code, pro_backup_res.return_message),
level="warning")
messages_tmpl = self.render_to_string("admin/base/base_messages.html")
return simplejson.dumps(
self.success(data={
"tmpl": tmpl,
"messages_tmpl": messages_tmpl
}))
def get_current_user(self):
current_user = self.session.get("current_user", None)
# logger.info("******[GET SESSION] %s" % current_user)
if current_user:
logger.info("\t [current_user]: %s(%s)-perms:(%s)" % (current_user.id, current_user.username, current_user.get_current_perms()))
else:
logger.info("\t [current_user]: None")
return current_user
def get_project_list(kwargs={}):
logger.info("------[celery task get_project_list]------")
with DataBaseService(kwargs) as svc:
projects = svc.db.query(Pro_Info).all()
project_list = [i.as_dict() for i in projects]
logger.info("project_list")
res = {"return_code": 0, "return_message": "", "data": project_list}
return res
def get_info(self):
logger.info("------[get_info]------")
perm_id = self.params.get("perm_id")
pt_perm = svc.db.query(PT_Perm).filter(PT_Perm.id == perm_id).first()
if pt_perm:
return self.success(data=projects)
else:
return NotFoundError()
def get(self):
svc = ProjectService(self)
pro_list_res = svc.get_project_list()
if pro_list_res.return_code < 0:
raise SystemError(pro_list_res.return_code, pro_list_res.return_message)
logger.info(pro_list_res)
data = dict(pro_list_res=pro_list_res)
return self.render_to_string("admin/event/add.html", **data)
def load_env_resource_values(self):
logger.info("------[load_env_resource_values]------")
pro_id = self.params.get("pro_id", 0)
project = self.db.query(Pro_Info).filter(Pro_Info.id == pro_id).first()
if project:
env_resource_value = project.env.env_resource_value
return self.success(data=env_resource_value.as_dict() if env_resource_value else {})
else:
return self.failure(ERROR.not_found_err)
def task_act_post(act_type=1, table_name="", table_doc=""):
logger.info("------[celery task post act]------")
logger.info("------[ act type %s ]------" % act_type)
with DataBaseService({}) as svc:
act = Act_History()
act.act_type = act_type
act.desc = act_actions[act_type].value % table_doc
svc.db.add(act)
svc.db.flush()
def task_act_post(act_type=1, table_name="", table_doc=""):
logger.info("------[celery task post act]------")
logger.info("------[ act type %s ]------" % act_type)
with DataBaseService({}) as svc:
act = Act_History()
act.act_type = act_type
act.desc = act_actions[act_type].value % table_doc
svc.db.add(act)
svc.db.flush()
def _db_init(self):
self.db = self.__class__.__DB_Session()
if CONF("DB.ENGINE").lower() == "myisam":
try:
self.db.begin()
logger.info("====[begin transaction]====")
except:
logThrown()
logger.info("====[INIT DB, DB.BEGIN]====")
def get(self):
svc = ProjectService(self)
pro_list_res = svc.get_project_list()
if pro_list_res.return_code < 0:
raise SystemError(pro_list_res.return_code,
pro_list_res.return_message)
logger.info(pro_list_res)
data = dict(pro_list_res=pro_list_res)
return self.render_to_string("admin/event/add.html", **data)
def get_or_create(self):
logger.info("------ [get_or_create] ------")
name = self.params.get("name", "")
keyword = self.params.get("keyword", "")
perm_info, created = PT_Perm.get_or_create_obj(self.db,
name = name,
keyword = keyword,
)
return self.success(data=perm_info)
def delete_info(self):
logger.info("------ [delete_info] ------")
user_id = self.params.get("user_id")
is_success = self.db.query(
PT_User
).filter(
PT_User.id == user_id,
).delete()
return self.success(data={"is_success": is_success})
def _db_init(self):
self.db = self.__class__.__DB_Session()
if CONF("DB.ENGINE").lower() == "myisam":
try:
self.db.begin()
logger.info("====[begin transaction]====")
except:
logThrown()
logger.info("====[INIT DB, DB.BEGIN]====")
def get(self):
env_svc = EnvService(self)
env_list_res = env_svc.get_list()
svc = ProjectService(self)
result = svc.get_project_list()
if result.return_code < 0:
raise SystemError(result.return_code, result.return_message)
logger.info(result)
return self.render_to_string("admin/guide/index.html", result=result, pro_resource_apply_status_types=pro_resource_apply_status_types, env_list_res=env_list_res)
def get_profile(self):
logger.info("------[get_profile]------")
current_user_id = self.handler.current_user.id
if current_user_id:
pt_user = self.db.query(PT_User).filter(
PT_User.id == current_user_id).first()
return self.success(data=pt_user)
else:
return NotFoundError()
def task_post_action(act_type=1, content=u"", user_id=0):
logger.info("------[celery task post action]------")
logger.info("------[ act type %s ]------" % act_type)
with DataBaseService({}) as svc:
act = Act_History()
act.act_type = act_type
act.desc = content
act.user_id = user_id
svc.db.add(act)
svc.db.flush()
def task_post_action(act_type=1, content=u"", user_id=0):
logger.info("------[celery task post action]------")
logger.info("------[ act type %s ]------" % act_type)
with DataBaseService({}) as svc:
act = Act_History()
act.act_type = act_type
act.desc = content
act.user_id = user_id
svc.db.add(act)
svc.db.flush()
def load_env_internet_ip_types(self):
logger.info("------[load_env_internet_ip_types]------")
pro_id = self.params.get("pro_id", 0)
project = self.db.query(Pro_Info).filter(Pro_Info.id == pro_id).first()
if project:
internet_ip_types = project.env.env_internet_ip_types
internet_ip_options = [{"value": i.id, "desc": i.name, "bandwidths": i.bandwidths} for i in internet_ip_types]
return self.success(data=internet_ip_options)
else:
return self.failure(ERROR.not_found_err)
def get(self):
svc = ApplyBackups(self)
pro_backup_res = svc.get_info()
if pro_backup_res.return_code < 0:
raise SystemError(pro_backup_res.return_code, pro_backup_res.return_message)
logger.info(pro_backup_res)
data = {
"pro_backup_res": pro_backup_res,
}
return self.render_to_string("admin/apply/backup/detail.html", **data)
def get(self):
svc = ProResourceApplyService(self)
pro_resource_apply_res = svc.get_resource()
if pro_resource_apply_res.return_code < 0:
raise SystemError(pro_resource_apply_res.return_code, pro_resource_apply_res.return_message)
logger.info(pro_resource_apply_res)
data = {
"pro_resource_apply_res": pro_resource_apply_res,
}
return self.render_to_string("admin/apply/resource/detail.html", **data)
def get_or_create(self):
logger.info("------ [get_or_create] ------")
name = self.params.get("name", "")
keyword = self.params.get("keyword", "")
perm_info, created = PT_Perm.get_or_create_obj(
self.db,
name=name,
keyword=keyword,
)
return self.success(data=perm_info)
def get(self):
svc = EventService(self)
pro_event_res = svc.get_info()
if pro_event_res.return_code < 0:
raise SystemError(pro_event_res.return_code, pro_event_res.return_message)
logger.info(pro_event_res)
data = {
"pro_event_res": pro_event_res,
}
return self.render_to_string("admin/event/detail.html", **data)
def get(self):
svc = ApplyLoadBalance(self)
pro_loadbalance_res = svc.get_info()
if pro_loadbalance_res.return_code < 0:
raise SystemError(pro_loadbalance_res.return_code, pro_loadbalance_res.return_message)
logger.info(pro_loadbalance_res)
data = {
"pro_loadbalance_res": pro_loadbalance_res,
}
return self.render_to_string("admin/apply/loadbalance/detail.html", **data)
def get(self):
svc = ApplyPublish(self)
pro_publish_res = svc.get_publish()
if pro_publish_res.return_code < 0:
raise SystemError(pro_publish_res.return_code, pro_publish_res.return_message)
logger.info(pro_publish_res)
data = {
"pro_publish_res": pro_publish_res,
}
return self.render_to_string("admin/apply/publish/detail.html", **data)
def get_env(self):
logger.info("------[get_env]------")
env_id = self.params.get("env_id")
env = self.db.query(
Env_Info
).filter(
Env_Info.id == env_id
).first()
if not env:
raise NotFoundError()
return self.success(data=env)
