def post(self, request, *args, **kwargs):
"Handle post requests."
if not request.user.is_authenticated():
response = JsonResponse({"errors": ["Not authenticated"]},
content_type='application/json')
response.status_code = 403
return response
if not request.user.profile.school:
response = JsonResponse(
{"errors": ["Not associated with any school"]},
content_type='application/json')
response.status_code = 403
return response
form = KioskForm(request.POST)
response = {}
status_code = None
if form.is_valid() and form.cleaned_data['kiosk_pk'] != -1:
status_code = 201
# Update the form
try:
kiosk = Kiosk.objects.get(pk=form.cleaned_data['kiosk_pk'])
kiosk.name = form.cleaned_data['name']
kiosk.save()
update_poll(kiosk, form.cleaned_data['poll_question'],
form.cleaned_data['poll_choices'])
kiosk.save()
except ObjectDoesNotExist:
response['errors'] = 'PK not found'
response['data'] = form.cleaned_data
status_code = 404
elif form.is_valid() and form.cleaned_data['kiosk_pk'] == -1:
kiosk = Kiosk(
name=form.cleaned_data['name'],
school=self.request.user.profile.school,
)
kiosk.save()
if form.cleaned_data['poll_question']:
kiosk.poll = PollQuestion(
question_text=form.cleaned_data['poll_question'])
kiosk.poll.save()
for choice in form.cleaned_data['poll_choices'].split('\n'):
PollChoice(question=kiosk.poll, choice_text=choice).save()
kiosk.save()
status_code = 201
response['data'] = form.cleaned_data
response['data']['kiosk_pk'] = kiosk.pk
else:
response['errors'] = form.errors
status_code = 400
http_response = JsonResponse(response)
http_response.status_code = status_code
return http_response
def patch(self, request, pk):
"""
修改用户密码
请求方式:
http://127.0.0.1:8000/site/user/(?P<id>\d+)?pwd=xxxx
"""
user_id = request.session.get("user_id")
pwd = request.GET.get("password")
# print(user_id,pwd)
# 传值为空
if not pk or not pwd:
res = JsonResponse({"code": 0, "msg": "值为空"})
res.status_code = status.HTTP_400_BAD_REQUEST
return res
# 验证是否为本人操作
if int(user_id) != int(pk):
res = JsonResponse({"code": 0, "msg": "修改失败"})
res.status_code = status.HTTP_401_UNAUTHORIZED
return res
query = models.User.objects.filter(id=pk)
res = return_exist(query)
if res: return res
#保存
obj = query.first()
obj.password = pwd
obj.save()
res = JsonResponse({"code": 1, "msg": "修改成功"})
res.status_code = status.HTTP_200_OK
return res
def recognise(request):
global nn
try:
if 'nn' in request.session:
# nn = NetworkReader.readFrom('data/' + request.session['nn'] + '.nn')
img = request.POST['img_data']
img, img_data = _transform_img(img)
print img_data
print img_data.ravel().tolist()
# activation = nn.activate(_img_data_to_vec(img_data))
activation = nn.call(_img_data_to_vec(img_data))
print activation
return JsonResponse({
'status': 'ok',
'activation': activation.tolist()
})
else:
resp = JsonResponse({
'status': 'error',
'msg': 'Run train first'
})
resp.status_code = 400
return resp
except Exception as e:
print e
resp = JsonResponse({
'status': 'error',
'msg': e
})
resp.status_code = 500
return resp
def logout(request):
"""
请求方式:
http://127.0.0.1:8000/site/logout
"""
if request.method != "GET":
res = JsonResponse({"code": 0, "msg": "请求方法不被允许"})
res.status_code = status.HTTP_405_METHOD_NOT_ALLOWED
return res
request.session.delete()
res = JsonResponse({"code": 1, "msg": "请求成功"})
res.status_code = status.HTTP_200_OK
return res
def get_json_response_error_with_data(http_status_code, http_msg, data_name, data):
"""
Generate a json http response encoded for errors with specific data (object json-friendly)
and its property name.
{
'http_msg': <http_msg>
<data_name>: <data>
}
:param http_status_code: http code
:type http_status_code: int
:param http_msg: summary message
:type http_msg: str
:param data_name: name of property data in the json encoded string
:type data_name: str
:param data: json-friendly python object
:type data: dict or list or tuple or str
"""
error = {'http_msg': http_msg, data_name: data}
response = JsonResponse(error)
response.status_code = http_status_code
return response
def post(self, request):
"""
随机创建数据
0-10
小于7.5 属于3/4概率 ,
反之 1/4
请求方式:
http://127.0.0.1:8000/site/data
"""
str = request.POST.get("key")
for i in range(20):
number = random.randint(1, 10)
res = self.create()
if number <= 7.5:
res = self.create() + str
lens = len(res)
# 有些耗费性能,应该批量创建
models.Data.objects.create(str=res, len=lens)
res = JsonResponse({
"code": 1,
"msg": "创建成功",
})
res.status_code = status.HTTP_201_CREATED
return res
def server_failure(request):
status = ServerStatus.objects.get(id=1)
types = status.types
delay_time = status.delay_time
code = status.status_code
if types == 'status_code':
resp = JsonResponse(
retv(True,
str(code) + " " + status_code.get(code), code))
resp.status_code = int(code)
return resp
if types == 'delay_time':
request_time = datetime.now().isoformat()
time.sleep(float(delay_time))
response_time = datetime.now().isoformat()
resp = JsonResponse(
retv(
True,
f'Delay {delay_time} Second(s)',
200,
request_time=request_time,
response_time=response_time,
))
return resp
return JsonResponse(retv(False, '서버 장애 내용을 확인해주세요.'))
def retrain(request):
dataset_name = request.POST['dataset_name']
try:
X = []
y = []
with open('data/' + dataset_name + '.csv', 'r') as f:
csv_f = csv.reader(f, delimiter=',')
for l in csv_f:
X.append([float(ll) for ll in l[:-1]])
y.append(_number_to_output_vector(int(float(l[-1]))))
X = np.asarray(X)
y = np.asarray(y)
_train2(X, y, dataset_name, 1500)
request.session['nn'] = dataset_name
for im, l in zip(X, y):
print l, nn.call(im)
return JsonResponse({
'status': 'ok'
})
except Exception as e:
print e
resp = JsonResponse({
'status': 'error',
'msg': e.message
})
resp.status_code = 500
return resp
def create_json_response(status,
details,
status_code=None,
res_errors=None,
data=None,
warnings_=None,
importer_id=None,
auto_generation=None,
error_type=None,
missing_columns=None):
info = {'status': status, 'details': details}
if res_errors:
info['errors'] = res_errors
if data:
info['data'] = data
if warnings_:
info['warnings'] = warnings_
if importer_id:
info['importer_id'] = importer_id
if auto_generation:
info['auto_generation'] = auto_generation
if error_type:
info['error_type'] = error_type
if missing_columns is not None:
info['missing_columns'] = missing_columns
response = JsonResponse(info)
if status_code:
response.status_code = status_code
return response
def train_mnist(request):
try:
data = scipy.io.loadmat("mnist/ex4data1.mat")
X = data["X"][:15000]
y = data["y"][:15000]
y[y == 10] = 0
y = [_number_to_output_vector(yy) for yy in y]
print len(X), len(y)
f = uuid.uuid4().hex
_train(X, y, f, 50)
request.session['nn'] = f
return JsonResponse({
'status': 'ok'
})
except Exception as e:
print e
resp = JsonResponse({
'status': 'error',
'msg': e.message
})
resp.status_code = 500
return resp
def process_view(self, request, callback, callback_args, callback_kwargs):
if callback.__name__ == "DataView":
id = request.session.get("user_id")
if not id:
res = JsonResponse({"code": 0, "msg": "请登录"})
res.status_code = status.HTTP_302_FOUND
return res
def status_test_path(request, code):
if code:
resp = JsonResponse(
retv(True,
str(code) + " " + status_code.get(str(code)), str(code)))
resp.status_code = int(code)
return resp
return JsonResponse(retv(False, 'Status Code를 확인해주세요.'))
def return_exist(obj):
"""
验证是否存在
"""
if not obj:
res = JsonResponse({"code": 0, "msg": "不存在该用户"})
res.status_code = status.HTTP_400_BAD_REQUEST
return res
def post(self, request, *args, **kwargs):
if request.is_ajax():
form = self.form_class(request.POST)
if form.is_valid():
form.save()
mensaje = f'{self.model.__name__} registrado correctamente!'
error = 'No hay error!'
response = JsonResponse({'mensaje': mensaje, 'error': error})
response.status_code = 201
return response
else:
mensaje = f'{self.model.__name__} no se ha podido registrar!'
error = form.errors
response = JsonResponse({'mensaje': mensaje, 'error': error})
response.status_code = 400
return response
else:
return redirect('accounts:inicio_usuarios')
def form_invalid(self, form):
# if response type as typed with json
if self.request.GET.get('dataType') == 'json':
response = JsonResponse(form.errors)
else:
response = super(ContactView, self).form_invalid(form)
response.status_code = 400
return response
def status_test(request):
code = request.GET.get('code')
if code:
resp = JsonResponse(
retv(True,
str(code) + " " + status_code.get(code), code))
resp.status_code = int(code)
return resp
return JsonResponse(retv(False, 'Status Code를 확인해주세요.'))
def get(self, request):
response_data = {
attr[:-4]: os.environ.get(getattr(self, attr))
for attr in dir(self)
if attr.endswith('_key') and getattr(self, attr)
}
response = JsonResponse(response_data)
if not response_data['build_date'] or not response_data['commit_id']:
response.status_code = 501
return response
def get(self, request):
"""
获取数据个数
请求方式:
http://127.0.0.1:8000/site/data
"""
key = request.GET.get("key")
count = models.Data.objects.filter(str__contains=key, len__gt=10)
# 没查到
if not count:
res = JsonResponse({"code": 0, "msg": "结果为空"})
res.status_code = status.HTTP_200_OK
return res
res = JsonResponse({"code": 1, "count": len(count)})
res.status_code = status.HTTP_200_OK
return res
def process_request(self, request):
while_url_list = Url.objects.filter(user_type='anonymous').values_list(
'url', flat=True)
for url in while_url_list:
if re.match(url, request.path_info): return None
if 'logged_in' in request.session and request.session[
'logged_in'] == 'no':
response = JsonResponse({'detail': 'Permission denied'})
response.status_code = 403
return response
def send_verification_email(request, user=None):
if request.method == "POST":
email = request.POST.get("email")
password = request.POST.get("password")
user = authenticate(request, email=email, password=password)
if user and user.verify_email(request):
return JsonResponse({"success": "Quiz successfully saved"})
else:
jsonResponse = JsonResponse({"error": "Email Could Not Be Sent"})
jsonResponse.status_code = 400
def post(self, request):
"""
创建用户
"""
res = self.regex(request)
user = res['user']
pwd = res['pwd']
# 创建成功
if user and pwd:
models.User.objects.create(username=user, password=pwd)
res = JsonResponse({"code": 1, "msg": "创建成功"})
res.status_code = status.HTTP_201_CREATED
return res
# 失败
res = JsonResponse({"code": 0, "msg": "用户名或者密码error"})
res.status_code = status.HTTP_400_BAD_REQUEST
return res
def delete(self, request, *args, **kwargs):
if request.is_ajax():
usuario = self.get_object()
usuario.usuario_activo = False
usuario.save()
mensaje = f'{self.model.__name__} eliminado correctamente!'
error = 'No hay error!'
response = JsonResponse({'mensaje': mensaje, 'error': error})
response.status_code = 201
return response
else:
return redirect('accounts:inicio_usuarios')
def fileUpload(request): file = request.FILES['uploadedFile'] file_name = default_storage.save(file.name, file) fileUpload = File( fileName = file_name ) fileUpload.save() response = JsonResponse(fileUpload.as_dict()) response.status_code = 201 thread = threading.Thread(fileUpload.process()) thread.start() return JsonResponse(file_name, safe = False)
def process_request(self, request):
while_url_list = Url.objects.filter(user_type='anonymous').values_list(
'url', flat=True)
for url in while_url_list:
if re.match(url, request.path_info): return None
user_jwt = JSONWebTokenAuthentication().authenticate(Request(request))
if user_jwt is not None:
user = user_jwt[0]
request.user = user
return None
response = JsonResponse({'detail': 'Permission denied'})
response.status_code = 403
return response
def post(self, request, *args, **kwargs):
if request.is_ajax():
form = self.form_class(request.POST)
if form.is_valid():
Alumno = CreateAlumno(form)
else:
mensaje = f'{self.model.__name__} no se ha podido registrar!'
error = " "
error = form.errors
response = JsonResponse({'mensaje': mensaje, 'error': error})
response.status_code = 400
return response
else:
return redirect('alumnos: list')
def save_extra(request):
if request.method == "POST":
extra = request.POST.get("extra")
# extra = json.loads(extra)
quiz_id = request.POST.get("quiz")
quiz = get_object_or_404(Quiz, quiz_id=quiz_id)
quizTaker = QuizTakers.objects.get(quiz=quiz, user=request.user)
quizTaker.extra = extra
quizTaker.save()
return JsonResponse(
{"success": "Extra Information saved successfully"})
jsonResponse = JsonResponse(
{"error": "Extra Information Could Not Be Saved"})
jsonResponse.status_code = 400
def get(self, request):
from moj_irat.healthchecks import registry
response_data = {}
for response in registry.run_healthchecks():
response = response.get_dict()
check_name = response.pop('name')
response_data[check_name] = response
all_passed = all(response['status'] for response in response_data.values())
response_data['*'] = dict(status=all_passed)
response = JsonResponse(response_data)
if not all_passed:
response.status_code = 500
return response
def login(request):
"""
请求方式:
http://127.0.0.1:8000/site/login
"""
if request.method != "POST":
res = JsonResponse({"code": 0, "msg": "请求方法不被允许"})
res.status_code = status.HTTP_405_METHOD_NOT_ALLOWED
return res
user = request.POST.get("username")
pwd = request.POST.get("password")
obj = models.User.objects.filter(username=user, password=pwd)
res = return_exist(obj)
if res: return res
request.session["user_id"] = obj.first().pk
res = JsonResponse({"code": 1, "msg": "登录成功"})
res.status_code = status.HTTP_200_OK
return res
def delete(self, request, pk):
"""
删除
请求方式:
http://127.0.0.1:8000/site/user/(?P<id>\d+)
"""
obj = models.User.objects.filter(id=pk)
res = return_exist(obj)
# fail
if res: return res
# suc
obj.delete()
res = JsonResponse({"code": 1, "msg": "删除成功"})
res.status_code = status.HTTP_200_OK
return res
def answer_request_delete_view(request, pk):
try:
answer_request = request.user.answer_requests.get(pk=pk)
answer_request.request_list.remove(request.user.pk)
answer_request.save()
except:
response = JsonResponse({}, safe=False)
response.status_code = 400
return response
response = JsonResponse({}, safe=False)
response.status = 200
return response
def error(self, title='Server Error. Unexpected Mode.', path="/"):
''' '''
result = {}
errors = []
error = {}
meta = {}
error['id'] = 'server'
error['code'] = '500'
error['title'] = title
meta['arguments'] = []
meta['arguments'].append(path)
error['meta'] = meta
errors.append(error)
result['errors'] = errors
response = JsonResponse(result)
response.status_code = 500
return response
def profile_update_view(request, username):
User = get_user_model()
user = get_object_or_404(User, username=username)
if user == request.user:
if request.method == 'POST':
data = json.loads(request.body)
first_name = user.first_name
last_name = user.last_name
bio = user.bio
try:
first_name = data['first_name']
except KeyError:
pass
try:
last_name = data['last_name']
except KeyError:
pass
try:
bio = data['bio']
except KeyError:
pass
user.first_name = first_name
user.last_name = last_name
user.bio = bio
user.save()
response = JsonResponse(
{
'first_name': first_name,
'last_name': last_name,
'bio': bio,
},
safe=False)
response.status_code = 200
return response
return JsonResponse({}, safe=False)
def process_request(self, request):
anonymous_url_queryset = Url.objects.filter(user_type='anonymous')
authenticated_url_queryset = Url.objects.filter(
user_type='authenticated')
# 匿名用户基础权限
if self.urlcheck(request, anonymous_url_queryset): return None
if not request.user.is_authenticated: return None
user = request.user
# 登录用户基础权限
if self.urlcheck(request, authenticated_url_queryset): return None
# 自定义用户权限
role_list = user.roles.all()
for role in role_list:
url_obj_list = role.urls.all()
if self.urlcheck(request, url_obj_list): return None
response = JsonResponse({'detail': 'Permission denied'})
response.status_code = 403
return response
def train(request):
images = json.loads(request.POST['dataset'])
random.shuffle(images)
filename = str(int(time.time())) + "_" + str(uuid.uuid4().hex)
try:
images_data = []
with open('data/' + filename + '.csv', 'w') as f:
a = csv.writer(f, delimiter=',')
for img, label in images:
img_data = _img_data_to_vec(_transform_img(img)[1])
img_data = np.append(img_data, [label])
images_data.append(img_data)
a.writerows(images_data)
X = []
y = []
for d in images_data:
X.append(d[:-1])
y.append(_number_to_output_vector(int(d[-1])))
_train2(X, y, filename, 10000)
request.session['nn'] = filename
for im in images_data:
print im[-1], nn.call(im[:-1])
return JsonResponse({
'status': 'ok'
})
except Exception as e:
print e
resp = JsonResponse({
'status': 'error',
'msg': e.message
})
resp.status_code = 500
return resp
