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 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 _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_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 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 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)