Пример #1
0
 def get(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     obj_group_id = request.GET.get("obj_group_id")
     if not obj_group_id:
         context = {"code": 1, "msg": "对象组id不能为空"}
         return JsonResponse(context)
     try:
         object_group = ObjectGroup.objects.get(obj_group_id=obj_group_id)
         id = object_group.id
         object_list = Object.objects.filter(
             obj_group_id=id, object_user=user_id).order_by("id")
     except Exception as e:
         context = {"code": 1, "msg": "相关对象信息不存在"}
         return JsonResponse(context)
     all_object_data = list()
     for obj in object_list:
         data_dict = dict()
         data_dict["id"] = obj.id
         data_dict["object_id"] = obj.object_id
         data_dict["object_name"] = obj.object_name
         all_object_data.append(data_dict)
     data = {"all_data": all_object_data}
     context = {"code": 0, "msg": "获取对象信息成功", "data": data}
     return JsonResponse(context)
Пример #2
0
 def get(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     user = User.objects.get(id=user_id)
     username = user.username
     email = user.email
     last_login = user.last_login
     is_superuser = user.is_superuser
     first_name = user.first_name
     last_name = user.last_name
     date_joined = user.date_joined
     is_active = user.is_active
     data = {
         "username": username,
         "email": email,
         "last_login": last_login,
         "is_superuser": is_superuser,
         "first_name": first_name,
         "last_name": last_name,
         "date_joined": date_joined,
         "is_active": is_active
     }
     context = {"code": 0, "msg": "获取用户信息页面成功", "data": data}
     return JsonResponse(context)
Пример #3
0
 def get(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     try:
         object_group_data = ObjectGroup.objects.filter(
             obj_group_user=user_id).order_by("id")
     except Exception as e:
         context = {"code": 1, "msg": "参数错误,请重新填写"}
         return JsonResponse(context)
     try:
         data_list = list()
         for group_data in object_group_data:
             data_dict = dict()
             data_dict["id"] = group_data.id
             data_dict["obj_group_name"] = group_data.obj_group_name
             data_dict["obj_group_id"] = group_data.obj_group_id
             data_list.append(data_dict)
         api_dict = dict()
         api_dict["all_data"] = data_list
         context = {"code": 0, "msg": "成功获取API", "data": api_dict}
         return JsonResponse(context, safe=False)
     except Exception as e:
         context = {"code": 1, "msg": "参数错误,请重新填写"}
         return JsonResponse(context)
Пример #4
0
 def post(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     user = User.objects.get(id=user_id)
     try:
         data_dict = json.loads(request.body.decode("utf-8"))
     except Exception as e:
         context = {"code": 1, "msg": "获取json数据失败"}
         return JsonResponse(context)
     try:
         pipe_id = data_dict["pipe_id"]
     except KeyError as e:
         context = {"code": 1, "msg": "数据管道标识不能为空"}
         return JsonResponse(context)
     try:
         pipe_name = data_dict["pipe_name"]
     except KeyError as e:
         context = {"code": 1, "msg": "数据管道名称不能为空"}
         return JsonResponse(context)
     try:
         template = data_dict["template"]
     except KeyError as e:
         template = self.template
     try:
         script = data_dict["script"]
     except KeyError as e:
         script = self.script
     try:
         remark = data_dict["remark"]
     except KeyError as e:
         remark = self.remark
     try:
         tool = DataPipe.objects.get(pipe_id=pipe_id)
     except Exception as e:
         tool = False
     if tool:
         context = {"code": 1, "msg": "数据管道标识已存在,请重新输入"}
         return JsonResponse(context)
     if not re.match(r"^[a-zA-Z0-9_]{4,16}$", str(pipe_id)):
         context = {"code": 1, "msg": "数据管道标识为4-16位的字母,数字或下划线"}
         return JsonResponse(context)
     try:
         datapipe = DataPipe()
         datapipe.pipe_id = pipe_id
         datapipe.pipe_name = pipe_name
         datapipe.template = template
         datapipe.script = script
         datapipe.remark = remark
         datapipe.pipe_user = user
         datapipe.save()
     except Exception as e:
         context = {"code": 1, "msg": "添加数据管道失败"}
         return JsonResponse(context)
     context = {"code": 0, "msg": "添加数据管道成功"}
     return JsonResponse(context)
Пример #5
0
 def get(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     filter_list = DataFilter.objects.filter(filter_user=user_id).order_by("id")
     if not filter_list:
         context = {"code": 0, "msg": "还未有过滤器注册",
                    "data": {"all_data": [], "single_data": {}}}
         return JsonResponse(context)
     id = request.GET.get('id')
     keyword = request.GET.get("keyword")
     if not keyword:
         if not id:
             id = filter_list[0].id
             all_filter_data = list()
             for filter in filter_list:
                 data_dict = dict()
                 data_dict["id"] = filter.id
                 data_dict["filter_id"] = filter.filter_id
                 data_dict["filter_name"] = filter.filter_name
                 all_filter_data.append(data_dict)
             filter_dict = self.get_single_data(id, user_id)
             data = {"all_data": all_filter_data, "single_data": filter_dict}
             context = {"code": "0", "msg": "获取过滤器成功", "data": data}
             return JsonResponse(context)
         else:
             filter_dict = self.get_single_data(id, user_id)
             data = {"single_data": filter_dict}
             context = {"code": "0", "msg": "获取过滤器成功", "data": data}
             return JsonResponse(context)
     else:
         keyword = keyword.strip(" ")
         search_result = list()
         for filter in filter_list:
             filter_dict = dict()
             if (keyword.upper() in filter.filter_id.upper()) or (keyword.upper() in filter.filter_name.upper()):
                 filter_dict["id"] = filter.id
                 filter_dict["filter_id"] = filter.filter_id
                 filter_dict["filter_name"] = filter.filter_name
             if filter.filter_name.upper() in keyword.upper():
                 filter_dict["id"] = filter.id
                 filter_dict["filter_id"] = filter.filter_id
                 filter_dict["filter_name"] = filter.filter_name
             if filter_dict:
                 search_result.append(filter_dict)
         if not search_result:
             data = {"all_data": search_result, "single_data": {}}
             context = {"code": 0, "msg": "搜索的内容不存在", "data": data}
             return JsonResponse(context)
         id = search_result[0]["id"]
         filter_dict = self.get_single_data(id, user_id)
         data = {"all_data": search_result, "single_data": filter_dict}
         context = {"code": 0, "msg": "搜索成功", "data": data}
         return JsonResponse(context)
Пример #6
0
 def get(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     client_list = Account.objects.filter(account_user=user_id).order_by("id")
     if not client_list:
         context = {"code": 0, "msg": "还未有账户注册", "data": {"single_data": {}, "all_data": []}}
         return JsonResponse(context)
     id = request.GET.get("id")
     keyword = request.GET.get("keyword")
     if not keyword:
         if not id:
             id = client_list[0].id
             all_account_data = list()
             for client in client_list:
                 data_dict = dict()
                 data_dict["id"] = client.id
                 data_dict["account_id"] = client.account_id
                 data_dict["account_name"] = client.account_name
                 all_account_data.append(data_dict)
             client_data = self.get_single_data(id, user_id)
             data = {"all_data": all_account_data, "single_data": client_data}
             context = {"code": 0, "msg": "获取账户页面成功", "data": data}
             return JsonResponse(context)
         else:
             client_data = self.get_single_data(id, user_id)
             data = {"single_data": client_data}
             context = {"code": 0, "msg": "获取账户页面成功", "data": data}
             return JsonResponse(context)
     else:
         keyword = keyword.strip(" ")
         search_result = list()
         for account in client_list:
             account_dict = dict()
             if (keyword.upper() in account.account_id.upper()) or (keyword.upper() in account.account_name.upper()):
                 account_dict["id"] = account.id
                 account_dict["account_id"] = account.account_id
                 account_dict["account_name"] = account.account_name
             if account.account_name.upper() in keyword.upper():
                 account_dict["id"] = account.id
                 account_dict["account_id"] = account.account_id
                 account_dict["account_name"] = account.account_name
             if account_dict:
                 search_result.append(account_dict)
         if not search_result:
             data = {"all_data": search_result, "single_data": {}}
             context = {"code": 0, "msg": "搜索的内容不存在", "data": data}
             return JsonResponse(context)
         id = search_result[0]["id"]
         client_data = self.get_single_data(id, user_id)
         data = {"all_data": search_result, "single_data": client_data}
         context = {"code": 0, "msg": "搜索成功", "data": data}
         return JsonResponse(context)
Пример #7
0
 def delete(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     id = request.GET.get("id")
     if not all([id]):
         context = {"code": 1, "msg": "参数不完整"}
         return JsonResponse(context)
     Object.objects.filter(id=id, object_user=user_id).delete()
     context = {"code": 0, "msg": "删除对象信息成功"}
     return JsonResponse(context)
Пример #8
0
 def get(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     organzier_list = DataOrganizer.objects.filter(organizer_user=user_id).order_by("id")
     all_organizer_data = list()
     for organizer in organzier_list:
         data_dict = dict()
         data_dict["id"] = organizer.id
         data_dict["organizer_name"] = organizer.organizer_name
         data_dict["organizer_id"] = organizer.organizer_id
         all_organizer_data.append(data_dict)
     data = {"all_data": all_organizer_data}
     context = {"code": 0, "msg": "获取组织器api成功", "data": data}
     return JsonResponse(context, safe=False)
Пример #9
0
 def delete(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     id = request.GET.get("id")
     if not all([id]):
         context = {"code": 1, "msg": "参数不完整"}
         return JsonResponse(context)
     try:
         DataPipe.objects.filter(id=id, pipe_user=user_id).delete()
     except Exception as e:
         context = {"code": 1, "msg": "删除数据管道失败"}
         return JsonResponse(context)
     context = {"code": 0, "msg": "删除数据管道成功"}
     return JsonResponse(context)
Пример #10
0
 def get(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     msg_out = MessageOut.objects.filter(
         msg_out_user=user_id).order_by("id")
     all_msg_data = list()
     for msg in msg_out:
         data_dict = dict()
         data_dict["id"] = msg.id
         data_dict["msg_out_id"] = msg.msg_out_id
         data_dict["msg_out_name"] = msg.msg_out_name
         all_msg_data.append(data_dict)
     data = {"all_data": all_msg_data}
     context = {"code": 0, "msg": "获取数据管道api成功", "data": data}
     return JsonResponse(context)
Пример #11
0
 def delete(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     user = User.objects.get(id=user_id)
     id = request.GET.get("id")
     if not all([id]):
         context = {"code": 1, "msg": "参数不完整"}
         return JsonResponse(context)
     try:
         Account.objects.filter(id=id, account_user=user).delete()
     except Exception as e:
         context = {"code": 1, "msg": "删除账户信息失败"}
         return JsonResponse(context)
     context = {"code": 0, "msg": "删除账户信息成功"}
     return JsonResponse(context)
Пример #12
0
 def get(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     object_list = Object.objects.filter(object_user=user_id).order_by("id")
     all_object_data_list = list()
     for objs in object_list:
         data_dict = dict()
         data_dict["id"] = objs.id
         data_dict["object_name"] = objs.object_name
         data_dict["object_id"] = objs.object_id
         all_object_data_list.append(data_dict)
     data = dict()
     data["all_data"] = all_object_data_list
     context = {"code": 0, "msg": "成功获取API", "data": data}
     return JsonResponse(context)
Пример #13
0
 def get(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     client_list = Account.objects.filter(account_user=user_id).order_by("id")
     if not client_list:
         context = {"code": 1, "msg": "还未有账户注册", "data": {}}
         return JsonResponse(context)
     all_account_data = list()
     for client in client_list:
         data_dict = dict()
         data_dict["id"] = client.id
         data_dict["account_name"] = client.account_name
         data_dict["account_id"] = client.account_id
         all_account_data.append(data_dict)
     data = {"all_data": all_account_data}
     context = {"code": 0, "msg": "获取账户api成功", "data": data}
     return JsonResponse(context, safe=False)
Пример #14
0
 def get(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     analysis_list = AnalysisParameter.objects.filter(
         analysis_user=user_id).order_by("id")
     if not analysis_list:
         context = {"code": 0, "msg": "分析参数为空", "data": {}}
         return JsonResponse(context)
     all_analysis_data_list = list()
     for analysis in analysis_list:
         data_dict = dict()
         data_dict["id"] = analysis.id
         data_dict["ana_para_id"] = analysis.ana_para_id
         data_dict["ana_para_name"] = analysis.ana_para_name
         all_analysis_data_list.append(data_dict)
     data = {"all_data": all_analysis_data_list}
     context = {"code": 0, "msg": "获取数据成功", "data": data}
     return JsonResponse(context)
Пример #15
0
 def get(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     data_pipe_list = DataPipe.objects.filter(
         pipe_user=user_id).order_by("id")
     if not data_pipe_list:
         context = {"code": 0, "msg": "还未有数据源注册", "data": {}}
         return JsonResponse(context)
     all_data_pipe_list = []
     for pipe in data_pipe_list:
         data_dict = dict()
         data_dict["id"] = pipe.id
         data_dict["pipe_name"] = pipe.pipe_name
         data_dict["pipe_id"] = pipe.pipe_id
         all_data_pipe_list.append(data_dict)
     data = {"all_data": all_data_pipe_list}
     context = {"code": 0, "msg": "获取数据成功", "data": data}
     return JsonResponse(context)
Пример #16
0
 def get(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     optimization_list = OptimizationParameter.objects.filter(
         optimization_user=user_id).order_by("id")
     if not optimization_list:
         context = {"code": 0, "msg": "优化参数为空", "data": {}}
         return JsonResponse(context)
     all_optimization_data_list = list()
     for optimization in optimization_list:
         data_dict = dict()
         data_dict["id"] = optimization.id
         data_dict["opt_para_name"] = optimization.opt_para_name
         data_dict["opt_para_id"] = optimization.opt_para_id
         all_optimization_data_list.append(data_dict)
     data = {"all_data": all_optimization_data_list}
     context = {"code": 0, "msg": "获取数据成功", "data": data}
     return JsonResponse(context)
Пример #17
0
 def get(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     object_id = request.GET.get("object_id")
     if not object_id:
         context = {"code": 1, "msg": "object_id不能为空"}
         return JsonResponse(context)
     data = {"equipment_id": object_id}
     try:
         response = requests.post(APIQ_PRO_URL, data=data)
         content = json.loads(response.text)
     except Exception as e:
         context = {"code": 1, "msg": "indass请求mapping数据出错"}
         return JsonResponse(context)
     if content["code"] != 200:
         context = {"code": 1, "msg": "indass请求mapping数据出错"}
         return JsonResponse(context)
     all_data = content["info"]["script"]
     data = {"all_data": all_data}
     context = {"code": 0, "msg": "获取mapping数据成功", "data": data}
     return JsonResponse(context)
Пример #18
0
 def put(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     user = User.objects.filter(id=user_id)
     try:
         data_dict = json.loads(request.body.decode("utf-8"))
     except Exception as e:
         context = {"code": 1, "msg": "获取json数据失败"}
         return JsonResponse(context)
     try:
         username = data_dict["username"]
         password = data_dict["password"]
         email = data_dict["email"]
     except Exception as e:
         context = {"code": 1, "msg": "参数不完整"}
         return JsonResponse(context)
     try:
         first_name = data_dict["first_name"]
     except Exception as e:
         first_name = self.first_name
     try:
         last_name = data_dict["last_name"]
     except Exception as e:
         last_name = self.last_name
     if not all([username, password, email]):
         context = {"code": 1, "msg": "参数不完整"}
         return JsonResponse(context)
     if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}', str(email)):
         context = {"code": 1, "msg": "邮箱格式错误"}
         return JsonResponse(context)
     user.password = password
     user.email = email
     user.first_name = first_name
     user.last_name = last_name
     user.save()
     context = {"code": 0, "msg": "用户信息修改成功"}
     return JsonResponse(context)
Пример #19
0
 def get(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     param1 = {
         'username': '******',
         'password': '******',
         'system': 'PRO'
     }
     try:
         r1 = requests.post(self.login_url, data=param1)
         dic1 = json.loads(r1.text)
         token = dic1["data"]["token"]
         headers = {'Authorization': 'Bearer ' + token}
         data = {
             "is_all": 1,
             "page_index": 1,
             "page_size": 20,
             "condition": ""
         }
         result = requests.post(self.apiq_url, headers=headers, data=data)
         result = json.loads(result.text)
         all_data = list()
         for equipment in result["data"]:
             data = dict()
             data["object_id"] = equipment["equipment_id"]
             data["object_name"] = equipment["equipment_name"]
             all_data.append(data)
         all_data_dict = dict()
         all_data_dict["all_data"] = all_data
         return_data = {
             "code": 0,
             "msg": "The request is successful!",
             "data": all_data_dict
         }
     except Exception as e:
         return_data = {"code": 1, "msg": "request failed!"}
     return JsonResponse(return_data)
Пример #20
0
 def post(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     user = User.objects.get(id=user_id)
     try:
         data_dict = json.loads(request.body.decode("utf-8"))
     except Exception as e:
         context = {"code": 1, "msg": "获取json数据失败"}
         return JsonResponse(context)
     try:
         ana_para_id = data_dict["ana_para_id"]
     except KeyError as e:
         context = {"code": 1, "msg": "分析参数标识不能为空"}
         return JsonResponse(context)
     try:
         ana_para_name = data_dict["ana_para_name"]
     except KeyError as e:
         context = {"code": 1, "msg": "分析参数名称不能为空"}
         return JsonResponse(context)
     try:
         script = data_dict["script"]
         if not script:
             context = {"code": 1, "msg": "脚本不能为空"}
             return JsonResponse(context)
     except KeyError as e:
         context = {"code": 1, "msg": "脚本不能为空"}
         return JsonResponse(context)
     try:
         object_id = data_dict["object_id"]
     except KeyError as e:
         context = {"code": 1, "msg": "分析对象标识不能为空"}
         return JsonResponse(context)
     try:
         template = data_dict["template"]
     except KeyError as e:
         template = self.template
     try:
         remark = data_dict["remark"]
     except KeyError as e:
         remark = self.remark
     if not all([ana_para_id, ana_para_name, script, object_id]):
         context = {"code": 1, "msg": "参数不完整"}
         return JsonResponse(context)
     try:
         tool = AnalysisParameter.objects.get(ana_para_id=ana_para_id)
     except Exception as e:
         tool = False
     if tool:
         context = {"code": 1, "msg": "分析参数标识已存在,请重新输入"}
         return JsonResponse(context)
     if not re.match(r"^[a-zA-Z0-9_]{4,16}$", str(ana_para_id)):
         context = {"code": 1, "msg": "分析参数标识为4-16位的字母,数字或下划线"}
         return JsonResponse(context)
     try:
         ana_object = Object.objects.get(object_id=object_id)
     except Exception as e:
         context = {"code": 1, "msg": "分析对象不存在"}
         return JsonResponse(context)
     try:
         ast.literal_eval(script)
     except Exception as e:
         context = {"code": 1, "msg": "分析参数脚本格式错误"}
         return JsonResponse(context)
     try:
         analysis_parameter = AnalysisParameter()
         analysis_parameter.ana_para_name = ana_para_name
         analysis_parameter.ana_para_id = ana_para_id
         analysis_parameter.script = script
         analysis_parameter.object_id = ana_object
         analysis_parameter.template = template
         analysis_parameter.remark = remark
         analysis_parameter.analysis_user = user
         analysis_parameter.save()
     except Exception as e:
         context = {"code": 1, "msg": "数据库添加分析参数信息失败"}
         return JsonResponse(context)
     context = {"code": 0, "msg": "添加分析参数成功"}
     return JsonResponse(context)
Пример #21
0
 def put(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     user = User.objects.get(id=user_id)
     try:
         data_dict = json.loads(request.body.decode("utf-8"))
     except Exception as e:
         context = {"code": 1, "msg": "获取json数据失败"}
         return JsonResponse(context)
     try:
         ana_object_id = Object.objects.get(
             object_id=data_dict["object_id"])
     except Exception:
         context = {"code": 1, "msg": "分析对象ID不能为空"}
         return JsonResponse(context)
     try:
         id = data_dict["id"]
     except KeyError as e:
         context = {"code": 1, "msg": "分析参数错误,请刷新页面重试"}
         return JsonResponse(context)
     try:
         ana_para_id = data_dict["ana_para_id"]
     except KeyError as e:
         context = {"code": 1, "msg": "分析参数标识不能为空"}
         return JsonResponse(context)
     try:
         ana_para_name = data_dict["ana_para_name"]
     except KeyError as e:
         context = {"code": 1, "msg": "分析参数名不能为空"}
         return JsonResponse(context)
     try:
         script = data_dict["script"]
         if not script:
             context = {"code": 1, "msg": "脚本不能为空"}
             return JsonResponse(context)
     except KeyError as e:
         context = {"code": 1, "msg": "脚本不能为空"}
         return JsonResponse(context)
     try:
         is_available = data_dict["is_available"]
     except KeyError as e:
         is_available = True
     try:
         template = data_dict["template"]
     except KeyError as e:
         template = self.template
     try:
         remark = data_dict["remark"]
     except KeyError as e:
         remark = self.remark
     if not re.match(r"^[a-zA-Z0-9_]{4,16}$", str(ana_para_id)):
         context = {"code": 1, "msg": "分析参数标识为4-16位的字母,数字或下划线"}
         return JsonResponse(context)
     try:
         ast.literal_eval(script)
     except Exception as e:
         context = {"code": 1, "msg": "分析参数脚本格式错误"}
         return JsonResponse(context)
     try:
         analysis_parameter = AnalysisParameter.objects.get(
             id=id, analysis_user=user_id)
         analysis_parameter.ana_para_name = ana_para_name
         analysis_parameter.ana_para_id = ana_para_id
         analysis_parameter.script = script
         analysis_parameter.object_id = ana_object_id
         analysis_parameter.template = template
         analysis_parameter.is_available = is_available
         analysis_parameter.remark = remark
         analysis_parameter.analysis_user = user
         analysis_parameter.save()
     except Exception as e:
         print(e)
         context = {"code": 1, "msg": "修改分析参数失败"}
         return JsonResponse(context)
     context = {"code": 0, "msg": "修改分析参数成功"}
     return JsonResponse(context)
Пример #22
0
 def put(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     user = User.objects.get(id=user_id)
     try:
         data_dict = json.loads(request.body.decode("utf-8"))
     except Exception as e:
         context = {"code": 1, "msg": "获取json数据失败"}
         return JsonResponse(context)
     try:
         id = data_dict["id"]
     except KeyError as e:
         context = {"code": 1, "msg": "分析对象不存在!"}
         return JsonResponse(context)
     try:
         object_id = data_dict["object_id"]
     except KeyError as e:
         context = {"code": 1, "msg": "分析对象标识不能为空"}
         return JsonResponse(context)
     object_id = str(object_id)
     try:
         is_available = data_dict["is_available"]
     except KeyError:
         is_available = True
     try:
         object_reference_id = data_dict["object_reference_id"]
     except KeyError:
         context = {"code": 1, "msg": "分析对象参考标识不能为空"}
         return JsonResponse(context)
     try:
         object_name = data_dict["object_name"]
     except KeyError:
         context = {"code": 1, "msg": "分析对象名不能为空"}
         return JsonResponse(context)
     try:
         obj_group_id = data_dict["obj_group_id"]
     except KeyError:
         context = {"code": 1, "msg": "分析对象组不能为空"}
         return JsonResponse(context)
     try:
         object_model = data_dict["object_model"]
     except KeyError:
         context = {"code": 1, "msg": "分析对象型号不能为空"}
         return JsonResponse(context)
     try:
         template = data_dict["template"]
     except KeyError as e:
         template = self.template
     try:
         script = data_dict["script"]
     except KeyError as e:
         script = self.script
     try:
         remark = data_dict["remark"]
     except KeyError as e:
         remark = self.remark
     if not re.match(r"^[a-zA-Z0-9_]{4,16}", str(object_id)):
         context = {"code": 1, "msg": "对象标识为4-16位的字母,数字或下划线"}
         return JsonResponse(context)
     if not re.match(r"^[a-zA-Z0-9_]{4,16}", str(object_reference_id)):
         context = {"code": 1, "msg": "分析对象参考标识为4-16位的字母,数字或下划线"}
         return JsonResponse(context)
     try:
         group_id = ObjectGroup.objects.get(obj_group_id=obj_group_id)
     except KeyError as e:
         context = {"code": 1, "msg": "分析对象组错误,请重新填写"}
         return JsonResponse(context)
     try:
         objects = Object.objects.get(id=id, object_user=user_id)
         objects.object_id = object_id
         objects.object_name = object_name
         objects.obj_group_id = group_id
         objects.object_reference_id = object_reference_id
         objects.object_model = object_model
         objects.script = script
         objects.remark = remark
         objects.template = template
         objects.is_available = is_available
         objects.object_user = user
         objects.save()
     except Exception:
         context = {"code": 1, "msg": "更新数据库失败"}
         return JsonResponse(context)
     context = {"code": 0, "msg": "修改对象成功"}
     return JsonResponse(context)
Пример #23
0
 def get(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     obj_group_list = ObjectGroup.objects.filter(
         obj_group_user=user_id).order_by("id")
     if not obj_group_list:
         context = {
             "code": 0,
             "msg": "还未有对象组注册",
             "data": {
                 "all_data": [],
                 "single_data": {}
             }
         }
         return JsonResponse(context)
     id = request.GET.get("id")
     keyword = request.GET.get("keyword")
     if not keyword:
         if not id:
             id = obj_group_list[0].id
             all_obj_group_data_list = list()
             for obj_group in obj_group_list:
                 data_dict = dict()
                 data_dict["id"] = obj_group.id
                 data_dict["obj_group_id"] = obj_group.obj_group_id
                 data_dict["obj_group_name"] = obj_group.obj_group_name
                 all_obj_group_data_list.append(data_dict)
             obj_group_dict = self.get_single_data(id, user_id)
             data = {
                 "all_data": all_obj_group_data_list,
                 "single_data": obj_group_dict
             }
             context = {"code": 0, "msg": "获取对象组页面成功", "data": data}
             return JsonResponse(context)
         else:
             obj_group_dict = self.get_single_data(id, user_id)
             data = {"single_data": obj_group_dict}
             context = {"code": 0, "msg": "获取对象组页面成功", "data": data}
             return JsonResponse(context)
     else:
         keyword = keyword.strip(" ")
         search_result = list()
         for object_group in obj_group_list:
             object_group_dict = dict()
             if (keyword.upper() in object_group.obj_group_id.upper()) or (
                     keyword.upper()
                     in object_group.obj_group_name.upper()):
                 object_group_dict["id"] = object_group.id
                 object_group_dict[
                     "obj_group_id"] = object_group.obj_group_id
                 object_group_dict[
                     "obj_group_name"] = object_group.obj_group_name
             if object_group.obj_group_name.upper() in keyword.upper():
                 object_group_dict["id"] = object_group.id
                 object_group_dict[
                     "obj_group_id"] = object_group.obj_group_id
                 object_group_dict[
                     "obj_group_name"] = object_group.obj_group_name
             if object_group_dict:
                 search_result.append(object_group_dict)
         if not search_result:
             data = {"all_data": search_result, "single_data": {}}
             context = {"code": 0, "msg": "搜索的内容不存在", "data": data}
             return JsonResponse(context)
         id = search_result[0]["id"]
         obj_group_dict = self.get_single_data(id, user_id)
         data = {"all_data": search_result, "single_data": obj_group_dict}
         context = {"code": 0, "msg": "搜索成功", "data": data}
         return JsonResponse(context)
Пример #24
0
 def put(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     user = User.objects.get(id=user_id)
     try:
         data_dict = json.loads(request.body.decode("utf-8"))
     except Exception as e:
         context = {"code": 1, "msg": "获取json数据失败"}
         return JsonResponse(context)
     try:
         id = data_dict["id"]
     except KeyError as e:
         context = {"code": 1, "msg": "id不能为空"}
         return JsonResponse(context)
     try:
         obj_group_id = data_dict["obj_group_id"]
     except KeyError as e:
         context = {"code": 1, "msg": "分析对象组标识不能为空"}
         return JsonResponse(context)
     try:
         obj_group_name = data_dict["obj_group_name"]
     except KeyError as e:
         context = {"code": 1, "msg": "分析对象组名称不能为空"}
         return JsonResponse(context)
     try:
         object_category = data_dict["object_category"]
     except KeyError as e:
         context = {"code": 1, "msg": "分析对象类型不能为空"}
         return JsonResponse(context)
     try:
         is_available = data_dict["is_available"]
     except KeyError as e:
         is_available = True
     try:
         template = data_dict["template"]
     except KeyError as e:
         template = self.template
     try:
         script = data_dict["script"]
     except KeyError as e:
         script = self.script
     try:
         remark = data_dict["remark"]
     except KeyError as e:
         remark = self.remark
     if not re.match(r"^[a-zA-Z0-9_]{4,16}", str(obj_group_id)):
         context = {"code": 1, "msg": "分析对象组标识必须为4-16位数字,字母或下划线"}
         return JsonResponse(context)
     try:
         objectgroup = ObjectGroup.objects.get(id=id,
                                               obj_group_user=user_id)
         objectgroup.obj_group_id = obj_group_id
         objectgroup.obj_group_name = obj_group_name
         objectgroup.object_category = object_category
         objectgroup.template = template
         objectgroup.script = script
         objectgroup.remark = remark
         objectgroup.is_available = is_available
         objectgroup.obj_group_user = user
         objectgroup.save()
     except Exception as e:
         context = {"code": 1, "msg": "数据库添加对象组失败"}
         return JsonResponse(context)
     context = {"code": 0, "msg": "修改对象组成功"}
     return JsonResponse(context)
Пример #25
0
 def post(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     user = User.objects.get(id=user_id)
     try:
         data_dict = json.loads(request.body.decode("utf-8"))
     except Exception as e:
         context = {"code": 1, "msg": "获取json数据失败"}
         return JsonResponse(context)
     try:
         account_id = data_dict["account_id"]
     except KeyError as e:
         context = {"code": 1, "msg": "账户标识不能为空"}
         return JsonResponse(context)
     try:
         account_name = data_dict["account_name"]
     except KeyError as e:
         context = {"code": 1, "msg": "账户名不能为空"}
         return JsonResponse(context)
     try:
         account_login = data_dict["account_login"]
     except KeyError as e:
         context = {"code": 1, "msg": "账户登录名不能为空"}
         return JsonResponse(context)
     try:
         account_pin = data_dict["account_pin"]
     except KeyError as e:
         context = {"code": 1, "msg": "账户登录密码不能为空"}
         return JsonResponse(context)
     try:
         template = data_dict["template"]
     except KeyError as e:
         template = self.template
     try:
         script = data_dict["script"]
     except KeyError as e:
         script = self.script
     try:
         remark = data_dict["remark"]
     except KeyError as e:
         remark = self.remark
     if not all([account_id, account_name, account_login, account_pin]):
         context = {"code": 1, "msg": "参数不完整"}
         return JsonResponse(context)
     try:
         tool = Account.objects.get(account_id=account_id)
     except Exception as e:
         tool = False
     if tool:
         context = {"code": 1, "msg": "account_id已存在,请重新输入"}
         return JsonResponse(context)
     if not re.match(r"^[a-zA-Z0-9_]{4,16}$", str(account_id)):
         context = {"code": 1, "msg": "账户标识为4-16位的字母,数字或下划线"}
         return JsonResponse(context)
     if not re.match(r'^[a-zA-Z0-9_]{4,16}$', str(account_login)):
         context = {"code": 1, "msg": "账户登录名为4-16位的字母,数字或下划线"}
         return JsonResponse(context)
     if not re.match(r'^[a-zA-Z0-9]{4,16}$', str(account_pin)):
         context = {"code": 1, "msg": "账户密码为6-16位的字母或数字"}
         return JsonResponse(context)
     try:
         account = Account()
         account.account_id = account_id
         account.account_name = account_name
         account.account_login = account_login
         account.account_pin = account_pin
         account.template = template
         account.script = script
         account.remark = remark
         account.account_user = user
         account.save()
     except Exception as e:
         context = {"code": 1, "msg": "数据库添加账户信息失败"}
         return JsonResponse(context)
     context = {"code": 0, "msg": "添加账户成功"}
     return JsonResponse(context)
Пример #26
0
 def get(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     data_source_list = DataSource.objects.filter(
         source_user=user_id).order_by("id")
     if not data_source_list:
         context = {
             "code": 0,
             "msg": "还未有数据源注册",
             "data": {
                 "all_data": [],
                 "single_data": {}
             }
         }
         return JsonResponse(context)
     id = request.GET.get("id")
     keyword = request.GET.get("keyword")
     if not keyword:
         if not id:
             id = data_source_list[0].id
             all_data_source_list = list()
             for source in data_source_list:
                 data_dict = dict()
                 data_dict["id"] = source.id
                 data_dict["source_id"] = source.source_id
                 data_dict["source_name"] = source.source_name
                 all_data_source_list.append(data_dict)
             source_dict = self.get_single_data(id, user_id)
             data = {
                 "all_data": all_data_source_list,
                 "single_data": source_dict
             }
             context = {"code": 0, "msg": "获取数据源页面成功", "data": data}
             return JsonResponse(context)
         else:
             source_dict = self.get_single_data(id, user_id)
             data = {"single_data": source_dict}
             context = {"code": 0, "msg": "获取数据源页面成功", "data": data}
             return JsonResponse(context)
     else:
         keyword = keyword.strip(" ")
         search_result = list()
         for source in data_source_list:
             source_dict = dict()
             if (keyword.upper() in source.source_id.upper()) or (
                     keyword.upper() in source.source_name.upper()):
                 source_dict["id"] = source.id
                 source_dict["source_id"] = source.source_id
                 source_dict["source_name"] = source.source_name
             if source.source_name.upper() in keyword.upper():
                 source_dict["id"] = source.id
                 source_dict["source_id"] = source.source_id
                 source_dict["source_name"] = source.source_name
             if source_dict:
                 search_result.append(source_dict)
         if not search_result:
             data = {"all_data": search_result, "single_data": {}}
             context = {"code": 0, "msg": "搜索的内容不存在", "data": data}
             return JsonResponse(context)
         id = search_result[0]["id"]
         source_dict = self.get_single_data(id, user_id)
         data = {"all_data": search_result, "single_data": source_dict}
         context = {"code": 0, "msg": "搜索成功", "data": data}
         return JsonResponse(context)
Пример #27
0
 def get(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     analysis_list = AnalysisParameter.objects.filter(
         analysis_user=user_id).order_by("id")
     if not analysis_list:
         context = {
             "code": 0,
             "msg": "未有分析参数创建",
             "data": {
                 "all_data": [],
                 "single_data": {}
             }
         }
         return JsonResponse(context)
     id = request.GET.get("id")
     keyword = request.GET.get("keyword")
     if not keyword:
         if not id:
             id = analysis_list[0].id
             all_analysis_data_list = list()
             for analysis in analysis_list:
                 data_dict = dict()
                 data_dict["id"] = analysis.id
                 data_dict["ana_para_id"] = analysis.ana_para_id
                 data_dict["ana_para_name"] = analysis.ana_para_name
                 all_analysis_data_list.append(data_dict)
             analysis_dict = self.get_single_data(id, user_id)
             data = {
                 "all_data": all_analysis_data_list,
                 "single_data": analysis_dict
             }
             context = {"code": 0, "msg": "获取分析参数页面成功", "data": data}
             return JsonResponse(context)
         else:
             analysis_dict = self.get_single_data(id, user_id)
             data = {"single_data": analysis_dict}
             context = {"code": 0, "msg": "获取分析参数页面成功", "data": data}
             return JsonResponse(context)
     else:
         keyword = keyword.strip(" ")
         search_result = list()
         for analysis in analysis_list:
             analysis_dict = dict()
             if (keyword.upper() in analysis.ana_para_id.upper()) or (
                     keyword.upper() in analysis.ana_para_name.upper()):
                 analysis_dict["id"] = analysis.id
                 analysis_dict["ana_para_id"] = analysis.ana_para_id
                 analysis_dict["ana_para_name"] = analysis.ana_para_name
             if analysis.ana_para_name.upper() in keyword.upper():
                 analysis_dict["id"] = analysis.id
                 analysis_dict["ana_para_id"] = analysis.ana_para_id
                 analysis_dict["ana_para_name"] = analysis.ana_para_name
             if analysis_dict:
                 search_result.append(analysis_dict)
         if not search_result:
             data = {"all_data": search_result, "single_data": {}}
             context = {"code": 0, "msg": "搜索的内容不存在", "data": data}
             return JsonResponse(context)
         id = search_result[0]["id"]
         analysis_dict = self.get_single_data(id, user_id)
         data = {"all_data": search_result, "single_data": analysis_dict}
         context = {"code": 0, "msg": "搜索成功", "data": data}
         return JsonResponse(context)
Пример #28
0
 def put(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     user = User.objects.get(id=user_id)
     try:
         data_dict = json.loads(request.body.decode("utf-8"))
     except Exception as e:
         context = {"code": 1, "msg": "获取json数据失败"}
         return JsonResponse(context)
     try:
         id = data_dict["id"]
     except KeyError as e:
         context = {"code": 1, "msg": "id不能为空"}
         return JsonResponse(context)
     try:
         opt_para_id = data_dict["opt_para_id"]
     except KeyError as e:
         context = {"code": 1, "msg": "优化参数标识不能为空"}
         return JsonResponse(context)
     try:
         opt_para_name = data_dict["opt_para_name"]
     except KeyError as e:
         context = {"code": 1, "msg": "优化参数名不能为空"}
         return JsonResponse(context)
     try:
         script = data_dict["script"]
         if not script:
             context = {"code": 1, "msg": "script不能为空"}
             return JsonResponse(context)
     except KeyError:
         context = {"code": 1, "msg": "script不能为空"}
         return JsonResponse(context)
     try:
         is_available = data_dict["is_available"]
     except KeyError as e:
         is_available = True
     try:
         template = data_dict["template"]
     except KeyError as e:
         template = self.template
     try:
         opt_object_id = Object.objects.get(
             object_id=data_dict["object_id"])
     except Exception:
         context = {"code": 1, "msg": "分析对象ID不能为空"}
         return JsonResponse(context)
     try:
         remark = data_dict["remark"]
     except KeyError as e:
         remark = self.remark
     if not all([id, opt_para_id, opt_para_name, script]):
         context = {"code": 1, "msg": "参数不完整"}
         return JsonResponse(context)
     if not re.match(r"^[a-zA-Z0-9_]{4,16}$", str(opt_para_id)):
         context = {"code": 1, "msg": "优化参数标识为4-16位的字母,数字或下划线"}
         return JsonResponse(context)
     try:
         ast.literal_eval(script)
     except Exception as e:
         context = {"code": 1, "msg": "优化参数脚本格式错误"}
         return JsonResponse(context)
     try:
         optimization_parameter = OptimizationParameter.objects.get(id=id)
         optimization_parameter.opt_para_id = opt_para_id
         optimization_parameter.opt_para_name = opt_para_name
         optimization_parameter.script = script
         optimization_parameter.object_id = opt_object_id
         optimization_parameter.template = template
         optimization_parameter.is_available = is_available
         optimization_parameter.remark = remark
         optimization_parameter.optimization_user = user
         optimization_parameter.save()
     except Exception as e:
         context = {"code": 1, "msg": "修改优化参数信息失败"}
         return JsonResponse(context)
     context = {"code": 0, "msg": "修改优化参数信息成功"}
     return JsonResponse(context)
Пример #29
0
 def put(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     user = User.objects.get(id=user_id)
     try:
         data_dict = json.loads(request.body.decode("utf-8"))
     except Exception as e:
         context = {"code": 1, "msg": "获取json数据失败"}
         return JsonResponse(context)
     try:
         id = data_dict["id"]
     except KeyError as e:
         context = {"code": 1, "msg": "id不能为空"}
         return JsonResponse(context)
     try:
         pipe_id = data_dict["pipe_id"]
     except KeyError as e:
         context = {"code": 1, "msg": "数据源标识不能为空"}
         return JsonResponse(context)
     try:
         pipe_name = data_dict["pipe_name"]
     except KeyError as e:
         context = {"code": 1, "msg": "数据源名称不能为空"}
         return JsonResponse(context)
     try:
         is_available = data_dict["is_available"]
     except KeyError as e:
         is_available = True
     try:
         template = data_dict["template"]
     except KeyError as e:
         template = self.template
     try:
         script = data_dict["script"]
     except KeyError as e:
         script = self.script
     try:
         remark = data_dict["remark"]
     except KeyError as e:
         remark = self.remark
     if not all([id, pipe_id, pipe_name]):
         context = {"code": 1, "msg": "参数不完整"}
         return JsonResponse(context)
     if not re.match(r"^[a-zA-Z0-9_]{4,16}$", str(pipe_id)):
         context = {"code": 1, "msg": "数据管道标识为4-16位的字母,数字或下划线"}
         return JsonResponse(context)
     try:
         datapipe = DataPipe.objects.get(id=id, pipe_user=user_id)
         datapipe.pipe_id = pipe_id
         datapipe.pipe_name = pipe_name
         datapipe.template = template
         datapipe.script = script
         datapipe.remark = remark
         datapipe.is_available = is_available
         datapipe.pipe_user = user
         datapipe.save()
     except Exception as e:
         context = {"code": 1, "msg": "修改数据管道失败"}
         return JsonResponse(context)
     context = {"code": 0, "msg": "修改数据管道成功"}
     return JsonResponse(context)
Пример #30
0
 def get(self, request):
     context = LoginRequiredMixin.login_required(request)
     if context["code"] != 0:
         return JsonResponse(context)
     user_id = context["user_id"]
     optimization_list = OptimizationParameter.objects.filter(
         optimization_user=user_id).order_by("id")
     if not optimization_list:
         context = {
             "code": 0,
             "msg": "还未有优化参数创建",
             "data": {
                 "all_data": [],
                 "single_data": {}
             }
         }
         return JsonResponse(context)
     id = request.GET.get("id")
     keyword = request.GET.get("keyword")
     if not keyword:
         if not id:
             id = optimization_list[0].id
             all_optimization_data_list = list()
             for optimization in optimization_list:
                 data_dict = dict()
                 data_dict["id"] = optimization.id
                 data_dict["opt_para_id"] = optimization.opt_para_id
                 data_dict["opt_para_name"] = optimization.opt_para_name
                 all_optimization_data_list.append(data_dict)
             optimization_dict = self.get_single_data(id, user_id)
             data = {
                 "all_data": all_optimization_data_list,
                 "single_data": optimization_dict
             }
             context = {"code": 0, "msg": "获取优化参数页面成功", "data": data}
             return JsonResponse(context)
         else:
             try:
                 optimization_dict = self.get_single_data(id, user_id)
             except Exception as e:
                 context = {"code": 1, "msg": "获取数据失败,请确认分析对象成功填写"}
                 return JsonResponse(context)
             data = {"single_data": optimization_dict}
             context = {"code": 0, "msg": "获取优化参数页面成功", "data": data}
             return JsonResponse(context)
     else:
         keyword = keyword.strip(" ")
         search_result = list()
         for optimization in optimization_list:
             optimization_dict = dict()
             if (keyword.upper() in optimization.opt_para_id.upper()) or (
                     keyword.upper() in optimization.opt_para_name.upper()):
                 optimization_dict["id"] = optimization.id
                 optimization_dict["opt_para_id"] = optimization.opt_para_id
                 optimization_dict[
                     "opt_para_name"] = optimization.opt_para_name
             if optimization.opt_para_name.upper() in keyword.upper():
                 optimization_dict["id"] = optimization.id
                 optimization_dict["opt_para_id"] = optimization.opt_para_id
                 optimization_dict[
                     "opt_para_name"] = optimization.opt_para_name
             if optimization_dict:
                 search_result.append(optimization_dict)
         if not search_result:
             data = {"all_data": search_result, "single_data": {}}
             context = {"code": 0, "msg": "搜索的内容不存在", "data": data}
             return JsonResponse(context)
         id = search_result[0]["id"]
         try:
             optimization_dict = self.get_single_data(id, user_id)
         except Exception as e:
             context = {"code": 1, "msg": "获取数据失败,请确认分析对象成功填写"}
             return JsonResponse(context)
         data = {
             "all_data": search_result,
             "single_data": optimization_dict
         }
         context = {"code": 0, "msg": "搜索成功", "data": data}
         return JsonResponse(context)