def post(self, request, *args, **kwargs):
l_form = LoginForm(request.POST)
if l_form.is_valid():
email = l_form.cleaned_data['email']
password = l_form.cleaned_data['password']
try:
member = Member.objects.get(email=email)
if check_password(password, member.password):
auth.login(request, member)
ret = {
'code': 200,
'message': _('Login success.'),
'redirect': reverse('member_login')
}
return response.JsonResponse(ret)
else:
ret = {'code': 403, 'message': _('Password error.')}
return response.JsonResponse(ret)
except Member.DoesNotExist:
ret = {'code': 404, 'message': _('Username not exist.')}
return response.JsonResponse(ret)
else:
context = {'errors': l_form.errors}
return render(request, 'login.html', context)
def add_service(request):
if request.is_ajax():
get_service = request.POST.get("service")
Service.objects.create( service_name=get_service).save()
return response.JsonResponse({
'msg' :'Success',
})
return response.JsonResponse({
'msg' :'error',
})
def post_top_n_users(request):
if request.method == "GET":
html = """<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<form method='post' action="http://127.0.0.1:8000/v1/ranking_list/upload">
玩家姓名:<input type="text" name="client_name">
成绩:<input type="text" name="fraction">
<input type='submit' value='提交'>
</form>
</body>
</html>"""
return HttpResponse(html)
if request.method == 'POST':
request_data = request.POST
print(f"POST内容:{request_data}")
client_name = request_data.get("client_name")
fraction = request_data.get("fraction")
if not client_name and not fraction:
return response.JsonResponse(
User_response.User_Response.error(
400, "not params client_name, fraction"))
print(f"client_name:{client_name}, fraction:{fraction}")
# 放redis有序集合(废)
score = 1
fraction_list = r.zrange("fraction", 0, -1)
if int(fraction) not in fraction_list:
pipe.zadd("fraction", {int(fraction): score})
pipe.execute()
current_client = Hign_scores.objects.filter(client_name=client_name)
print(f"current_client:{current_client}")
if current_client:
Hign_scores.objects.filter(client_name=client_name).update(
fraction=int(fraction))
else:
try:
Hign_scores_obj = Hign_scores.objects.create(
client_name=client_name, fraction=int(fraction))
Hign_scores_obj.save()
except Exception as e:
return response.JsonResponse(
User_response.User_Response.error(400, "not params"))
upload_data = {}
upload_data["client_name"] = client_name
upload_data["fraction"] = fraction
record = User_response.User_Response.success(200, upload_data)
return response.JsonResponse(data=record)
def add_subservice(request):
if request.is_ajax():
service_id = request.POST.get("service_id")
print (service_id)
service_get = Service.objects.get(pk=service_id)
sub_service = request.POST.get("sub_service")
SubService.objects.create(service_name=service_get,sub_service_name=sub_service).save()
return response.JsonResponse({
'msg' :'Success',
})
return response.JsonResponse({
'msg' :'error',
})
def add_servicetype(request):
if request.is_ajax():
sub_service_id = request.POST.get("subservice_id")
subservice_get = SubService.objects.get(pk=sub_service_id)
service_type = request.POST.get("service_type")
service_type_amount = request.POST.get("service_type_amount")
ServiceType.objects.create(service_name=subservice_get,service_type=service_type, service_type_rate=service_type_amount).save()
return response.JsonResponse({
'msg' :'Success',
})
return response.JsonResponse({
'msg' :'error',
})
def get(self, request):
request_params = request.GET
client_name = request_params.get("client_name")
if not client_name:
return response.JsonResponse(
StatusResponse.error(400, "need client_name"))
current_page = int(request_params.get("p", 1))
count = request_params.get("count", 10)
playergoal_obj = Ranking.objects.all().order_by("-fraction")
paginator = Paginator(playergoal_obj, count) # 每页5条记录
num_pages = paginator.num_pages
print(num_pages)
if current_page > num_pages:
current_page = 1
page = paginator.page(current_page) # 获取第一页数据，从1开始
total = paginator.count
start_index = (current_page - 1) * 10 + 1
current_obj = None
s_index = 1
playergoal_array = []
for index, obj in enumerate(page):
if client_name == obj.client_name:
current_obj = obj
playergoal_array.append({
"index": start_index + index,
"id": obj.id,
"client_name": obj.client_name,
"fraction": obj.fraction
})
if not current_obj:
current_obj = Ranking.objects.filter(
client_name=client_name).first()
if current_obj:
playergoal_array.append({
"index": s_index,
"id": current_obj.id,
"client_name": current_obj.client_name,
"fraction": current_obj.fraction,
})
data = {
"page": current_page,
"count": count,
"total": total,
"data": playergoal_array
}
record = StatusResponse.success(data)
return response.JsonResponse(data=record)
def update_mistri_information(request):
if request.is_ajax():
u = User.objects.get(pk=request.user.id)
m = MistriInformation.objects.all()
global mid
global muid
global memail
global mplink
for x in m:
mid = x.id
muid =x.uid
memail = x.email
mplink = x.profile_image_link
m_data = MistriInformation.objects.get(pk=mid)
m_data.mistri_id = 2
m_data.uid = muid
m_data.email = memail
m_data.profile_image_link = mplink
m_data.name = request.POST.get('name')
m_data.phone = request.POST.get('number')
try:
m_data.image = request.FILES['image']
print (request.FILES['image'])
print ("f**k From image")
except :
print ("f**k without image")
# m_data.address = request.POST.get('address')
m_data.dob = request.POST.get('dob')
#user=u,mistri_id=mistri_id,uid=uid,name=name,phone=phone,image=image,address=address,dob=dob
m_data.save()
return response.JsonResponse({
'msg' :'Success',
})
def update_client_information(request):
if request.is_ajax():
u = User.objects.get(pk=request.user.id)
c = ClientInformation.objects.all()
global cid
global cuid
global memail
for x in c:
cid = x.id
cuid =x.uid
cemail =x.email
cplink = x.profile_image_link
c_data = ClientInformation.objects.get(pk=cid)
c_data.clint_id = 1
c_data.uid = cuid
c_data.email = cemail
c_data.profile_image_link = cplink
c_data.name = request.POST.get('name')
c_data.phone =request.POST.get('phone')
c_data.home_address = request.POST.get('address')
c_data.save()
# return render(request,"dashboard/personal_information.html")
return response.JsonResponse({
'msg' :'Success',
})
def auto_response(resp):
if isinstance(resp, text_type):
return response.HttpResponse(resp)
elif isinstance(resp, dict):
return response.JsonResponse(resp)
else:
return resp
def post(self, request):
request_data = request.POST
client_name = request_data.get("client_name")
fraction = request_data.get("fraction")
if not all([client_name, fraction]):
return response.JsonResponse(StatusResponse.error(400, "need params client_name, fraction"))
print(client_name, fraction)
current_client = playerrank.objects.filter(client_name=client_name).first()
# 如果存在更新，不存在新增
if current_client:
playerrank.objects.filter(client_name=client_name).update(fraction=fraction)
else:
playergoal_obj = playerrank(client_name=client_name, fraction=fraction)
playergoal_obj.save()
record = StatusResponse.success({})
return response.JsonResponse(data=record)
def log_stream(request):
if not request.is_ajax():
return response.HttpResponseBadRequest(
"Only Ajax requests are accepted.")
if request.method != 'POST':
return response.HttpResponseNotAllowed(request.method)
search_str = request.POST.get("search")
aggregates = []
if search_str != "":
aggregates.append({"$match": {"$text": {"$search": search_str}}})
last_requests = log_records.aggregate(aggregates + [{
"$sort": {
"time": -1
}
}, {
"$limit": 100
}, {
"$project": {
"_id": 0
}
}])
data = {"last_requests": list(last_requests)}
return response.JsonResponse(data)
def predict(request):
from pss_recognition.recognition.model_holder import ModelHolder
from pss_recognition.recognition.recognition import transform_x, get
import tensorflow as tf
import numpy as np
import json
if request.method == 'POST':
form = UploadFileForm(request.POST, request.FILES)
if form.is_valid():
model = ModelHolder.get_model()
label_to_name = json.loads(
open('models/latest_label_to_name.json').read())
handle_uploaded_file(request.FILES['picture'])
with tf.device('/CPU:0'):
transformed, _ = transform_x(np.asarray([get('image.jpg')]),
np.asarray([0]))
prediction = model.predict(transformed)
label = np.argmax(prediction)
probability = np.max(prediction)
return response.JsonResponse({
'name': label_to_name[str(label)],
'probability': str(probability)
})
return response.HttpResponseBadRequest()
def finalize_response(self, request, response, *args, **kwargs):
if isinstance(response, text_type):
response = django_response.HttpResponse(response)
elif isinstance(response, dict):
response = django_response.JsonResponse(response)
return super(WeChatViewMixin, self).finalize_response(
request, response, *args, **kwargs)
def delete_subservicetype(request):
if request.is_ajax():
sub_service_type = request.POST.get("id")
subservicetype = ServiceType.objects.get(pk=sub_service_type)
subservicetype.delete()
return response.JsonResponse({
'msg' :'Success',
})
def delete_service(request):
if request.is_ajax():
service_id = request.POST.get("id")
service = Service.objects.get(pk=service_id)
service.delete()
return response.JsonResponse({
'msg' :'Success',
})
def add_city(request):
if request.is_ajax():
city = City.objects.all()
city_name = request.POST.get("city")
print(request.POST.get("city"))
City.objects.create(city_name=city_name).save()
return response.JsonResponse({
'msg' :'Success',
})
def ajax_postCreateRoom(req):
if req.method == "POST":
game = DBC.createRoom(req.user)
res = {
"success": True,
"gameId": game.id,
"message": "ルームを作成しました．"
}
return response.JsonResponse(res)
def delete_city(request):
if request.is_ajax():
city_id = request.POST.get("id")
get_city = City.objects.get(pk=city_id)
get_city.delete()
return response.JsonResponse({
'msg' :'Success',
})
def delete_subarea(request):
if request.is_ajax():
subarea_id = request.POST.get("id")
get_subarea = SubArea.objects.get(pk=subarea_id)
get_subarea.delete()
return response.JsonResponse({
'msg' :'Success',
})
def add_subarea(request):
if request.is_ajax():
area_id= request.POST.get("sub_area_id")
area_name = Area.objects.get(pk=area_id)
subarea_name = request.POST.get("subarea")
SubArea.objects.create(area_name=area_name,sub_area_name=subarea_name).save()
return response.JsonResponse({
'msg' :'Success',
})
def edit_city(request):
if request.is_ajax():
city_id = request.POST.get("id")
city_get = City.objects.get(pk=city_id)
city_get.city_name = request.POST.get("edit_city_name")
city_get.save()
return response.JsonResponse({
'msg' :'Success',
})
def cart_detail(request):
cart = Cart(request).cart
for cart_item in cart:
item_from_db = Product.objects.filter(pk=cart_item).first()
if not item_from_db:
cart.remove(cart_item)
else:
cart[cart_item]['ksh_price'] = item_from_db.ksh_price
cart[cart_item]['usd_price'] = item_from_db.usd_price
return response.JsonResponse(cart, safe=False)
def edit_service(request):
if request.is_ajax():
service_id = request.POST.get("id")
service = Service.objects.get(pk=service_id)
service.service_name = request.POST.get("change_name_service")
service.save()
return response.JsonResponse({
'msg' :'Success',
})
def client_order_process(request):
if request.is_ajax():
mistri_list = request.POST.getlist("mistri_name_data")
discount_amount = request.POST.get("discountAmount")
print (mistri_list,"===>",discount_amount)
return response.JsonResponse({
'msg':'success',
'mistri_list':list(mistri_list),
'discount_amount':discount_amount,
})
def shorten(request):
try:
url = json.loads(str(request.body, encoding='utf-8'))['url']
val(url)
obj = URL.objects.get_or_create(original_link=url)
except:
return response.HttpResponseBadRequest()
return response.JsonResponse({
"short_link": request.build_absolute_uri(reverse("open", args=(obj[0].slug,))),
"original_link": obj[0].original_link
}) #status=201 if obj[1] else 200
def add_area(request):
if request.is_ajax():
city_id1 = request.POST.get("city_id")
print ("====>",city_id1)
city_name1 = City.objects.get(pk=city_id1)
area_name = request.POST.get("area")
print ("====>",area_name)
Area.objects.create(city_name=city_name1,area_name=area_name).save()
return response.JsonResponse({
'msg' :'Success',
})
def request_month(request):
if not request.is_ajax():
return response.HttpResponseBadRequest(
"Only Ajax requests are accepted.")
if request.method != 'POST':
return response.HttpResponseNotAllowed(request.method)
year = request.POST.get("year")
month = request.POST.get("month")
return response.JsonResponse(requests_month_bar(year=year, month=month))
def edit_subarea(request):
if request.is_ajax():
area_id = request.POST.get("get_areaid")
area_get = Area.objects.get(pk=area_id)
subarea_id = request.POST.get("id")
subarea_get = SubArea.objects.get(pk=subarea_id)
subarea_get.area_name = area_get
subarea_get.sub_area_name = request.POST.get("edit_subarea_name")
subarea_get.save()
return response.JsonResponse({
'msg' :'Success',
})
def edit_area(request):
if request.is_ajax():
city_id = request.POST.get("get_cityid")
city_get = City.objects.get(pk=city_id)
area_id = request.POST.get("id")
get_area = Area.objects.get(pk=area_id)
get_area.city_name = city_get
get_area.area_name = request.POST.get("edit_area_name")
get_area.save()
return response.JsonResponse({
'msg' :'Success',
})
def edit_subservicetype(request):
if request.is_ajax():
subservice_id = request.POST.get("subservice_id")
fetch_subservice = SubService.objects.get(pk=subservice_id)
servicetype_id = request.POST.get("id")
servicetype = ServiceType.objects.get(pk=servicetype_id)
servicetype.service_name = fetch_subservice
servicetype.service_type = request.POST.get("change_name_servicetype")
servicetype.service_type_rate = request.POST.get("change_servicetype_rate")
servicetype.save()
return response.JsonResponse({
'msg' :'Success',
})
