def cancel_request(request, request_id):
if request.method == 'DELETE':
req = request.user.request_set.get(id=request_id)
if req.status == Request.OPEN:
req.delete()
return JsonResponse({
'status': 'success',
'message': req.subject
})
else:
response = JsonResponse({
'status': 'error',
'message': 'Cannot cancel once a bidder has been accepted.',
})
response.status_code = 404
return response
response = JsonResponse({
'status': 'error',
'message': 'Invalid request method.',
})
response.status_code = 404
return response
def edit(request):
if request.POST.get('id'):
company = Company.objects.get(id=request.POST.get('id'))
else:
company = None
cf = CompanyForm(request.POST, request.FILES, instance=company)
if not cf.is_valid():
response = JsonResponse(cf.errors)
response.status_code = 500
return response
company = cf.save()
errors = dict()
if request.POST.get('positions'):
positions = literal_eval(request.POST.get('positions'))
for position in positions:
position['company'] = company.id
if position.get('id'):
position_obj = Position.objects.get(id=position['id'])
else:
position_obj = None
pf = PositionForm(position, instance=position_obj)
if not pf.is_valid():
if position.get('name'):
errors[position['name']] = pf.errors
else:
errors['Unknown'] = pf.errors
else:
if pf.instance.ongoing is None:
pf.instance.ongoing = pf.fields['ongoing'].initial
pf.save()
if len(errors) > 0:
response = JsonResponse({'company': serializer(company=company), 'errors': errors})
response.status_code = 500
return response
return JsonResponse({'company': serializer(company=company)})
def dispatch(self, request, *args, **kwargs):
try:
response = super(JsonView, self).dispatch(request, *args, **kwargs)
if not isinstance(response, JsonResponse):
response = JsonResponse(response, encoder=ModelJSONEncoder, safe=False)
except ObjectDoesNotExist:
logger.warning('Not Found: %s', request.path,
extra={'status_code': 404, 'request': request})
response = JsonResponse({'error': 'Not Found'})
response.status_code = 404
except PermissionDenied:
logger.warning('Forbidden (Permission denied): %s', request.path,
extra={'status_code': 403, 'request': request})
response = JsonResponse({'error': 'Forbidden'})
response.status_code = 403
except SuspiciousOperation as e:
logger.error(force_text(e),
extra={'status_code': 400, 'request': request})
response = JsonResponse({'error': 'Bad Request'})
response.status_code = 400
except SystemExit:
# Allow sys.exit()
raise
except:
logger.exception('Failed to handle request: %s', request.path,
extra={'status_code': 500, 'request': request})
response = JsonResponse({'error': 'Internal Server Error'})
response.status_code = 500
return response
def status(request): # pylint: disable=unused-argument
"""Status"""
token = request.GET.get("token", "")
if not token or token != settings.STATUS_TOKEN:
raise Http404()
info = {}
check_mapping = {
'REDIS': (get_redis_info, 'redis'),
'ELASTIC_SEARCH': (get_elasticsearch_info, 'elasticsearch'),
'POSTGRES': (get_pg_info, 'postgresql'),
'CELERY': (get_celery_info, 'celery'),
}
for setting, (check_fn, key) in check_mapping.items():
if setting in settings.HEALTH_CHECK:
log.debug('getting: %s', key)
info[key] = check_fn()
log.debug('%s done', key)
code = HTTP_OK
status_all = UP
for key in info:
if info[key]["status"] == DOWN:
code = SERVICE_UNAVAILABLE
status_all = DOWN
break
info["status_all"] = status_all
resp = JsonResponse(info)
resp.status_code = code
return resp
def write_review(req, request_id):
if req.method == 'POST':
try:
data = json.loads(req.body)
except ValueError:
data = req.POST
request = Request.objects.get(id=request_id)
worker_id = request.proposal_set.get(status=Request.ACCEPTED).worker_id
request.status = Request.CLOSED
request.save()
user = req.user
worker = Worker.objects.get(id=worker_id)
rating = data['rating']
type = Review.CUSTOMER_WORKER
message = data['message']
review = Review(user=user, worker=worker, rating=rating, type=type, message=message)
review.save()
return JsonResponse({
'status': 'success',
'message': review.user.username
})
response = JsonResponse({
'status': 'error',
'message': 'Invalid request method'
})
response.status_code = 405
return response
def login(request):
form = LoginForm(request.POST)
message = {}
if request.method == 'POST':
if form.is_valid():
# Autentica o usuário
usuario = authenticate(username=form.cleaned_data.get('username'),
password=form.cleaned_data.get('password'))
# Verifica se o usuário existe
if usuario is not None:
# Verifica se o usuário está ativo
if usuario.is_active:
login_(request, usuario)
message = {'message': 'Login realizado com sucesso !', 'level': 'success'}
else:
message = {'message': u'Seu usuário foi desativo !', 'level': 'danger'}
else:
message = {'message': u'Seu usuário ou senha estão incorretos !', 'level': 'danger'}
else:
response = JsonResponse(form.errors)
response.status_code = 500
return response
return JsonResponse(message)
def json_from_email(request):
email = request.GET.get("email")
#Check for an entry point with the given e-mail (or lack thereof), setting
#entry_point to none if it wasn't found
if email:
domain = email.split("@")[-1]
try:
entry_point = EntryPoint.objects.get(domain=domain)
except EntryPoint.DoesNotExist:
entry_point = None
else:
entry_point = None
#Try to get the default entry point if we don't have one already from the e-mail
if not entry_point:
try:
entry_point = EntryPoint.objects.get(domain="")
except EntryPoint.DoesNotExist:
#Do nothing, entry_point is already None
pass
if entry_point:
page = entry_point.page
data = _json_for_page(request, page)
response = JsonResponse(data)
response["Access-Control-Allow-Origin"] = "*"
return response
#After all that, we still couldn't figure out what to serve.
response = JsonResponse({})
response.status_code = 404
response["Access-Control-Allow-Origin"] = "*"
return response
def post(self, request, *args, **kwargs):
data = {}
post_data = json.loads(request.body) if request.body else {}
form = AuthenticationForm(request, post_data)
if form.is_valid():
user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password'])
else:
user = None
status_code = 401
if user is not None:
if user.is_active:
login(request, user)
status_code = 200
# Redirect to a success page.
else:
data['message'] = 'Disabled Account'
# Return a 'disabled account' error message
status_code = 401
else:
data['message'] = 'Invalid Credentials'
# Return an 'invalid login' error message.
status_code = 401
response = JsonResponse(data)
response.status_code = status_code
return response
def load_menu(request):
try:
fetch_menu()
except:
response = JsonResponse({
'error': 'Unable to load menu'
})
response.status_code = status.HTTP_503_SERVICE_UNAVAILABLE
else:
response = JsonResponse({
'success': 'Menu successfully loaded'
})
response.status_code = status.HTTP_200_OK
# TODO verbose output
return response
def render_json_response(status_code, view_object_name, view_object, msg, url):
r = JsonResponse({
view_object_name: view_object,
'msg': msg,
'url': url
})
r.status_code = status_code
return r
def post(self, request, *args, **kwargs):
"""Override post to first check if any users exist already."""
if User.objects.count() > 0:
response = JsonResponse({'status': 'denied'})
response.status_code = 403
return response
else:
return super().post(request, *args, **kwargs)
def default(request):
"""
in case the url doesn't match the existing
"""
msg = {'message': 'Resource Not found'}
re = JsonResponse(msg)
re.status_code = 404
return re
def post(self, request, *args, **kwargs):
"""Actually run the test."""
if User.objects.count() > 0:
response = JsonResponse({'status': 'denied'})
response.status_code = 403
return response
try:
self.run_test(request, *args, **kwargs)
return JsonResponse({'status': 'success'})
except Exception:
tb = ''.join(traceback.format_exc())
response = JsonResponse({'status': 'failed',
'error': tb, })
response.status_code = 400
return response
def post(request):
"""Identifies a time series group by the name of an AssetSensor.
If the AssetSensor does not yet exist, creates it.
Args:
recipe_instance: (Optional) POST argument with the
recipe_instance pk. Used to retrieve the Brewhouse equipment
associated with the request. Used for some cases when the
equipment has more readily available access to the
recipe_instance rather than the Brewhouse directly.
brewhouse: (Optional): POST argument with the Brewhouse pk. Required
if recipe_instance is not submitted.
name: Name for the AssetSensor to be used in the time series data.
See AssetSensor for more information on naming.
variable_type: Type of AssetSensor to be used (e.g. "value" or
"override"). Defaults to 'value'.
Returns:
JsonResponse with the pk to the sensor as the property "sensor".
Response status is 200 if just returning object and 201 if needed to
create a new AssetSensor.
"""
name = request.data['name']
variable_type = request.data.get('variable_type', 'value')
if 'recipe_instance' in request.data:
recipe_instance_id = request.data['recipe_instance']
recipe_instance = models.RecipeInstance.objects.get(
id=recipe_instance_id)
brewhouse = recipe_instance.brewhouse
else:
brewhouse_id = request.data['brewhouse']
brewhouse = models.Brewhouse.objects.get(id=brewhouse_id)
if not permissions.is_member_of_brewing_company(
request.user, brewhouse.brewery.company):
return HttpResponseForbidden(
'Access not permitted to brewing equipment.')
# See if we can get an existing AssetSensor.
try:
sensor = models.AssetSensor.objects.get(name=name,
brewhouse=brewhouse,
variable_type=variable_type)
status_code = status.HTTP_200_OK
# Otherwise create one for recording data
except ObjectDoesNotExist:
LOGGER.debug('Creating new asset sensor %s for asset %s',
name, brewhouse)
sensor = models.AssetSensor.objects.create(
name=name, brewhouse=brewhouse, variable_type=variable_type)
status_code = status.HTTP_201_CREATED
response = JsonResponse({'sensor': sensor.pk})
response.status_code = status_code
return response
def group_reject_request(request,group,player):
group = get_object_or_404(Group, pk=group)
player = get_object_or_404(Player, pk=player)
request.user.player.reject_request_group(group,player)
response = JsonResponse({
"message" : "%s rejected into group %s" % (player,group.name)
})
response.status_code = 200
return response
def device_request(request):
from django.http import JsonResponse
data = {}
error_code = 0
if request.POST.get('uuid') and request.POST.get('address') and request.POST.get('action'):
device_uuid = request.POST['uuid']
resource_address = request.POST['address']
action = request.POST['action']
if action == 'read' or action == 'write':
if Resource.objects.filter(device__uuid=device_uuid).filter(address=resource_address).count() != 0:
from django.conf import settings
from pika.exceptions import ConnectionClosed
try:
if action == 'read':
DeviceRequest(settings.AMQP_HOST, device_uuid).read(resource_address)
data['status'] = 'success'
data['message'] = 'read request sent'
else:
if request.POST.get('value'):
resource_value = request.POST['value']
DeviceRequest(settings.AMQP_HOST, device_uuid).write(resource_address, resource_value)
data['status'] = 'success'
data['message'] = 'write request sent'
else:
data['status'] = 'error'
data['message'] = 'write action requested without value'
error_code = 400
except ConnectionClosed:
data['status'] = 'error'
data['message'] = 'Unable to connect to the AMQP server'
error_code = 500
else:
data['status'] = 'error'
data['message'] = 'unknown device or resource'
error_code = 400
else:
data['status'] = 'error'
data['message'] = 'unknown action'
error_code = 400
else:
data['status'] = 'error'
data['message'] = 'bad request'
error_code = 400
if error_code != 0:
response = JsonResponse(data)
response.status_code = error_code
return response
else:
return JsonResponse(data)
def upload_img(request):
form = ImageUploadForm(request.POST, request.FILES)
if form.is_valid():
result = form.save()
return JsonResponse({'status': 'successful', 'url': result.img.url})
response = JsonResponse({'error': form.errors})
response.status_code = 400
return response
def post(self, request, *args, **kwargs):
w = self.get_window()
ids = [(i[len('number_'):], request.POST[i]) for i in request.POST if i.startswith('number_')]
seats = [(i[len('seats_'):], request.POST[i].split(',')) for i in request.POST if i.startswith('seats_')]
print_format = request.POST.get('print-format', self.DEFAULT_PF)
discount = request.POST.get('discount', '')
if discount:
discount = Discount.objects.get(id=discount)
data = request.POST.copy()
data['email'] = settings.FROM_EMAIL
form = MPRegisterForm(data,
event=w.event, ids=ids, seats=seats,
client=request.session.get('client', ''))
keys = list(form.fields.keys())
for k in keys:
# email is required
if k == 'email':
continue
# removing not required fields
form.fields.pop(k)
if form.is_valid():
mp = form.save(commit=False)
if discount:
mp.discount = discount
mp.price = mp.get_window_price()
mp.confirm()
for tk in mp.tickets.all():
tk.sold_in_window = True
tk.price = tk.get_window_price()
tk.save()
price = float(data.get('price', 0))
payed = data.get('payed', 0)
if payed:
payed = float(payed)
else:
payed = 0
change = float(data.get('change', 0))
payment = data.get('payment', 'cash')
sale = TicketWindowSale(purchase=mp, window=w, user=request.user,
price=price, payed=payed,
change=change, payment=payment)
sale.save()
url = reverse('window_ticket', kwargs={'ev': mp.ev.slug, 'w': w.slug, 'pf': print_format, 'order': mp.order})
data = {'url': url, 'mp': mp.order_tpv, 'wc': mp.window_code(), 'nt': mp.tickets.count()}
return JsonResponse(data)
data = {"message": _("There was an error, please try again"), "status": "ok"}
resp = JsonResponse(data)
resp.status_code = 400
return resp
def report_build(request):
try:
payload = json.loads(str(request.body, encoding='utf-8'))
build = Build.objects.get(pk=payload['id'])
build.handle_worker_report(payload)
response = JsonResponse({'message': 'Thanks for building it'})
except Build.DoesNotExist:
response = JsonResponse({'error': 'Build not found'})
response.status_code = 404
return response
def api_details(request, rt_id):
try:
m = Movie.objects.get(rt_id=rt_id)
except ObjectDoesNotExist:
r = JsonResponse({
'error': "Movie with id '{}' was not found.".format(rt_id)
})
r.status_code = 404
return r
return JsonResponse(_details(m))
def get(self, request, *args, **kwargs):
try:
threatsList = loadMetaFiles()
threatsList["dir_path"] = metaDirectory
resp = JsonResponse(threatsList)
resp.status_code = 200
return resp
except IOError:
return HttpResponseNotFound("Cannot find directory " + metaDirectory)
except Exception as e:
return HttpResponseServerError(e.message)
def process_exception(self, request, exception):
if type(exception) == AuthAlreadyAssociated:
# this can happen when a user is already logged in via one backend (e.g. facebook)
# and then tries to sign in via another one (e.g. google)
# clients should check the session before trying to log in, but if they don't
# provide a more meaningful error message
response = JsonResponse({'error': unicode(_(
'You are already logged in via another OAuth provider. '
'Sign out first if you want to log in with another account.'))})
response.status_code = 400
return response
def save_photo(request):
'''
Takes a JSON-formatted search result from the Flickr Search API, fetches the
photo in multiple sizes from the Flickr API and saves them.
'''
if not request.user.is_authenticated():
rsp = JsonResponse({'error': 'Login required'})
rsp.status_code = 401
return rsp
search_result = request.POST
download_photo(request.user, search_result)
return JsonResponse({'saved': True})
def proposal(req, request_id):
if req.method == 'POST':
try:
data = json.loads(req.body)
except ValueError:
data = req.POST
if 'message' not in data:
raise MissingArgumentsException('message')
if 'cost' not in data:
raise MissingArgumentsException('cost')
worker = req.worker
request = Request.objects.get(id=request_id)
if Proposal.objects.filter(worker_id=req.worker.id, request_id=request_id).exists():
return JsonResponse({
'status': 'error',
'message': 'You cannot submit multiple bids for one request.',
})
proposal = Proposal(cost=data['cost'], message=data['message'], worker=worker, status=Proposal.OPEN,
request=request)
proposal.save()
return JsonResponse({
'status': 'success',
'message': proposal.worker.user.username,
})
elif req.method == 'DELETE':
proposal = Proposal.objects.filter(worker_id=req.worker.id, request_id=request_id).first()
if proposal.status == Proposal.OPEN:
proposal.delete()
return JsonResponse({
'status': 'success',
'message': proposal.request.subject,
})
else:
response = JsonResponse({
'status': 'error',
'message': 'Only OPEN bids can be cancelled.',
})
response.status_code = 404
return response
return JsonResponse({
'status': 'error',
'message': 'Invalid request method.',
})
def json_from_page(request, slug):
try:
page = Page.objects.get(slug=slug)
except Page.DoesNotExist:
response = JsonResponse({})
response.status_code = 404
response["Access-Control-Allow-Origin"] = "*"
return response
data = _json_for_page(request, page)
response = JsonResponse(data)
response["Access-Control-Allow-Origin"] = "*"
return response
def post(self, request, *args, **kwargs):
"""Actually run the test."""
try:
data = JSONParser().parse(request)
self.run_test(data, *args, **kwargs)
return JsonResponse({'status': 'success'})
except Exception:
tb = ''.join(traceback.format_exc())
response = JsonResponse({
'status': 'failed',
'error': tb,
})
response.status_code = 400
return response
def json_default(request):
try:
page = EntryPoint.objects.get(domain="").page
data = _json_for_page(request, page)
response = JsonResponse(data)
response["Access-Control-Allow-Origin"] = "*"
return response
except EntryPoint.DoesNotExist:
response = JsonResponse({})
response.status_code = 404
response["Access-Control-Allow-Origin"] = "*"
return response
def accept_proposal(request, request_id, proposal_id):
proposal = Proposal.objects.get(id=proposal_id)
request = Request.objects.get(id=request_id)
if proposal.worker.user.id == request.user.id:
response = JsonResponse({
'status': 'error',
'message': 'You cannot bid on your own request',
})
response.status_code = 404
return response
proposal.status = 'ACCEPTED'
request.status = 'ACCEPTED'
proposal.save()
request.save()
return JsonResponse({'status': 'success'})
def post(self, request, *args, **kwargs):
post_data = json.loads(request.body)
form = UserCreationForm(post_data)
status_code = 400
data = {}
if form.is_valid():
User.objects.create_user(form.cleaned_data['username'], password=form.cleaned_data['password1'])
user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password1'])
login(request, user)
status_code = 202
else:
data['errors'] = form.errors
response = JsonResponse(data)
response.status_code = status_code
return response
def confirm_token(request):
if request.method == "POST":
request_params = request.POST.dict()
token = int(request_params["text"])
username = request_params["phone"]
user = Ureporter.objects.get(user__username=username)
data = None
if user.token == token:
data = {"token_ok": "true"}
else:
data = {"token_ok": "false"}
response = JsonResponse(data)
response.status_code = 200
return response
def exp_action_replay(request, experiment_id):
try:
experimentJudge = ExperimentJudge.objects.get(experiment__id=experiment_id, user__id=request.user.profile.id)
except ExperimentJudge.DoesNotExist:
data = {"message": "You are not authorized to participate in this experiment."}
response = JsonResponse(data=data)
response.status_code = 401
return response
else:
experiment = experimentJudge.experiment
if request.method == 'POST':
try:
candidate_id = int(request.POST.get('candidate_id', -1))
try:
candidate = CandidatePair.objects.get(pk=candidate_id)
except CandidatePair.DoesNotExist:
data = {"message": "Invalid candidate pair id."}
response = JsonResponse(data=data)
response.status_code = 401
return response
except TypeError:
data = {"message": "Invalid candidate pair id."}
response = JsonResponse(data=data)
response.status_code = 401
return response
try:
time_spent = int(request.POST.get('time_spent', -1))
except TypeError:
data = {"message": "Invalid time spent information"}
response = JsonResponse(data=data)
response.status_code = 401
return response
try:
next_exp_details = ExperimentDetail.objects.filter(candidate_pair__id__gt =candidate_id,
experiment=experiment,
visited=True,
source_type=ExperimentDetail.PRECISION_FRAMEWORK_SOURCE_TYPE).order_by('candidate_pair')
if next_exp_details:
block1 = next_exp_details[0].candidate_pair.candidate_one
block2 = next_exp_details[0].candidate_pair.candidate_two
data = {"block_one": block1.getSourceCode().strip(),
"block_two": block2.getSourceCode().strip(),
"exp_id": experiment_id,
"candidate_id": next_exp_details[0].candidate_pair.id,
"has_next": next_exp_details.count() > 1,
"left": next_exp_details.count(),
"clone_type": next_exp_details[0].clone_type,
"resolution_method": next_exp_details[0].resolution_method,
}
response = JsonResponse(data=data)
response.status_code = 200
return response
else:
data = getReportForExperimentForUser(request.user.profile, experiment)
response = JsonResponse(data=data)
response.status_code = 200
return response
except ExperimentDetail.DoesNotExist:
data = {
"message": "Invalid request. Couldn't find the requested candidate pair",
"redirect_url": "send some url"} # TODO:send redirect url
response = JsonResponse(data=data)
response.status_code = 401
return response
def pointsEnquiry(request):
if request.method == 'POST':
success = True
missing_field_name = ''
third_party_sh_name = ''
request_mode = ''
params = {}
third_userid = ''
userid = ''
account_name = ''
token = ''
post_balance = 0
error_msg = ""
received_json_data = json.loads(request.body)
if '3rd_party_sh_name' in received_json_data:
third_party_sh_name = received_json_data['3rd_party_sh_name']
else:
missing_field_name += '3rd_party_sh_name, '
success = False
if 'request_mode' in received_json_data:
request_mode = received_json_data['request_mode']
else:
missing_field_name += 'request_mode, '
success = False
if 'params' in received_json_data:
params = received_json_data['params']
else:
missing_field_name += 'parameters, '
success = False
if '3rd_userid' in params:
third_userid = params['3rd_userid']
else:
missing_field_name += '3rd_userid, '
success = False
if 'userid' in params:
userid = params['userid']
else:
missing_field_name += 'userid, '
success = False
if 'account_name' in params:
account_name = params['account_name']
if 'token' in params:
token = params['token']
else:
missing_field_name += 'token, '
success = False
if success == False:
response = JsonResponse({
"success":
'false',
"error_msg":
missing_field_name[0:len(missing_field_name) - 2] +
" are missing.",
"points":
"null",
"act_membership_num":
"null",
"expiration_time":
"",
"request_mode":
request_mode
})
response.status_code = 200
return response
if checkIfTokenExist(token):
balance = checkIfRecordExistAndBalance(third_party_sh_name,
third_userid, account_name)
if not balance == 'no_exist':
error_msg = ''
post_balance = balance
success = 'true'
status_code = 200
expiration_time = datetime.datetime.now() + datetime.timedelta(
30)
else:
error_msg = "not found the record according to these parameters"
post_balance = 'null'
success = 'false'
status_code = 404
expiration_time = 'null'
response = JsonResponse({
"success": success,
"error_msg": error_msg,
"points": post_balance,
"act_membership_num": "null",
"expiration_time": expiration_time,
"request_mode": request_mode
})
response.status_code = status_code
return response
else:
response = JsonResponse({
"success": 'false',
"error_msg": "token is not valid",
"points": "null",
"act_membership_num": "null",
"expiration_time": "null",
"request_mode": request_mode
})
response.status_code = 404
return response
response = JsonResponse({
"success": 'false',
"error_msg": "no valid parameters",
"points": "null",
"act_membership_num": "null",
"expiration_time": "null",
"request_mode": "null"
})
response.status_code = 404
return response
def add_city(request):
context = dict()
try:
context['message'] = request.session['message']
del request.session['message']
except:
pass
try:
user = Account.objects.get(pk=request.session['user'])
context['user'] = user
except:
return redirect(reverse(accountsviews.index))
else:
pass
if request.is_ajax():
try:
city_exists = bool(City.objects.get(name=request.POST['add']))
except:
city_exists = False
if not city_exists:
return JsonResponse({'message': 'success'})
else:
response = JsonResponse({"message": "error"})
response.status_code = 403 # To announce that the user isn't allowed to publish
return response
if request.method == 'POST':
city = str(request.POST['add'])
try:
city_picture = get_wiki_image(str(city) + ' city')
description = wikipedia.summary(str(city) + ' city')
except:
pass
try:
city_page = wikipedia.page(str(city) + ' city')
url = city_page.url
except:
pass
try:
location = geolocator.geocode(str(city))
city_latitude = location.latitude
city_longtitude = location.longitude
except:
city_latitude = None
city_longtitude = None
try:
city_request = RequestToCreateCity(city_name=city,
wiki_link=url,
requesting_user=user,
description=description,
picture=city_picture,
latitude=city_latitude,
longitude=city_longtitude)
city_request.save()
request_failed = False
except:
try:
city_request = RequestToCreateCity(city_name=city,
requesting_user=user,
description=description,
picture=city_picture,
latitude=city_latitude,
longitude=city_longtitude)
city_request.save()
request_failed = False
except:
request_failed = True
#city_slug = slugify(city)
#city = City(name = city, description = description, picture = city_picture, slug = city_slug)
#city.save()
if request_failed:
request.session['message'] = "Sorry, we couldn't find this city"
return redirect(reverse(views.add_city))
request.session['message'] = "City was successfuly added."
return redirect(reverse(views.add_city))
return render(request, 'app/city/add_city.html', context)
def error_500(request):
message = "An error occurred, it's on us"
response = JsonResponse(data={'message': message, 'status_code': 500})
response.status_code = 500
return response
def handler500(request):
response = JsonResponse({'msg': 'internal server error'})
response.status_code = 500
return response
def pointsDeduct(request):
if request.method == 'POST':
success = True
missing_field_name = ''
third_party_sh_name = ''
request_mode = ''
params = {}
third_userid = ''
userid = ''
account_name = ''
deduct_amount = ''
transaction_type = ''
linked_trans_id = ''
token = ''
post_balance = 0
error_msg = ""
deduct_time = ""
received_json_data = json.loads(request.body)
if '3rd_party_sh_name' in received_json_data:
third_party_sh_name = received_json_data['3rd_party_sh_name']
else:
missing_field_name += '3rd_party_sh_name, '
success = False
if 'request_mode' in received_json_data:
request_mode = received_json_data['request_mode']
else:
missing_field_name += 'request_mode, '
success = False
if 'params' in received_json_data:
params = received_json_data['params']
else:
missing_field_name += 'parameters, '
success = False
if '3rd_userid' in params:
third_userid = params['3rd_userid']
else:
missing_field_name += '3rd_userid, '
success = False
if 'userid' in params:
userid = params['userid']
else:
missing_field_name += 'userid, '
success = False
if 'account_name' in params:
account_name = params['account_name']
if 'deduct_amount' in params:
deduct_amount = params['deduct_amount']
else:
missing_field_name += 'deduct_amount, '
success = False
if 'transaction_type' in params:
transaction_type = params['transaction_type']
else:
missing_field_name += 'transaction_type, '
success = False
if 'linked_trans_id' in params:
linked_trans_id = params['linked_trans_id']
if 'token' in params:
token = params['token']
else:
missing_field_name += 'token, '
success = False
if success == False:
response = JsonResponse({
"success":
'false',
"error_msg":
missing_field_name[0:len(missing_field_name) - 2] +
" are missing.",
"pre_point_balance":
"null",
"post_point_balance":
"null",
"add_time":
"null",
"3rd_trans_num":
"",
"request_mode":
request_mode
})
response.status_code = 200
return response
if checkIfTokenExist(token):
id = checkIfRecordExist(third_party_sh_name, third_userid,
account_name)
if not id == False:
post_balance = deductBalance(id, deduct_amount)
if post_balance == '':
error_msg = "insufficient points balance for deduction operation"
post_balance = 'null'
deduct_time = 'null'
else:
deduct_time = datetime.datetime.now()
else:
error_msg = "not found the record according to these parameters"
post_balance = 'null'
deduct_time = 'null'
response = JsonResponse({
"success": 'true',
"error_msg": error_msg,
"pre_point_balance": deduct_amount,
"post_point_balance": post_balance,
"deduct_time": deduct_time,
"3rd_trans_num": "",
"request_mode": request_mode
})
response.status_code = 404
return response
else:
response = JsonResponse({
"success": 'false',
"error_msg": "token is not valid",
"pre_point_balance": "null",
"post_point_balance": "null",
"add_time": "null",
"3rd_trans_num": "",
"request_mode": request_mode
})
response.status_code = 404
return response
response = JsonResponse({
"success": 'false',
"error_msg": "no valid parameters",
"pre_point_balance": "null",
"post_point_balance": "null",
"add_time": "null",
"3rd_trans_num": "",
"request_mode": "null"
})
response.status_code = 404
return response
def form_invalid(self, form):
response = JsonResponse({
'image': 'Image missing or broken.',
})
response.status_code = 400
return response
def pointsAdd(request):
if request.method == 'POST':
success = True
missing_field_name = ''
third_party_sh_name = ''
params = {}
request_mode = ''
third_userid = ''
userid = ''
account_name = ''
add_amount = ''
transaction_type = ''
linked_trans_id = ''
token = ''
post_balance = 0
received_json_data = json.loads(request.body)
if '3rd_party_sh_name' in received_json_data:
third_party_sh_name = received_json_data['3rd_party_sh_name']
else:
missing_field_name += '3rd_party_sh_name, '
success = False
if 'request_mode' in received_json_data:
request_mode = received_json_data['request_mode']
else:
missing_field_name += 'request_mode, '
success = False
if 'params' in received_json_data:
params = received_json_data['params']
else:
missing_field_name += 'parameters, '
success = False
if '3rd_userid' in params:
third_userid = params['3rd_userid']
else:
missing_field_name += '3rd_userid, '
success = False
if 'userid' in params:
userid = params['userid']
else:
missing_field_name += 'userid, '
success = False
if 'account_name' in params:
account_name = params['account_name']
if 'add_amount' in params:
add_amount = params['add_amount']
else:
missing_field_name += 'add_amount, '
success = False
if 'transaction_type' in params:
transaction_type = params['transaction_type']
else:
missing_field_name += 'transaction_type, '
success = False
if 'linked_trans_id' in params:
linked_trans_id = params['linked_trans_id']
if 'token' in params:
token = params['token']
else:
missing_field_name += 'token, '
success = False
if success == False:
response = JsonResponse({
"success":
'false',
"error_msg":
missing_field_name[0:len(missing_field_name) - 2] +
" are missing.",
"pre_point_balance":
"null",
"post_point_balance":
"null",
"add_time":
"null",
"3rd_trans_num":
"",
"request_mode":
request_mode
})
response.status_code = 200
return response
if checkIfTokenExist(token):
id = checkIfRecordExist(third_party_sh_name, third_userid,
account_name)
if not id == False:
post_balance = sumBalance(id, add_amount)
else:
insertNewPoints(third_party_sh_name, third_userid,
request_mode, userid, account_name, add_amount,
transaction_type, linked_trans_id, token)
post_balance = int(add_amount)
response = JsonResponse({
"success": 'true',
"error_msg": "",
"pre_point_balance": add_amount,
"post_point_balance": post_balance,
"add_time": datetime.datetime.now(),
"3rd_trans_num": "",
"request_mode": request_mode
})
response.status_code = 404
return response
else:
response = JsonResponse({
"success": 'false',
"error_msg": "token is not valid",
"pre_point_balance": "null",
"post_point_balance": "null",
"add_time": "null",
"3rd_trans_num": "",
"request_mode": request_mode
})
response.status_code = 404
return response
response = JsonResponse({
"success": 'false',
"error_msg": "no valid parameters",
"pre_point_balance": "null",
"post_point_balance": "null",
"add_time": "null",
"3rd_trans_num": "",
"request_mode": "null"
})
response.status_code = 404
return response
def deleteComment(request, pk):
message = '잘못된 접근'
response = JsonResponse({'status': 'false', 'message': message})
response.status_code = 500
return response
def error_404(request, exception):
message = "The endpoint is not found"
response = JsonResponse(data={'message': message, 'status_code': 404})
response.status_code = 404
return response
def create_json_response_with_location(data, id, path):
json_response = JsonResponse(data)
json_response['Location'] = path + str(id)
json_response.status_code = 201
return json_response
def return_error_msg(msg, status=400):
resp = JsonResponse({"success": False, "msg": msg})
resp.status_code = status
return resp
def smps(request):
#Design parameters received flag and recommended components updated flags set to false on page load.
design_param_updated = False
design_comp_updated = False
if request.method == "GET":
#####################################
#Generic website parameters
#####################################
landing_page_url = "/"
design_center_url = "design-center"
header_title = "Design Electronics"
context.update({
"landing_page_url": landing_page_url,
"design_center_url": design_center_url,
'header_title': header_title
})
#####################################
#Model Parameters
#####################################
#Create list of all models in database.
models = []
#Query DC DC converters.
dc_dc_query = DCDC.objects.all()
models.append(dc_dc_query)
#Assumes that DC DC converter model has at least one entry.
if len(dc_dc_query) != 0:
power_types = dc_dc_query[0].POWER_ELECTRONIC_CIRCUIT_TYPES
smps_types = dc_dc_query[0].SMPS_TYPES
dc_dc_types = dc_dc_query[0].DCDC_TYPES
dc_dc_list = [o for o in dc_dc_query]
#####################################
#Current Circuit Analysis Update #
#####################################
default_circuit_url = "ccm-buck-converter"
analyzed_circuit_url = request.path.rsplit("/", 1)[1]
#Handle design-center page default design shown.
if analyzed_circuit_url == design_center_url:
analyzed_circuit_url = default_circuit_url
analyzed_circuit_object = None
circuit_found = False
#Loop through all models and select a model object to be displayed on webpage.
for circuit_type in models:
filtered_circuit = circuit_type.filter(url=analyzed_circuit_url)
if len(filtered_circuit) == 1:
circuit_found = True
analyzed_circuit_object = filtered_circuit[0]
break
#####################################
#Generate the sidebar. #
#####################################
generate_sidebar(power_types, smps_types, dc_dc_types, dc_dc_list,
context)
#Render 404 page if circuit url was not found.
if not circuit_found:
return render(request, '404.html', context=context)
context.update({'analyzed_circuit_object': analyzed_circuit_object})
#####################################
#Generate the design parameters and #
#selected components forms. #
#####################################
design_parameters_circuit_object = analyzed_circuit_object.design_params.all(
)
selected_components_circuit_object = analyzed_circuit_object.selected_components.all(
)
context.update({
'design_parameters_circuit_object':
design_parameters_circuit_object
})
context.update({
'selected_components_circuit_object':
selected_components_circuit_object
})
design_param_form = DesignParamForm(None,
design_parameters_circuit_object)
design_comp_form = DesignCompForm(None,
selected_components_circuit_object)
context.update({
'design_param_form': design_param_form,
'design_comp_form': design_comp_form
})
#GET method, populate recommended components section with default text.
generate_rec_dcdc_components(analyzed_circuit_object, context, None)
analyze_dcdc_converter(analyzed_circuit_object, context, None)
#Initial flags for receiving updated forms are set to false on initial page load.
context.update({'design_comp_updated': False})
context.update({'design_param_updated': False})
#Populate bode plots with initial load of data.
generate_bode(analyzed_circuit_object, context, None, 5000)
#####################################
#Generate the recommended components#
#or analyze the circuit.
#####################################
elif request.method == "POST":
#Generate selected components.
if "submitdesignparams" in request.POST:
design_param_form = DesignParamForm(
request.POST, context["design_parameters_circuit_object"])
circuit_obj = context["analyzed_circuit_object"]
#Validate data (and generate self.cleaned_data)
#prior to custom clean so that it is available
#to custom cleaning method.
design_param_form.is_valid()
#Custom clean design_param_form given type of power electronic circuit to be analyzed.
design_param_form.custom_clean(circuit_obj.pe_circuit_type,
circuit_obj.smps_circuit_type,
circuit_obj.dcdc_type,
circuit_obj.name)
if len(design_param_form.errors) == 0:
generate_rec_dcdc_components(
context["analyzed_circuit_object"], context,
design_param_form.cleaned_data)
#Update design parameter form
context.update({'design_param_form': design_param_form})
context.update({'design_param_updated': True})
else:
#The entered data was not valid, return errors.
context.update({'design_param_updated': False})
response = JsonResponse({"errors": design_param_form.errors})
response.status_code = 403
return response
return JsonResponse(context["rec_dcdc_comps"], safe=False)
#Analyze the circuit.
elif "submitcompvalues" in request.POST:
#Checks if the first recommended component has been populated
#given valid design parameters.
if context["design_param_updated"]:
design_comp_form = DesignCompForm(
request.POST,
context["selected_components_circuit_object"])
circuit_obj = context["analyzed_circuit_object"]
#Validate data (and generate self.cleaned_data)
#prior to custom clean so that it is available
#to custom cleaning method.
design_comp_form.is_valid()
#Custom clean design_param_form given type of power electronic circuit to be analyzed.
design_comp_form.custom_clean(circuit_obj.pe_circuit_type,
circuit_obj.smps_circuit_type,
circuit_obj.dcdc_type,
circuit_obj.name)
if design_comp_form.is_valid():
design_param_form = context["design_param_form"]
success = analyze_dcdc_converter(
context["analyzed_circuit_object"], context,
dict(
chain(design_comp_form.cleaned_data.items(),
design_param_form.cleaned_data.items())))
if success:
context.update({'design_comp_form': design_comp_form})
context.update({'design_comp_updated': True})
else:
context.update({'design_comp_updated': False})
param_error = {}
param_error["DC/DC Analysis"] = [
"Design components selected do not result in a feasible converter."
+
" Possible issues could be due to the losses in the parasitic resistances, reduce values and resubmit. "
]
response = JsonResponse({"errors": param_error})
response.status_code = 403
return response
else:
#The entered data was not valid.
context.update({'design_comp_updated': False})
response = JsonResponse(
{"errors": design_comp_form.errors})
response.status_code = 403
return response
return JsonResponse(context["analyzed_equations"], safe=False)
else:
#Design parameters were not received, must enter design parameters
#before being able to analyze the converter.
context.update({'design_comp_updated': False})
design_comp_form = DesignCompForm(
request.POST,
context["selected_components_circuit_object"])
#Get a field to associate an error with. NEED TO UPDATE, THIS IS TERRIBLE.
for k, v in design_comp_form.fields.items():
field = k
break
design_comp_form.add_error(
field, "Design parameter form entered was not valid." +
" Correct form and resubmit prior to submitting component values."
)
response = JsonResponse({"errors": design_comp_form.errors})
response.status_code = 403
return response
#Generate open loop bode plots
elif "generateopenplots" in request.POST:
#Both design parameter form and design component form must be filled out to
#generate open loop plots.
if context["design_param_updated"] and context[
"design_comp_updated"]:
design_comp_form = context["design_comp_form"]
design_param_form = context["design_param_form"]
cleaned_data = dict(
chain(design_comp_form.cleaned_data.items(),
design_param_form.cleaned_data.items(),
[("D", context["duty_cycle"])]))
updated_data = generate_bode(
context["analyzed_circuit_object"], context, cleaned_data,
5000)
return JsonResponse(updated_data, safe=False)
else:
if not (context["design_param_updated"]):
#Design parameters were not received, must enter design parameters
#before being able to analyze the converter.
param_error = {}
param_error["Design parameter form"] = (
"Design parameter form entered was not valid." +
" Correct form and resubmit prior to generating open loop bode plots."
)
response = JsonResponse({"errors": param_error})
elif not (context["design_comp_updated"]):
#Design components were not received, must enter design components
#before being able to analyze the converter.
param_error = {}
param_error["Design component form"] = [
"Design component form entered was not valid." +
" Correct form and resubmit prior to generating open loop bode plots."
]
response = JsonResponse({"errors": param_error})
response.status_code = 403
return response
return render(request, 'smps.html', context=context)
def ShowAllUser(request):
'''
描述：处理管理员获取全部用户请求
参数：request
返回：response
'''
Success = True
Return = {}
Reason = ""
TheSession = ""
TheResult = {}
TheErrorInfo = {}
ErrorID = Constants.UNDEFINED_NUMBER
TheLastSeenID = Constants.UNDEFINED_NUMBER
TheMostNumber = Constants.UNDEFINED_NUMBER
if Success:
try:
TheSession = request.GET.get("session")
if TheSession == 'UNDEFINED':
Success = False
Reason = "请求参数不合法！"
ErrorID = Constants.ERROR_CODE_INVALID_PARAMETER
try:
TheLastSeenID = int(request.GET.get("lastSeenId"))
except:
TheLastSeenID = Constants.UNDEFINED_NUMBER
try:
TheMostNumber = int(request.GET.get("most"))
if TheMostNumber <= 0:
Success = False
Reason = "请求参数不合法！"
ErrorID = Constants.ERROR_CODE_INVALID_PARAMETER
except:
TheMostNumber = Constants.UNDEFINED_NUMBER
except:
Success = False
Reason = "请求参数不合法！"
ErrorID = Constants.ERROR_CODE_INVALID_PARAMETER
if Success:
try:
if AdminManager.JudgeWhetherAdminLogin(TheSession) != True:
Success = False
Reason = "管理员未登录！"
ErrorID = Constants.ERROR_CODE_LOGIN_ERROR
except:
Success = False
Reason = "管理员未登录！"
ErrorID = Constants.ERROR_CODE_LOGIN_ERROR
if Success:
try:
TheResult, TheErrorInfo = AdminManager.ShowAllUsers(TheLastSeenID, TheMostNumber)
if TheResult == {}:
Success = False
Reason = TheErrorInfo["reason"]
ErrorID = TheErrorInfo["code"]
except:
Success = False
Reason = "查询全部用户失败！"
ErrorID = Constants.ERROR_CODE_UNKNOWN
if Success:
Return = TheResult
else:
Return["errid"] = ErrorID
Return["errmsg"] = Reason
Response = JsonResponse(Return)
if Success == True:
Response.status_code = 200
else:
Response.status_code = 400
return Response
def ajax_bad_request(error_msg):
response = JsonResponse({'err': error_msg})
response.status_code = http.HTTPStatus.BAD_REQUEST
return response
def user_login(request):
def get_user_login_success_response(user):
expires = timezone.now() + timezone.timedelta(days=7)
jwt_payload = get_user_private_dict(user.account)
jwt_payload['expires'] = expires.strftime("%Y-%m-%d %H:%M:%S")
jwt_token = jwt.encode(jwt_payload, PRIVATE_KEY,
algorithm="RS256").decode("utf-8")
response = JsonResponse(
get_json_dict(data={}, err_code=0, message="Login success"))
response.set_cookie('jwt', jwt_token, max_age=604800)
return response
received_data = json.loads(request.body.decode('utf-8'))
username = received_data['username']
password = received_data['password']
json_dict = get_json_dict(data={})
user = authenticate(username=username, password=password)
if user: # user auth success
if user.is_active: # user have confirmed its email, login success
response = get_user_login_success_response(user)
return response
else: # user have not confirmed its email
json_dict['err_code'] = -1
json_dict['message'] = "请验证您的学号邮箱"
response = JsonResponse(json_dict)
response.status_code = 403
return response
else: # user auth fail
try:
User.objects.get(username=username)
except ObjectDoesNotExist as e: # user object does not exist
if (re.match("\d{3,11}", username)
): # username is the form of a student/staff account
nickname = check_fdu_auth(
username, password
) # check username and password via mail.fudan.edu.cn
if nickname != None: # check success, create user
user = User(username=username)
user.set_password(password)
user.is_active = True
user.save()
account = Account(user=user)
account.nickname = nickname
account.save()
user_icon_response = requests.get(
"https://www.gravatar.com/avatar/{0}?s=256&d=identicon&r=PG"
.format(user.username))
account.icon.save(name='default_icon',
content=ContentFile(
user_icon_response.content))
return get_user_login_success_response(user)
# user does not exists
json_dict['err_code'] = -1
json_dict['message'] = "用户不存在"
response = JsonResponse(json_dict)
response.status_code = 403
return response
else: # user exists, password is incorrect
json_dict['err_code'] = -1
json_dict['message'] = "密码错误"
response = JsonResponse(json_dict)
response.status_code = 403
return response
def not_found(request):
"""Not found view"""
response = JsonResponse(data={'detail': 'not found.'})
response.status_code = status.HTTP_404_NOT_FOUND
return response
def send_json(message, status_code, data={}):
response = JsonResponse({'data': data, 'message': message})
response.status_code = status_code
return response
def post(self, request, *args, **kwargs):
if request.is_ajax():
usuario = Usuario.objects.filter(
id=request.POST.get('usuario')).first()
turismo = Turismo.objects.filter(
id=request.POST.get('turismo')).first()
fecha_inicial = request.POST.get('fecha1')
fecha_final = request.POST.get('fecha2')
fecha_actual = datetime.today()
if fecha_inicial and fecha_final:
#datetime.strptime(fecha_inicial, '%Y-%m-%d') -> permite transformar un string a date
fecha_inicial_a_date = datetime.strptime(
fecha_inicial, '%Y-%m-%d')
fecha_final_a_date = datetime.strptime(fecha_final, '%Y-%m-%d')
if fecha_inicial_a_date > fecha_actual and fecha_final_a_date > fecha_actual and fecha_final_a_date > fecha_inicial_a_date or fecha_final_a_date == fecha_inicial_a_date:
if fecha_final_a_date == fecha_inicial_a_date:
if fecha_inicial_a_date > fecha_actual and fecha_final_a_date > fecha_actual:
nueva_reserva = self.model(
usuario=usuario,
turismo=turismo,
fecha_inicial=fecha_inicial,
fecha_final=fecha_final)
nueva_reserva.save()
mensaje = f'{self.model.__name__} registrado correctamente!'
error = 'No hay error!'
response = JsonResponse({
'mensaje': mensaje,
'error': error,
'url': self.success_url
})
response.status_code = 201
return response
# septimo error else
elif fecha_inicial_a_date < fecha_actual:
mensaje = septimo_error_else
error = 'necesita rellenar el campo'
response = JsonResponse({
'mensaje': mensaje,
'error': error
})
response.status_code = 400
return response
# octavo error else
elif fecha_final_a_date < fecha_actual:
mensaje = octavo_error_else
error = 'necesita rellenar el campo'
response = JsonResponse({
'mensaje': mensaje,
'error': error
})
response.status_code = 400
return response
else:
nueva_reserva = self.model(usuario=usuario,
turismo=turismo,
fecha_inicial=fecha_inicial,
fecha_final=fecha_final)
nueva_reserva.save()
mensaje = f'{self.model.__name__} registrado correctamente!'
error = 'No hay error!'
response = JsonResponse({
'mensaje': mensaje,
'error': error,
'url': self.success_url
})
response.status_code = 201
return response
# cuarto error else
elif fecha_inicial_a_date < fecha_actual:
mensaje = cuarto_error_else
error = 'necesita rellenar el campo'
response = JsonResponse({
'mensaje': mensaje,
'error': error
})
response.status_code = 400
return response
# quinto error else
elif fecha_final_a_date < fecha_actual:
mensaje = quinto_error_else
error = 'necesita rellenar el campo'
response = JsonResponse({
'mensaje': mensaje,
'error': error
})
response.status_code = 400
return response
# sexto error else
elif fecha_final_a_date < fecha_inicial_a_date:
mensaje = sexto_error_else
error = 'necesita rellenar el campo'
response = JsonResponse({
'mensaje': mensaje,
'error': error
})
response.status_code = 400
return response
# primer error else
elif not fecha_inicial and not fecha_final:
mensaje = primer_error_else
error = 'necesita rellenar el campo'
response = JsonResponse({'mensaje': mensaje, 'error': error})
response.status_code = 400
return response
# segundo error else
elif not fecha_inicial:
mensaje = segundo_error_else
error = 'necesita rellenar el campo'
response = JsonResponse({'mensaje': mensaje, 'error': error})
response.status_code = 400
return response
# tercer error else
elif not fecha_final:
mensaje = tercer_error_else
error = 'necesita rellenar el campo'
response = JsonResponse({'mensaje': mensaje, 'error': error})
response.status_code = 400
return response
return redirect('templates_home:listado_turismos_disponibles')
def create_response(msg='success', status_code=200, data={}):
response = JsonResponse({'message': msg, 'data': data})
response.status_code = status_code
return response
def ChangeActivityStatus(request):
'''
描述：修改单一活动状态
参数：request
返回：response
'''
Success = True
Return = {}
Reason = ""
TheSession = ""
TheResult = {}
TheErrorInfo = {}
TheInfo = {}
ErrorID = Constants.UNDEFINED_NUMBER
if Success:
try:
TheSession = request.GET.get("session")
TheInfo = json.loads(request.body)
if TheSession == 'UNDEFINED':
Success = False
Reason = "请求参数不合法！"
ErrorID = Constants.ERROR_CODE_INVALID_PARAMETER
except:
Success = False
Reason = "请求参数不合法！"
ErrorID = Constants.ERROR_CODE_INVALID_PARAMETER
if Success:
try:
if AdminManager.JudgeWhetherAdminLogin(TheSession) != True:
Success = False
Reason = "管理员未登录！"
ErrorID = Constants.ERROR_CODE_LOGIN_ERROR
except:
Success = False
Reason = "管理员未登录！"
ErrorID = Constants.ERROR_CODE_LOGIN_ERROR
if Success:
try:
TheResult = AdminManager.ChangeActivityStatus(TheInfo)
if TheResult["result"] != "success":
Success = False
Reason = TheResult["reason"]
ErrorID = TheResult["code"]
except:
Success = False
Reason = "修改活动状态失败！"
ErrorID = Constants.ERROR_CODE_UNKNOWN
if Success:
Return["result"] = "success"
else:
Return["errid"] = ErrorID
Return["errmsg"] = Reason
Response = JsonResponse(Return)
if Success == True:
Response.status_code = 200
else:
Response.status_code = 400
#发送消息
if Success and "sendMessage" in TheResult:
TimeManager.SendTimedMessageActivity(TheInfo["id"], TheResult["sendMessage"])
if TheResult["sendMessage"] == Constants.MESSAGE_TYPE_ACTIVITY_FORBIDDEN:
print("send forbid")
elif TheResult["sendMessage"] == Constants.MESSAGE_TYPE_AUDIT_PASS:
print("send audit pass")
elif TheResult["sendMessage"] == Constants.MESSAGE_TYPE_AUDIT_FAIL:
print("send audit fail")
return Response
def AjaxSearchCustomerMainAddress(request):
is_error = False
error_message = ""
customer_main_address_list = []
customer_zone = request.POST.get('customer_zone')
sql = "select cus_id, cus_name_th, cus_add1_th, cus_add2_th, cus_subdist_th, cus_name_en, cus_add1_en, cus_add2_en, cus_subdist_en, cus_zip, cus_tel, "
sql += "cus_fax, cus_email, cus_active, con_fname_th, con_lname_th, con_position_th, con_fname_en, con_lname_en, con_position_en, dist_th, dist_en, city_en, city_th, dept_en "
sql += "from EX_MAIN EX_MAIN where cus_active = 1 "
if customer_zone != "":
sql += "and cus_zone=" + str(customer_zone) + ";"
else:
sql += ";"
print("SQL = ", sql)
try:
with connection.cursor() as cursor:
cursor.execute(sql)
customer_main_address_obj = cursor.fetchall()
except db.OperationalError as e:
is_error = True
error_message = "Error message: " + str(e)
except db.Error as e:
is_error = True
error_message = "Error message: " + str(e)
finally:
cursor.close()
if customer_main_address_obj is not None:
if len(customer_main_address_obj) > 0:
for row in customer_main_address_obj:
record = {
"cus_id": row[0],
"cus_name_th": row[1],
"cus_add1_th": row[2],
"cus_add2_th": row[3],
"cus_subdist_th": row[4],
"dist_th": row[20],
"city_th": row[23],
"cus_name_en": row[5],
"cus_add1_en": row[6],
"cus_add2_en": row[7],
"cus_subdist_en": row[8],
"dist_en": row[21],
"city_en": row[22],
"cus_zip": row[9],
"cus_tel": row[10],
"cus_fax": row[11],
"cus_zone": row[24],
"con_fname_th": row[14],
"con_lname_th": row[15],
"con_position_th": row[16],
"con_fname_en": row[17],
"con_lname_en": row[18],
"con_position_en": row[19],
"cus_email": row[12],
}
customer_main_address_list.append(record)
else:
is_error = True
else:
is_error = True
response = JsonResponse(
data={
"is_error": False,
"error_message": error_message,
"customer_main_address_list": list(customer_main_address_list),
})
response.status_code = 200
return response
def handler404(request):
response = JsonResponse({'msg': 'not found'})
response.status_code = 404
return response
def make_response(data, status_code):
response = JsonResponse(data)
response.status_code = status_code
return response
def map_current_data(request):
"""
! Used only by administrator.
Loading all files from path to database.
{path} = "TowerDefense\\Packages"
Method, that updates game files.
url: /submit-update
:param request: GET
ver = version number : positive integer
:return:
{"update": "ok"}, status code 200
"""
try:
game_build = GameBuild.objects.get(name="game")
except Exception:
GameBuild.objects.create(version=0)
game_build = GameBuild.objects.get(name="game")
version = int(round(time.time()))
print("Current versions {}".format(version))
game_build.version = version
game_build.save()
graphic_files = []
sound_files = []
level_files = []
turret_files = []
enemy_files = []
# List all files
for root, dirs, paths in os.walk(os.getcwd() + os.path.sep + "data"):
for path in paths:
file_path: str = os.path.join(root, path).replace("\\", "/")
file_path = "." + re.search(r".+(/data.+)", file_path).group(1)
if "sprites" in root.lower():
graphic_files.append(file_path)
elif "sounds" in root.lower():
sound_files.append(file_path)
elif "levels" in root.lower():
level_files.append(file_path)
elif "turrets" in root.lower():
turret_files.append(file_path)
elif "enemies" in root.lower():
enemy_files.append(file_path)
def update_resource_files(file_list: list, db_objects):
for path in file_list:
resource_name: str = path.split("/")[-1]
resource_exists = False
for db_object in db_objects.all():
if db_object.path == path and db_object.name == resource_name:
resource_exists = True
break
if not resource_exists:
db_object, _ = db_objects.update_or_create(name=resource_name,
path=path)
db_object.version = version
db_object.save()
# noinspection PyTypeChecker
update_resource_files(graphic_files, Graphic.objects)
# noinspection PyTypeChecker
update_resource_files(sound_files, Sound.objects)
def update_json_documents(file_list: list, db_objects):
for path in file_list:
with open(path, 'r') as file:
resource_name: str = json.loads(file.read())['name']
resource_exists = False
for db_object in db_objects.all():
if db_object.path == path and db_object.name != resource_name:
resource_exists = True
break
if not resource_exists:
db_object, _ = db_objects.update_or_create(name=resource_name,
path=path)
db_object.version = version
db_object.save()
# noinspection PyTypeChecker
update_json_documents(level_files, Level.objects)
# noinspection PyTypeChecker
update_json_documents(turret_files, Turret.objects)
# noinspection PyTypeChecker
update_json_documents(enemy_files, Enemy.objects)
response = JsonResponse({"status": "ok", "version": version})
response.status_code = 200
return response
def excel_import(request):
if request.method == 'POST':
file = request.FILES['excel']
wb = openpyxl.load_workbook(file)
worksheet = wb["Sheet1"]
excel_data = list()
for row in worksheet.iter_rows():
row_data = list()
for cell in row:
row_data.append(str(cell.value))
excel_data.append(row_data)
saved_title = list()
last_title_id = 0
last_content_id = 0
for data in excel_data:
if len(saved_title) == 0:
saved_title.append(data[1])
title = Title.objects.create(title=data[1])
last_title_id = title.id
newData = Data.objects.create(article=data[0],
title_id=last_title_id,
content=data[2])
last_content_id = newData.id
else:
saved = False
for title in saved_title:
if title == data[1]:
saved = True
if saved != True:
saved_title.append(data[1])
title = Title.objects.create(title=data[1])
last_title_id = title.id
splitted_artice = data[0].split('.')
if len(splitted_artice) > 3:
Data.objects.create(article=data[0],
title_id=last_title_id,
content=data[2],
data_id=last_content_id)
else:
newData = Data.objects.create(article=data[0],
title_id=last_title_id,
content=data[2])
last_content_id = newData.id
print(last_content_id)
else:
splitted_artice = data[0].split('.')
if len(splitted_artice) > 3:
Data.objects.create(article=data[0],
title_id=last_title_id,
content=data[2],
data_id=last_content_id)
else:
newData = Data.objects.create(article=data[0],
title_id=last_title_id,
content=data[2])
last_content_id = newData.id
messages.success(request, 'Амжилттай хадгаллаа')
return render(request, 'fileupload.html')
elif request.method == 'GET':
return render(request, 'fileupload.html')
else:
response = JsonResponse()
response.status_code = 405
return response
def title(request):
if request.method == 'POST':
if request.body:
body_unicode = request.body.decode('utf-8')
body = json.loads(body_unicode)
try:
token = body['token']
question = body['question']
if token and question:
stop_word = ['нь', 'энэ', 'бол', 'дэх', 'тухай', 'хүн']
user_input = question
dataObj = Title.objects.all()
fullContents = list()
contents = list()
for obj in dataObj:
data = {
'id': obj.id,
'title': obj.title,
}
fullContents.append(data)
contents.append(obj.title)
convertToVector = ConvertToVector(stop_word)
contents.append(user_input)
total_vec = convertToVector.convert_tfidf_vector(contents)
res = []
max_cos = 0
user_vec = total_vec[len(total_vec) - 1]
for i in range(len(total_vec) - 1):
cosine_number = convertToVector.cosine_similarity(
user_vec, total_vec[i])
if cosine_number >= max_cos and cosine_number > 0:
max_cos = cosine_number
if len(res) == 0:
res.append(CosineResult(i, cosine_number))
else:
res.append(CosineResult(i, cosine_number))
if len(res) == 0:
response = JsonResponse({
'message':
'Таны асуултанд тохирох хариулт олдсонгүй :('
})
response.status_code = 204
return response
else:
answers = list()
res.sort(key=lambda c: c.cosine_number, reverse=True)
for obj in res:
answer = list()
answer.append(fullContents[obj.index]['id'])
answer.append(fullContents[obj.index]['title'])
answers.append(answer)
response = JsonResponse({'data': answers[0:5]})
response.status_code = 200
return response
else:
response = JsonResponse({'message': 'Өгөгдөл оруулна уу'})
response.status_code = 400
return response
except Exception as e:
print(e)
response = JsonResponse({'message': 'Хүсэлт буруу байна'})
response.status_code = 401
return response
else:
return render(request, '405error.html')
def exp_action_new(request, experiment_id):
try:
experimentJudge = ExperimentJudge.objects.get(experiment__id=experiment_id, user__id=request.user.profile.id)
except ExperimentJudge.DoesNotExist:
data = {"message": "You are not authorized to participate in this experiment."}
response = JsonResponse(data=data)
response.status_code = 401
return response
else:
if experimentJudge.status == ExperimentJudge.STATUS_NOT_STARTED:
experimentJudge.status = ExperimentJudge.STATUS_STARTED
experimentJudge.save()
experiment = experimentJudge.experiment
if request.method == 'POST':
try:
candidate_id = int(request.POST.get('candidate_id', -1))
try:
candidate = CandidatePair.objects.get(pk=candidate_id)
except CandidatePair.DoesNotExist:
data = {"message": "Invalid candidate pair id."}
response = JsonResponse(data=data)
response.status_code = 401
return response
except TypeError:
data = {"message": "Invalid candidate pair id."}
response = JsonResponse(data=data)
response.status_code = 401
return response
try:
time_spent = int(request.POST.get('time_spent', -1))
except TypeError:
data = {"message": "Invalid time spent information"}
response = JsonResponse(data=data)
response.status_code = 401
return response
form = ExperimentActionForm(experiment, request.POST, request=request)
if form.is_valid():
try:
exp_detail = ExperimentDetail.objects.get(experiment=experiment,
candidate_pair=candidate,
user=request.user.profile,
visited=False,
source_type=ExperimentDetail.USER_SOURCE_TYPE
)
exp_detail.vote = form.cleaned_data['vote']
exp_detail.SOURCE_TYPE = ExperimentDetail.USER_SOURCE_TYPE
# save candidate's user score.
candidate_user_score = CandidateUserScore()
candidate_user_score.user = request.user.profile
candidate_user_score.candidate = candidate
candidate_user_score.vote = exp_detail.vote
candidate_user_score.experiment = experiment
candidate_user_score.time_spent = time_spent # => [137]
candidate_user_score.explaination = form.cleaned_data['explanation']
candidate_user_score.save()
exp_detail.visited = True
exp_detail.save()
next_exp_details = ExperimentDetail.objects.filter(user=request.user.profile,
experiment=experiment,
visited=False,
source_type=ExperimentDetail.USER_SOURCE_TYPE).order_by(
'?')
if next_exp_details:
block1 = next_exp_details[0].candidate_pair.candidate_one
block2 = next_exp_details[0].candidate_pair.candidate_two
data = {"block_one": block1.getSourceCode().strip(),
"block_two": block2.getSourceCode().strip(),
"exp_id": experiment_id,
"candidate_id": next_exp_details[0].candidate_pair.id,
"has_next": next_exp_details.count() > 1,
"left": next_exp_details.count()
}
response = JsonResponse(data=data)
response.status_code = 200
return response
else:
data = getReportForExperimentForUser(request.user.profile, experiment)
response = JsonResponse(data=data)
response.status_code = 200
return response
except ExperimentDetail.DoesNotExist:
data = {
"message": "Invalid request. Couldn't find the requested candidate pair",
"redirect_url": "send some url"} # TODO:send redirect url
response = JsonResponse(data=data)
response.status_code = 401
return response
else:
print(form.errors)
data = {
"message": "Some error in form validation",
"redirect_url": "send some url"} # TODO:send redirect url
response = JsonResponse(data=data)
response.status_code = 401
return response
def decorated(*args, **kwargs):
if settings.SECURE_API_ENDPOINTS:
request = args[0]
auth = request.META.get("HTTP_AUTHORIZATION", None)
if auth:
parts = auth.split()
token = parts[1]
else:
response = JsonResponse({
'detail':
'Authentication credentials were not provided'
})
response.status_code = 401
return response
AUTH0_DOMAIN = os.environ.get('AUTH0_DOMAIN')
API_IDENTIFIER = os.environ.get('API_IDENTIFIER')
jsonurl = req.urlopen('https://' + AUTH0_DOMAIN +
'/.well-known/jwks.json')
jwks = json.loads(jsonurl.read())
cert = '-----BEGIN CERTIFICATE-----\n' + \
jwks['keys'][0]['x5c'][0] + '\n-----END CERTIFICATE-----'
certificate = load_pem_x509_certificate(
cert.encode('utf-8'), default_backend())
public_key = certificate.public_key()
try:
decoded = jwt.decode(token,
public_key,
audience=API_IDENTIFIER,
algorithms=['RS256'])
except jwt.ExpiredSignatureError as es:
response = JsonResponse(
{'detail': 'Token Signature has expired'})
response.status_code = 401
return response
except jwt.InvalidAudienceError as es:
response = JsonResponse(
{'detail': 'Invalid audience in token'})
response.status_code = 401
return response
except jwt.InvalidIssuerError as es:
response = JsonResponse(
{'detail': 'Invalid issuer for token'})
response.status_code = 401
return response
except jwt.InvalidSignatureError as es:
response = JsonResponse(
{'detail': 'Invalid signature in token'})
response.status_code = 401
return response
except Exception as e:
response = JsonResponse({'detail': 'Invalid token'})
response.status_code = 401
return response
if decoded.get("scope"):
token_scopes = decoded["scope"].split()
token_scopes_set = set(token_scopes)
if set(required_scopes).issubset(token_scopes_set):
return f(*args, **kwargs)
response = JsonResponse(
{'message': 'You don\'t have access to this resource'})
response.status_code = 403
return response
else:
return f(*args, **kwargs)
def notification_invalid_response(error_message='Invalid Notification'):
response = JsonResponse({'notificationResponse': error_message})
response.status_code = 403
return response
