def loadSelectCategoriaTipo(request): mydict = QueryDict.dict(request.POST) aux = CategoriaXIndicador.objects.all().distinct("categoria") indicadores = [] data = "" for i in aux: aux_categoria = CategoriaIndicador.objects.get(pk=i.categoria_id) if mydict["tipo"] == "Todos": data = Indicador.objects.all().values_list() n = 0 array = [] for i in data: unidad = UnidadMedida.objects.get(pk=i[4]) aux = {"id": i[0], "nombre": i[1], "numerador": i[2], "denominador": i[3], "unidad": unidad.nombre} array.append(aux) # pdb.set_trace() data = json.dumps(array) elif mydict["tipo"] == aux_categoria.nombre: aux_indicadores = CategoriaXIndicador.objects.all().filter(categoria=aux_categoria.id) for j in aux_indicadores: aux_indicador = Indicador.objects.get(pk=j.indicador_id) aux_unidad = UnidadMedida.objects.get(pk=aux_indicador.unidad_id) aux1 = { "id": aux_indicador.id, "nombre": aux_indicador.nombre, "numerador": aux_indicador.numerador, "denominador": aux_indicador.denominador, "unidad": aux_unidad.nombre, } indicadores.append(aux1) data = json.dumps(indicadores) break return HttpResponse(data, content_type="application/json")
def edit_perspectiva(request): """ """ if request.is_ajax() and request.POST: mydict=QueryDict.dict(request.POST) if mydict['oper'] == 'edit': form=PerspectivaForm({'nombre':mydict['fields.nombre'], 'descripcion':mydict['fields.descripcion'], 'color':mydict['fields.color'], 'icono':mydict['fields.icono']}) if form.is_valid(): aux_obj=Perspectiva.objects.get(id=request.POST['pk']) aux_obj.nombre=mydict['fields.nombre'] aux_obj.descripcion=mydict['fields.descripcion'] aux_obj.color=mydict['fields.color'] aux_obj.icono=mydict['fields.icono'] aux_obj.save() data={'message':'Correcto'} else: data={'message':'Error'} elif mydict['oper'] == 'del': aux_obj=Perspectiva.objects.get(id=mydict['id']) aux_obj.delete() data={'message':'Correcto'} elif mydict['oper'] == 'add': form=PerspectivaForm({'nombre':mydict['fields.nombre'], 'descripcion':mydict['fields.descripcion'], 'color':mydict['fields.color'], 'icono':mydict['fields.icono']}) if form.is_valid(): form.save() data={'message':'Correcto'} else: data={'message':'Error'} return HttpResponse(json.dumps(data),content_type='application/json') else: raise Http404
def load_select_categoria_tipo(request): """ """ mydict = QueryDict.dict(request.POST) aux = CategoriaXIndicador.objects.all().distinct('categoria') indicadores = [] data="" for i in aux: aux_categoria = CategoriaIndicador.objects.get(pk=i.categoria_id) if mydict['tipo'] == "Todos": data= Indicador.objects.all().values_list() n=0 array=[] for i in data: unidad=UnidadMedida.objects.get(pk=i[4]) aux={'id':i[0], 'nombre':i[1], 'numerador':i[2], 'denominador':i[3], 'unidad':unidad.nombre} array.append(aux) data=json.dumps(array) elif mydict['tipo']==aux_categoria.nombre: aux_indicadores=CategoriaXIndicador.objects.all().filter(categoria=aux_categoria.id) for j in aux_indicadores: aux_indicador=Indicador.objects.get(pk=j.indicador_id) aux_unidad=UnidadMedida.objects.get(pk=aux_indicador.unidad_id) aux1={'id':aux_indicador.id, 'nombre':aux_indicador.nombre, 'numerador':aux_indicador.numerador, 'denominador':aux_indicador.denominador, 'unidad':aux_unidad.nombre} indicadores.append(aux1) data=json.dumps(indicadores) break return HttpResponse(data, content_type='application/json')
def get_data(request, report, fmt, conf=""): DataProvider.fmt = fmt Logger.Message("Executing: " + conf) qd = QueryDict(conf) conf = qd.dict() if('async' in conf): url = log_async(report, fmt, conf) return HttpResponse("Request logged. Please donwload from: " + url) r = Reports() data = r.GetData(report, fmt, conf) if not data: return HttpResponse("Report does not exist") download = False if('gzip' in conf): fn = report + "." + fmt + ".gz" data = compress_string(data) c_type, download = get_mime_type('gzip') else: fn = report + "." + fmt c_type, download = get_mime_type(fmt) response = HttpResponse(data, content_type=c_type) if(download): response['Content-Disposition'] = 'attachment; filename="' + fn + '"' return response
def test_keep_existing(self): url = urlutils.update_querystring('http://example.com?next=/test', {'other': 'otherstuff'}) url_split = urlsplit(url) querydict = QueryDict(url_split.query) self.assertEqual(querydict.dict(), { 'next': '/test', 'other': 'otherstuff', })
def posted_data_dict(self): """ All the data that PayPal posted to us, as a correctly parsed dictionary of values. """ if not self.query: return None from django.http import QueryDict roughdecode = dict(item.split('=', 1) for item in self.query.split('&')) encoding = roughdecode.get('charset', None) if encoding is None: encoding = DEFAULT_ENCODING query = self.query.encode('ascii') data = QueryDict(query, encoding=encoding) return data.dict()
def login_with_facebook_auth(self, request): """ Check if the token is fresh, if not re-acquire it. Then get access token and enter user into model with ConnectedAccount """ if request.session.get(SESSION_STATE_KEY) != request.GET.get('state'): return HttpResponseRedirect(reverse('web_login')+("?error=There was a problem authenticating you. Please connect with Facebook or Twitter to vote.")) site = get_current_site(request) redirect_uri = "http://%s%s" % (site, reverse("web_login_facebook")) facebook_code_response = QueryDict.dict(request.GET).get('code') access_token_params = { 'client_id' : FACEBOOK_APPLICATION_ID, 'redirect_uri' : redirect_uri, 'client_secret' : FACEBOOK_APPLICATION_SECRET, 'code' : facebook_code_response, } # Get Access from facebook to reach user data facebook_access_token_resource = FACEBOOK_ACCESS_RESOURCE + '?' + urlencode(access_token_params) user_access_token = requests.get(facebook_access_token_resource) # create a dictionary of user info response_dict = {} if user_access_token.status_code == 200: response_list = user_access_token.content.split('&') # decoded_response_url = urlparse.parse_qs(twitter_user_access_info.content) # The above line is also usable, it creates the same thing that the below 2 lines do. Maybe faster for item in response_list: key = item.split('=')[0] value = item.split('=')[1] response_dict[key] = value elif user_access_token.status_code == 400: # If the token has expired then the user will be prompted to authorize again and # therefore forcing a new token to be created. return self.login_via_facebook(request) facebook_user_info=requests.get(FACEBOOK_USER_INFO_RESOURCE + '?' + user_access_token.content) name = facebook_user_info.json().get('name').split() user_defaults = {'name': name } try: user = ConnectedAccount.objects.get(identifier=facebook_user_info.json()['id']) except: user = None if user is None: # Ask facebook for user data to create a new user user, user_is_created = ConnectedAccount.objects.get_or_create(identifier=facebook_user_info.json()['id'], defaults=user_defaults) request.session['user_id'] = user.id return HttpResponseRedirect(reverse("home"))
def editPerspectiva(request): if request.is_ajax() and request.POST: mydict = QueryDict.dict(request.POST) if mydict["oper"] == "edit": form = PerspectivaForm( { "nombre": mydict["fields.nombre"], "descripcion": mydict["fields.descripcion"], "color": mydict["fields.color"], "icono": mydict["fields.icono"], } ) if form.is_valid(): aux_obj = Perspectiva.objects.get(id=request.POST["pk"]) aux_obj.nombre = mydict["fields.nombre"] aux_obj.descripcion = mydict["fields.descripcion"] aux_obj.color = mydict["fields.color"] aux_obj.icono = mydict["fields.icono"] aux_obj.save() data = {"message": "Correcto"} else: data = {"message": "Error"} elif mydict["oper"] == "del": aux_obj = Perspectiva.objects.get(id=mydict["id"]) aux_obj.delete() data = {"message": "Correcto"} elif mydict["oper"] == "add": form = PerspectivaForm( { "nombre": mydict["fields.nombre"], "descripcion": mydict["fields.descripcion"], "color": mydict["fields.color"], "icono": mydict["fields.icono"], } ) if form.is_valid(): form.save() data = {"message": "Correcto"} else: data = {"message": "Error"} return HttpResponse(json.dumps(data), content_type="application/json") else: raise Http404
def edit_indicador(request): """ """ if request.is_ajax() and request.POST: mydict=QueryDict.dict(request.POST) if mydict['oper'] == 'add': #categoria=CategoriaIndicador.objects.get(nombre=mydict['fields.categoria']) unidad=UnidadMedida.objects.get(abreviatura=mydict['fields.unidad']) form=IndicadorForm({'nombre':mydict['fields.nombre'], 'numerador':mydict['fields.numerador'], 'denominador':mydict['fields.denominador'], 'unidad':unidad.id}) print form.errors if form.is_valid(): form.save() data={'message':'Correcto'} else: data={'message':'Error'} return HttpResponse(json.dumps(data),content_type='application/json') else: raise Http404
def login(self, request, *args, **kwargs): data = QueryDict.dict(request.data) username = data['username'] password = data['password'] user = authenticate(username=username, password=password) if user is not None: if user.is_active: login(request, user) data = { 'code': 200, 'msg': '登录成功', 'user_id': user.id, 'username': user.username } else: data = {'code': 201, 'msg': '用户未激活'} else: data = {'code': 202, 'msg': '用户名或密码错误'} res = {'data': data} return Response(res)
def parse(self, stream, media_type=None, parser_context=None): result = super().parse(stream=stream, media_type=media_type, parser_context=parser_context) print(result.files) data = {} for key, value in result.data.items(): if '[' in key and ']' in key: # print(key, ' and ', value) keys = self.get_nested_keys(key) if len(keys) == 3: nested_dict_key1 = keys[0] nested_dict_key2 = keys[1] nested_dict_key3 = keys[2] if nested_dict_key2.isdigit(): # array of data index = int(nested_dict_key2) if nested_dict_key1 not in data: data[nested_dict_key1] = [] data[nested_dict_key1].append( {nested_dict_key3: value}) elif index < len(data[nested_dict_key1]): data[nested_dict_key1][index].update( {nested_dict_key3: value}) else: data[nested_dict_key1].append( {nested_dict_key3: value}) # TODO len(keys) == 2: else: data[key] = value # print(data) """ If pass only data, file field returned error as "no file was submitted" If QueryDict.dict() used, it works """ # TODO investigate for this issue q_dict = QueryDict('', mutable=True) q_dict.update(data) # print('==================+++++==============*****+========================') # print(q_dict) return parsers.DataAndFiles(q_dict.dict(), result.files)
def render(self, context, instance, placeholder): if not context['auth_flag']: return context config = ExeInfo.objects.get(cmsplugin_ptr_id=instance) argpost = QueryDict.dict(context['request'].POST) project_name = context['request'].session['project'] project = Project.objects.get(name=project_name) context['path'] = config.path context['title'] = config.title context['size'] = config.size context['exe_all'] = Environment.objects.filter( project_id=project.id).order_by('-id') context['itec_list'] = iTEC.objects.filter(project_id=project.id) context['type_list'] = EnvironmentType.objects.filter( project_id=project.id) method = argpost.get('execution_method', None) parameters = argpost.get('execution_para', None) if method and parameters: context = self._operate(method, parameters, project, context) elif argpost: # upload patch self._upload_patch(context['request'], config.path, context) # paging processing exe_list, page_range, entry_num = paginator(argpost, context['exe_all']) exe_config_list = [{ 'exe': exe, 'config': exe.configuration_set.all()[0] } for exe in exe_list] context['exe_count'] = len(context['exe_all']) context['exe_config_list'] = exe_config_list context['exe_list'] = exe_list context['page_range'] = page_range context['entry_num'] = entry_num context['proj_name'] = project_name return context
def edit_perspectiva(request): """ """ if request.is_ajax() and request.POST: mydict = QueryDict.dict(request.POST) if mydict['oper'] == 'edit': form = PerspectivaForm({ 'nombre': mydict['fields.nombre'], 'descripcion': mydict['fields.descripcion'], 'color': mydict['fields.color'], 'icono': mydict['fields.icono'] }) if form.is_valid(): aux_obj = Perspectiva.objects.get(id=request.POST['pk']) aux_obj.nombre = mydict['fields.nombre'] aux_obj.descripcion = mydict['fields.descripcion'] aux_obj.color = mydict['fields.color'] aux_obj.icono = mydict['fields.icono'] aux_obj.save() data = {'message': 'Correcto'} else: data = {'message': 'Error'} elif mydict['oper'] == 'del': aux_obj = Perspectiva.objects.get(id=mydict['id']) aux_obj.delete() data = {'message': 'Correcto'} elif mydict['oper'] == 'add': form = PerspectivaForm({ 'nombre': mydict['fields.nombre'], 'descripcion': mydict['fields.descripcion'], 'color': mydict['fields.color'], 'icono': mydict['fields.icono'] }) if form.is_valid(): form.save() data = {'message': 'Correcto'} else: data = {'message': 'Error'} return HttpResponse(json.dumps(data), content_type='application/json') else: raise Http404
def prepare_facet_data( self, aggregations: AggResponse, get_args: QueryDict) -> dict[str, list[dict[str, str]]]: resp: DataDict = {} for area, agg in aggregations.to_dict().items(): resp[area] = [] if 'value' in agg: # if the aggregation has the value key, it comes from the metrics. resp[area] = agg['value'] continue for item in aggregations[area].buckets: url_args, is_active = self.facet_url_args( url_args=deepcopy(get_args.dict()), field_name=area, field_value=str(item.key)) resp[area].append({ 'url_args': urlencode(url_args), 'name': item.key, 'count': item.doc_count, 'is_active': is_active }) return resp
def login(request): if request.method=='GET': return render(request, 'login.html') if request.method == 'POST': req = request.POST mydict = QueryDict.dict(req) access=AdminLogin.admin_auth(AdminLogin(),mydict) if access: context={ 'token':mydict.get('csrfmiddlewaretoken'), 'username':mydict.get('email'), 'email':mydict.get('email') } response= HttpResponseRedirect("/admin") response.set_cookie('auth_cookie',value=context,path='/') return response else: context={ "error":"Login Failed, Try Again" } return render(request,'login.html',context)
def signup(request): user_obj = UsersDetails.objects.filter(email=request.data["email"]) if len(user_obj) == 0: data = QueryDict.dict(request.data) data["username"] = request.data["email"] data["password"] = make_password(data["password"]) serializer = UsersDetailsSerializers(data=data) if serializer.is_valid(): serializer.save() user = UsersDetails.objects.get(id=serializer.data["id"]) serializer = UsersGetSerializers(user) payload = jwt_payload_handler(user) context = { 'token': jwt_encode_handler(payload), 'user': serializer.data, 'status': 200 } return Response(context) return Response(serializer.errors, status=400) else: return Response({"message": "User already exists"}, 400)
def render(self, context, instance, placeholder): argpost = QueryDict.dict(context['request'].POST) user_login_status = False my_project_list = None message = "" if 'user' in argpost and 'password' in argpost: user = authenticate(username=argpost.get('user'), password=argpost.get('password')) if user is not None: if user.is_active: group_list = user.groups.values_list('name', flat=True) print group_list project_list = Project.objects.all() my_project_list = self._get_myproject_list(group_list, project_list) print '=' * 40 print my_project_list print '=' * 40 user_login_status = True context['username'] = argpost.get('user') if my_project_list: login(context['request'], user) else: message = 'please access eam.intel.com to get related permissions.' else: message = 'The password is valid, but the account has been disabled!~' else: message = 'The username and password were incorrect.' if 'project' in argpost: context['request'].session['project'] = argpost.get('project') context['user_login_status'] = user_login_status context['user_login_status'] = True context['message'] = message context['project_list'] = my_project_list return context
def sign_up_form(request): # sent = False if request.method == 'POST': try: form = UserRegistrationForm(request.POST) if form.is_valid: form.save() username = QueryDict.dict(form.data).get('username') user = User.objects.filter(username=f'{username}').first() Profile.objects.create(user=user) messages.success( request, f'Your Account has been created!, You now login to access the page' ) return redirect('login') except Exception as e: print(e) else: form = UserRegistrationForm() return render(request, 'blog/signup.html', {'form': form})
def post(self, request, *args, **kwargs): data_dict = request.data mutable_query_dict = QueryDict(mutable=True) mutable_query_dict.update(data_dict) mutable_query_dict.__setitem__('user_id', request.user.id) if u.AccessRequest.objects.filter(user_id=request.user.id): return Response('A user can only make one access request', status=status.HTTP_422_UNPROCESSABLE_ENTITY) if 'organization_email' in data_dict and u.CustomUser.objects.filter( email=data_dict['organization_email'].lower()): return Response('This email is already taken', status=status.HTTP_422_UNPROCESSABLE_ENTITY) serializer = self.get_serializer(data=mutable_query_dict) serializer.is_valid(raise_exception=True) serializer.create(validated_data=mutable_query_dict.dict()) headers = self.get_success_headers(serializer.data) return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
def get(self, request): numPage = request.GET['numPage'] bookId = request.GET['bookId'] isOrder = request.GET['isOrder'] chapters = "" if "true" == isOrder: chapters = BooksContent.objects.filter(BookInfo__id=bookId).all() elif "false == isOrder": chapters = BooksContent.objects.filter( BookInfo__id=bookId).order_by('-chaptersId').all() book = BookInfo.objects.get(id=bookId) # chapters = BooksContent.objects.filter(BookInfo__id=bookId).all() paginator = Paginator(chapters, 5) serializers = ChaptersSerializers(paginator.page(numPage).object_list, many=True) content = QueryDict(mutable=True) content['bookName'] = book.bookName content['chaptersList'] = serializers.data content['pageNumber'] = paginator.num_pages return HttpResponse(json.dumps(content.dict()))
def editarUnidad(request): if request.is_ajax() and request.POST: mydict = QueryDict.dict(request.POST) if mydict["oper"] == "add": form = UnidadMedidaForm({"nombre": mydict["fields.nombre"], "abreviatura": mydict["fields.abreviatura"]}) if form.is_valid(): unidades = UnidadMedida.objects.all() mensaje = "crear" form.save() data = {"message": mensaje} else: data = {"message": "Error"} elif mydict["oper"] == "del": mensaje = "eliminar" aux_obj = UnidadMedida.objects.get(id=mydict["selrow"]) aux_obj.delete() data = {"message": mensaje} else: data = {"message": "Error"} return HttpResponse(json.dumps(data), content_type="application/json") else: raise Http404
def editar_unidad(request): if request.is_ajax() and request.POST: mydict=QueryDict.dict(request.POST) if mydict['oper'] == 'add': form = UnidadMedidaForm({'nombre':mydict['fields.nombre'], 'abreviatura':mydict['fields.abreviatura']}) if form.is_valid(): unidades=UnidadMedida.objects.all() mensaje='crear' form.save() data={'message':mensaje} else: data={'message':'Error'} elif mydict['oper'] == 'del': mensaje="eliminar" aux_obj=UnidadMedida.objects.get(id=mydict['selrow']) aux_obj.delete() data={'message':mensaje} else: data={'message':'Error'} return HttpResponse(json.dumps(data),content_type='application/json') else: raise Http404
def distancia(request): if request.is_ajax(): #dic= json.loads(request.body) q = QueryDict(request.body) dic= q.dict() x0= float(dic['puntos[0][x]']) y0= float(dic['puntos[0][y]']) x1= float(dic['puntos[1][x]']) y1= float(dic['puntos[1][y]']) pnt1= Point(x0,y0,srid=900913) pnt1.transform(4326) pnt2= Point(x1,y1,srid=900913) pnt2.transform(4326) print pnt1 print pnt2 calculo= pnt1.distance(pnt2) print calculo*100 lon1,lat1=pnt1.coords lon2,lat2=pnt2.coords geod = pyproj.Geod(ellps="WGS84") angle1,angle2,distance = geod.inv(lon1, lat1, lon2, lat2) print "Distance is %0.2f meters" % distance return HttpResponse(calculo, mimetype='application/json')
def distancia(request): if request.is_ajax(): #dic= json.loads(request.body) q = QueryDict(request.body) dic = q.dict() x0 = float(dic['puntos[0][x]']) y0 = float(dic['puntos[0][y]']) x1 = float(dic['puntos[1][x]']) y1 = float(dic['puntos[1][y]']) pnt1 = Point(x0, y0, srid=900913) pnt1.transform(4326) pnt2 = Point(x1, y1, srid=900913) pnt2.transform(4326) print pnt1 print pnt2 calculo = pnt1.distance(pnt2) print calculo * 100 lon1, lat1 = pnt1.coords lon2, lat2 = pnt2.coords geod = pyproj.Geod(ellps="WGS84") angle1, angle2, distance = geod.inv(lon1, lat1, lon2, lat2) print "Distance is %0.2f meters" % distance return HttpResponse(calculo, mimetype='application/json')
def insert_obj(request): dict_type = {"Film": {"constructor": Film(), "type": Film}, "Picture": {"constructor": Picture(), "type": Picture}, "Document": {"constructor": Simple_Document(), "type": Simple_Document}, "Text": {"constructor": Text(), "type": Text}, "Audio": {"constructor": Audio(), "type": Audio}} query_dict = QueryDict(request.body.decode("utf-8"), mutable=True) TYPE = query_dict.get("Type") if TYPE: for it in dict_type.get(TYPE)["constructor"].__getstate__().get("_fields_ordered"): if not query_dict.get(it) and it != "ID" and it != "_cls": return render(request, "blog/error.html", {"error": it + " is empty or null"}, status=400) query_dict["ID"] = index_found() try: dict_type.get(TYPE)["type"].objects.create(**query_dict.dict()) except: return render(request, "blog/error.html", {"error": "Wrong attribute"}, status=400) else: return render(request, "blog/error.html", {"error": "Type not found"}, status=400) return render(request, 'blog/index.html', {})
def editIndicador(request): if request.is_ajax() and request.POST: mydict = QueryDict.dict(request.POST) if mydict["oper"] == "add": # categoria=CategoriaIndicador.objects.get(nombre=mydict['fields.categoria']) unidad = UnidadMedida.objects.get(abreviatura=mydict["fields.unidad"]) form = IndicadorForm( { "nombre": mydict["fields.nombre"], "numerador": mydict["fields.numerador"], "denominador": mydict["fields.denominador"], "unidad": unidad.id, } ) print form.errors if form.is_valid(): form.save() data = {"message": "Correcto"} else: data = {"message": "Error"} return HttpResponse(json.dumps(data), content_type="application/json") else: raise Http404
def _put(self, request, bill_type: int): PUT = QueryDict(request.body) put_data = PUT.dict() need_field = ('bill_id', 'field_name', 'new_value') # 检查request中是否包含所需要的字段 for field in need_field: if field not in put_data: return JsonResponse(response_detail(400, detail="参数缺失")) # 检查每一个参数的正确性 bill = UserBills.objects.filter(id=int(put_data['bill_id']), type=bill_type, user=request.user).first() if not bill: return JsonResponse(response_detail(400, detail="账单不存在")) if not getattr(UserBills, put_data['field_name'], None): return JsonResponse( response_detail(400, detail="参数错误(field_name is not find)")) try: setattr(bill, put_data['field_name'], put_data['new_value']) bill.save() data = self._get_info(request, bill_type) return JsonResponse(response_detail(200, data=data)) except Exception: return JsonResponse(response_detail(500, detail="修改失败"))
def get(self, request): books = BookInfo.objects.all()[:3] showImgSerializers = ShowImgSerializers(books, many=True) showImg = QueryDict(mutable=True) showImg['showImg'] = showImgSerializers.data return HttpResponse(json.dumps(showImg.dict()))
def validate_out_parameters(cls, qs: QueryDict, *, outsalt: str) -> bool: """Check if the URL parameters have been tampered. """ parameters = qs.dict() shasign = parameters.pop("SHASIGN", None) string_to_hash = "" sha_out_params = { # https://shared.ecom-psp.com/v2/docs/guides/e-Commerce/SHA-OUT_params.txt "AAVADDRESS", "AAVCHECK", "AAVMAIL", "AAVNAME", "AAVPHONE", "AAVZIP", "ACCEPTANCE", "ALIAS", "AMOUNT", "BIC", "BIN", "BRAND", "CARDNO", "CCCTY", "CN", "COLLECTOR_BIC", "COLLECTOR_IBAN", "COMPLUS", "CREATION_STATUS", "CREDITDEBIT", "CURRENCY", "CVCCHECK", "DCC_COMMPERCENTAGE", "DCC_CONVAMOUNT", "DCC_CONVCCY", "DCC_EXCHRATE", "DCC_EXCHRATESOURCE", "DCC_EXCHRATETS", "DCC_INDICATOR", "DCC_MARGINPERCENTAGE", "DCC_VALIDHOURS", "DEVICEID", "DIGESTCARDNO", "ECI", "ED", "EMAIL", "ENCCARDNO", "FXAMOUNT", "FXCURRENCY", "IP", "IPCTY", "MANDATEID", "MOBILEMODE", "NBREMAILUSAGE", "NBRIPUSAGE", "NBRIPUSAGE_ALLTX", "NBRUSAGE", "NCERROR", "ORDERID", "PAYID", "PAYIDSUB", "PAYMENT_REFERENCE", "PM", "SCO_CATEGORY", "SCORING", "SEQUENCETYPE", "SIGNDATE", "STATUS", "SUBBRAND", "SUBSCRIPTION_ID", "TICKET", "TRXDATE", "VC" } for key in sorted(parameters): ku = key.upper() if ku in sha_out_params and parameters[key]: string_to_hash += f"{ku}={parameters[key]}{outsalt}" return shasign == sha512(string_to_hash.encode("utf-8")).hexdigest().upper()
def list_tickets(request): if request.method == 'GET': tickets = Ticket.objects.all().order_by('-id') ticket_serializer = TicketSerializer(tickets, many=True) # if request.user.is_authenticated: form = TicketForm({'id': Ticket.objects.count() + 1}) #return Response({'serializer': ticket_serializer }) #return JSONResponse(ticket_serializer.data) #ticket_form = TicketForm(request.POST) return render(request, "tickets/list_tickets.html", { "tickets": ticket_serializer.data, 'form': form }) elif request.method == 'POST': if request.user.is_authenticated: # form = TicketForm(request.POST) # tickets = Ticket.objects.all().order_by('-id') # ticket = get_object_or_404(Ticket, pk=request.POST['id']) # ticket_serializer = TicketSerializer(ticket, many=False) # form = TicketForm(initial=ticket_serializer.data) """ form = TicketForm(initial={'id':2, 'subject':'subject goes here', 'message':'message goes here', 'ticket_status':'N', 'ticket_type': 'D', 'updated':'2019-08-15 13:25:00', 'owner':'system'}) """ # data = {'id':15, 'subject':'subject goes here', 'message':'message goes here','ticket_status':'N','ticket_type': 'D','updated':'2019-08-15 13:25:00','owner':'system'} # data = {'id':request.POST['id'], 'subject':request.POST['subject'], 'message':request.POST['message'],'ticket_status':request.POST['ticket_status'],'ticket_type':request.POST['ticket_type'],'updated':request.POST['updated'],'owner':request.POST['owner'] } data = QueryDict.dict(request.POST) form = TicketForm() if not form.is_valid(): #cd = form.cleaned_data form = TicketForm(data) #data = form.cleaned_data bound = form.is_bound valid = form.is_valid() form.save() tickets = Ticket.objects.all().order_by("-id") size = Ticket.objects.count() + 1 blank = TicketForm({'id': Ticket.objects.count() + 1}) return render(request, "tickets/list_tickets.html", { "tickets": tickets, "size": size, "form": blank }) else: #return HttpResponse(request.POST + "hello" form['id'] + " " + form['subject'] + " " + form['message'] + " " + form['ticket_status'] + " " + form['ticket_type'] + " " + form['updated'] + " " + form['owner']) #return HttpResponse(form['id']) tickets = Ticket.objects.all() size = Ticket.objects.count() + 1 return render(request, "tickets/list_tickets.html", { 'form': form, "size": size }) """ ticket_data = JSONParser().parse(request) ticket_serializer = TicketSerializer(data=ticket_data) if ticket_serializer.is_valid(): ticket_serializer.save() #return JSONResponse(ticket_serializer.data, status=status.HTTP_201_CREATED ) return render(request, "tickets/list_tickets.html", { "tickets": ticket_serializer.data }) return JSONResponse(ticket_serializer.errors, status=status.HTTP_400_BAD_REQUEST ) """ else: return redirect("tickets:loginsss") else: form = TicketForm() return render(request, "tickets/list_tickets.html", {'form': form})
def AssetsEditView(request, pk): # print(request.body) data = QueryDict(request.body) jsondata = data.dict() Assets.objects.filter(pk=pk).update(**jsondata) return HttpResponse("Update ok")
def render(self, context, instance, placeholder): if not context['auth_flag']: return context # config = RegularReportChart.objects.get(cmsplugin_ptr_id=instance) # size = get_config_size(config.size) # context['title'] = config.title # context['size'] = size argpost = QueryDict.dict(context['request'].POST) argget = QueryDict.dict(context['request'].GET) project = Project.objects.get( name=context['request'].session['project']) queue_depth_id = argpost.get("queue_depth_id", None) #platform_id = argpost.get("platform_id",None) rw_id = argpost.get("rw_id", None) core_mask = argpost.get("core_mask", None) #io_size = argpost.get("io_size", None) #workload_mix = argpost.get("workload_mix", None) plan_id = argget.get("plan_id", None) #################### if rw_id and queue_depth_id: result_list = NvmeDriverTrendTable.objects.filter( rw_method_id=rw_id, queue_depth_id=queue_depth_id, ) elif rw_id: result_list = NvmeDriverTrendTable.objects.filter( rw_method_id=rw_id, ) elif queue_depth_id: result_list = NvmeDriverTrendTable.objects.filter( queue_depth_id=queue_depth_id, #rw_method_id=6, ) else: result_list = NvmeDriverTrendTable.objects.filter( rw_method_id=6, #queue_depth_id = queue_depth_id, ) #if queue_depth_id: # result_list = NvmeDriverTrendTable.objects.filter(queue_depth_id = queue_depth_id) chart_data = None exe_array,time_array,iops_array,latency_array,MBps_array,Min_lat_array,Max_lat_array=[],[],[],[],[],[],[] ############ #commit_info_list = TestRecordTable.objects.all() for res in result_list: iops_array.append(res.trend_iops) latency_array.append(res.trend_latency) time_array.append(str(res.create_time.strftime("%y-%m-%d"))) MBps_array.append(res.MBps) Min_lat_array.append(res.Min_lat) Max_lat_array.append(res.Max_lat) queue_depth_list = Queue_depth.objects.filter(project_id=project.id) rw_method_list = Rw_method.objects.filter(project_id=project.id) workload_mix_list = NvmeDriverTrendTable.objects.distinct().values( "workload_mix") core_mask_list = NvmeDriverTrendTable.objects.distinct().values( "Core_Mask") io_size_list = io_size.objects.all() if len(result_list) > 0: chart_data = json.dumps({ 'iops_array': iops_array[-7:], 'latency_array': latency_array[-7:], 'time_array': time_array[-7:], #'commit_info_list':commit_info_list 'MBps_array': MBps_array[-7:], 'Min_lat_array': Min_lat_array[-7:], 'Max_lat_array': Max_lat_array[-7:], 'queue_depth_id': queue_depth_id, 'rw_id': rw_id, 'core_mask': core_mask, #'io_size':io_size, #'workload_mix':workload_mix.workload_mix }) context['chart_data'] = chart_data #context['commit_info_list']=commit_info_list context['queue_depth_list'] = queue_depth_list context['rw_list'] = rw_method_list context['io_size_list'] = io_size_list context['workload_mix_list'] = workload_mix_list context['core_mask_list'] = core_mask_list return context
def get(self, request): Type = int(request.GET['type']) wordNumbers = int(request.GET['wordNumber']) updateTime = int(request.GET['updateTime']) state = int(request.GET['state']) bookMoney = int(request.GET['bookMoney']) pagesNumber = request.GET['pagesNumber'] clicksNumber = request.GET['bookHot'] books = BookInfo.objects.all() endTime = datetime.now() if Type is not 0: books = books.filter(type=Type) if wordNumbers is not 0: if wordNumbers is 1: books = books.filter(wordNumber__lt=300000) elif wordNumbers is 2: books = books.filter(wordNumber__range=(300000, 500000)) elif wordNumbers is 3: books = books.filter(wordNumber__range=(500000, 1000000)) else: books = books.filter(wordNumber__gt=1000000) if updateTime is not 0: if updateTime is 1: startTime = (endTime - timedelta(days=3)) books = books.filter(updateTime__range=(startTime, endTime)) elif updateTime is 2: startTime = (endTime - timedelta(days=7)) books = books.filter(updateTime__range=(startTime, endTime)) else: startTime = (endTime - timedelta(days=30)) books = books.filter(updateTime__range=(startTime, endTime)) if state is not 0: books = books.filter(state=state - 1) if bookMoney is not 0: books = books.filter(bookMoney=bookMoney - 1) paginator = Paginator(books, 10) serializers = LibrarySerializers( paginator.page(pagesNumber).object_list, many=True) library = QueryDict(mutable=True) library['list'] = serializers.data library['yeshuNumber'] = books.count() return HttpResponse(json.dumps(library.dict()))
def format_form(cls: type[T], form: QueryDict) -> T: return cls.parse_obj(form.dict())
def url_with_args(value: QueryDict, **kwargs): shit = {k: v for k, v in {**value.dict(), **kwargs}.items() if v} return '?' + urlencode(shit)
def ticket_detail(request, pk): # http_method_names = ["GET", "PUT", "DELETE"] try: ticket = Ticket.objects.get(pk=pk) except Ticket.DoesNotExist: return HttpResponse(status=status.HTTP_404_NOT_FOUND) if request.method == 'GET': ticket_serializer = TicketSerializer(ticket) form = TicketForm(initial=ticket_serializer.data) # return JSONResponse(ticket_serializer.data) return render( request, "tickets/ticket_detail.html", { 'ticket': ticket_serializer.data, 'current_user': request.user, 'form': form }) # return HttpResponse("GET Method") elif request.method == 'POST': data = QueryDict.dict(request.POST) if request.user.is_authenticated: # check if forms has values stored previously t = Ticket.objects.get(id=data['id']) # form = TicketForm(auto_id=True) Ticket.objects.filter(id=data['id']).update( subject=data['subject'], message=data['message'], ticket_type=data['ticket_type'], ticket_status=data['ticket_status'], updated=data['updated'], owner=data['owner']) # the **kwargs, states that it accepts dictionary as parameter # Ticket.objects.update_or_create(id=data['id'], subject=data['subject'], message=data['message'], ticket_type=data['ticket_type'], ticket_status=data['ticket_status'], updated=data['updated'], owner=data['owner']) #Ticket.objects.update(id=data['id'], subject=data['subject'], message=data['message'], ticket_type=data['ticket_type'], ticket_status=data['ticket_status'], updated=data['updated'], owner=data['owner']) #t.save() """ if not form.is_valid(): #cd = form.cleaned_data form = TicketForm(data) #data = form.cleaned_data bound = form.is_bound valid = form.is_valid() form.save() return redirect("tickets:updatess") #ticket = Ticket.objects.get(pk=pk) #return HttpResponse("Form is saved block") #return redirect("/tickets/api/list/", { "ticket": ticket, "current_user":request.user, "form":form }) #return redirect("tickets:listsss") #return render(request, "tickets/ticket_detail.html", { "ticket": ticket, "current_user":request.user, "form":form }) else: #return HttpResponse(request.POST + "hello" form['id'] + " " + form['subject'] + " " + form['message'] + " " + form['ticket_status'] + " " + form['ticket_type'] + " " + form['updated'] + " " + form['owner']) return HttpResponse("Is valid end") """ return redirect("tickets:listsss") # render(request, "tickets/ticket_detail.html", { "ticket":ticket }) else: return HttpResponse("Detail post not logged in") elif request.method == 'PUT': if request.user.is_authenticated: ticket_data = JSONParser().parse(request) # legacy ticket_serializer = TicketSerializer(ticket_data, data=ticket_data) ticket_serializer = TicketSerializer(ticket_data) if ticket_serializer.is_valid(): ticket_serializer.save() return HttpResponse("Serializer complete") #return JSONResponse(ticket_serializer.data) #return JSONResponse(ticket_serializer.errors, status=status.HTTP_400_BAD_REQUEST) return HttpResponse("PUT block") else: return HttpResponse("PUT check user block") elif request.method == 'DELETE': if request.user.is_authenticated: ticket.delete() return HttpResponse("Delete block") # return HttpResponse(status=status.HTTP_204_NO_CONTENT) else: return HttpResponse("DELETE check user")
def AssetsEditView(request, pk): if request.method == 'PUT': data = QueryDict(request.body) jsondata = data.dict() models.assetsInfo.objects.filter(pk=pk).update(**jsondata) return HttpResponse('success')
def EditResumeView(request, uid): ret = {"status": "seccuss", "status_code": "200"} _access = request.META.get('HTTP_X_REAL_IP') or request.META.get( 'HTTP_REMOTE_ADD') or request.META.get('REMOTE_ADDR') data = QueryDict(request.POST.urlencode(), mutable=True) # ManyToMany Field AssociatedFields = [ "personal_assessment", "work_info", "education_info", "project_info", "raw_text", "comprehensive_ability", "upload_user", ] MoreTable = {} obj = models.ResumeInfo.objects.filter(id=uid) if request.method == "POST": try: for i in request.POST: if i in AssociatedFields: MoreTable[i] = request.POST.get(i, None) data.pop(i) if data: obj.update(**data.dict()) if MoreTable: for item in MoreTable: instance = getattr(obj[0], item) instance.update(describe=MoreTable[item]) _describe = EventCode.EventCode["Resume.Update.Info"]["zh"][ "seccess"].format(request.user, obj.last().id, obj.last().username) _status = 1 _event_record = tasks.CommonRecordEventLog.delay( uuid=obj.last().uuid, user_id=request.user.id, event_type=EventCode.EventCode["Resume.Update.Info"]["type"], label=EventCode.EventCode["Resume.Update.Info"]["label"], request=None, response=None, describe=_describe, status=_status, access=_access, source=request.user.uuid, target=obj.last().uuid, ) obj.update(modify_time=datetime.datetime.now(tz)) except: _describe = EventCode.EventCode["Resume.Update.Info"]["zh"][ "failed"].format(request.user, obj.last().id, obj.last().username) _status = 2 _event_record = tasks.CommonRecordEventLog.delay( uuid=obj.last().uuid, user_id=request.user.id, event_type=EventCode.EventCode["Resume.Update.Info"]["type"], label=EventCode.EventCode["Resume.Update.Info"]["label"], request=None, response=None, describe=_describe, status=_status, access=_access, source=request.user.uuid, target=obj.last().uuid, ) return JsonResponse(ret)
def render(self, context, instance, placeholder): if not context['auth_flag']: return context config = RegularReportChart.objects.get(cmsplugin_ptr_id=instance) size = get_config_size(config.size) context['title'] = config.title context['size'] = size argpost = QueryDict.dict(context['request'].POST) argget = QueryDict.dict(context['request'].GET) project = Project.objects.get( name=context['request'].session['project']) plan_id = argget.get("plan_id", None) exe_id = argget.get("execution_id", None) rw_id = argpost.get("rw_id", None) if rw_id: exec_list = TestExecution.objects.filter(rw_id=rw_id, testplan_id=plan_id, project_id=project.id) else: plan_list = TestExecution.objects.filter(id=exe_id) exec_list1 = TestExecution.objects.filter(id=exe_id, project_id=project.id) plan_id_list = [] for exe in exec_list1: plan_id_list.append(exe.testplan) plan_id = plan_id_list[0] #Get All exec in One Testplan: exec_list = TestExecution.objects.filter(testplan=plan_id, project_id=project.id) chart_data = None exe_array,time_array,iops_array,latency_array,result_iops,rw_array,io_size_array =[],[],[],[],[],[],[] for exe in exec_list: exe_array.append(exe.rw.rw_method) results = Vhost_Scsi_Perf_Result.objects.filter( testexecution_id=exe.id, ) for res in results: #exe_array.append(res.rw_method.rw_method) iops_array.append(res.iops) latency_array.append(res.latency) time_list = Vhost_Scsi_Perf_Result.objects.filter( project_id=project.id) rw_list = Rw_method.objects.filter(project_id=project.id) for time in time_list: time_array.append(time.create_time) for rw in rw_list: rw_array.append(rw.rw_method) rw_type_list = Rw_method.objects.filter(project_id=project.id) rw_type_array = [] for rw_type in rw_type_list: rw_type_array.append(rw_type.rw_method) if len(exec_list) > 0: chart_data = json.dumps({ 'exe_array': exe_array, 'exec_length': len(exec_list), 'iops_array': iops_array, 'latency_array': latency_array, 'time_array': 'time_array', 'rw_array': rw_array, 'rw_type_array': rw_type_array }) context['chart_data'] = chart_data context['rw_list'] = rw_list context['exec_list'] = exec_list return context