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
