def complete_login(request):
auth = get_saml_auth(request)
auth.process_response()
errors = auth.get_errors()
if errors:
logger.error(auth.get_last_error_reason(), exc_info=True)
return HttpResponseBadRequest(
content='Error when processing SAML Response: {}'.format(', '.join(errors))
)
if auth.is_authenticated():
request.session['saml_attributes'] = auth.get_attributes()
request.session['saml_nameid'] = auth.get_nameid()
request.session['saml_session_index'] = auth.get_session_index()
params = {'state': 'saml'}
url = request.POST.get('RelayState', '/login')
return HttpResponseRedirect(auth.redirect_to(url, parameters=params))
else:
raise PermissionDenied()
python类HttpResponseBadRequest()的实例源码
def complete_logout(request):
auth = get_saml_auth(request)
url = auth.process_slo(delete_session_cb=lambda: request.session.flush())
errors = auth.get_errors()
if errors:
logger.error(auth.get_last_error_reason(), exc_info=True)
return HttpResponseBadRequest(
content='Error when processing SAML Logout Request: {}'.format(', '.join(errors))
)
params = {}
if url:
params['next'] = url
return HttpResponseRedirect(auth.redirect_to('/logout', parameters=params))
def post(self, request):
if "HTTP_PAYPAL_TRANSMISSION_ID" not in request.META:
# Do not even attempt to process/store the event if there is
# no paypal transmission id so we avoid overfilling the db.
return HttpResponseBadRequest()
trigger = WebhookEventTrigger.from_request(request)
if trigger.exception:
# An exception happened, return 500
return HttpResponseServerError()
if not trigger.valid:
# Webhook Event did not validate, return 400
return HttpResponseBadRequest()
return HttpResponse(str(trigger.id))
def search(request):
q = request.GET.get('q')
if not q:
return HttpResponseBadRequest("GET['q'] not set!")
q = q.strip()
try:
document_ids = search_ids(q)
except SearchError as e:
return HttpResponseServerError(str(e))
documents = [get_document(id).parsed for id in document_ids]
data = {
'status': 'ok',
'query': q,
'document_ids': document_ids,
'documents': documents,
'results': len(document_ids),
}
r = JsonResponse(data)
r["Access-Control-Allow-Origin"] = '*'
return r
def bad_request(request, exception, template_name='400.html'):
"""
400 error handler.
Templates: :template:`400.html`
Context: None
"""
try:
template = loader.get_template(template_name)
except TemplateDoesNotExist:
return http.HttpResponseBadRequest('<h1>Bad Request (400)</h1>', content_type='text/html')
# No exception content is passed to the template, to not disclose any sensitive information.
return http.HttpResponseBadRequest(template.render())
# This can be called when CsrfViewMiddleware.process_view has not run,
# therefore need @requires_csrf_token in case the template needs
# {% csrf_token %}.
def task_tester(request):
if request.method == 'POST':
cache.set('marco', 'ping', 100)
sample_task.delay('marco', 'polo', 10)
return http.HttpResponse(
'Now make a GET request to this URL\n',
status=201,
)
else:
if not cache.get('marco'):
return http.HttpResponseBadRequest(
'Make a POST request to this URL first\n'
)
for i in range(3):
value = cache.get('marco')
if value == 'polo':
return http.HttpResponse('It works!\n')
time.sleep(1)
return http.HttpResponseServerError(
'Tried 4 times (4 seconds) and no luck :(\n'
)
def ajax_required(f):
"""Check that the request is an AJAX request.
Use it in your views:
@ajax_required
def my_view(request):
....
Taken from:
http://djangosnippets.org/snippets/771/
"""
@wraps(f)
def wrapper(request, *args, **kwargs):
if not settings.DEBUG and not request.is_ajax():
return HttpResponseBadRequest("This must be an AJAX request.")
return f(request, *args, **kwargs)
return wrapper
def unpack_problem_json(request):
data = json.loads(request.body.decode('utf-8'))
if "name" not in data:
return HttpResponseBadRequest("Need to include a reference to 'name' in the json object")
if "courses" not in data:
return HttpResponseBadRequest("Need to include a reference to 'courses' in the json object")
if "tests" not in data:
return HttpResponseBadRequest("Need to include a reference to 'tests' in the json object")
if "solution_code" not in data:
return HttpResponseBadRequest("Need to include a reference to 'solution_code' in the json object")
courses = []
for c in data["courses"]:
course = Course.objects.filter(id=c)
if len(course) != 1:
return HttpResponseBadRequest("No course exists with the ID " + str(c))
courses.append(course[0])
data["courses"] = courses
return data
def get(self, request):
try:
start, end = get_start_end_paramters(request, default_days_back=1)
except ValueError as e:
return HttpResponseBadRequest(str(e))
combine = request.query_params.get('combine')
sites = request.query_params.getlist('site')
telescopes = request.query_params.getlist('telescope')
try:
telescope_availability = get_telescope_availability_per_day(
start, end, sites=sites, telescopes=telescopes
)
except ElasticSearchException:
logger.warning('Error connecting to ElasticSearch. Is SBA reachable?')
return Response('ConnectionError')
if combine:
telescope_availability = combine_telescope_availabilities_by_site_and_class(telescope_availability)
str_telescope_availability = {str(k): v for k, v in telescope_availability.items()}
return Response(str_telescope_availability)
def add_slack_btn(request):
code = request.GET.get("code", "")
if len(code) < 8:
return HttpResponseBadRequest()
result = requests.post("https://slack.com/api/oauth.access", {
"client_id": settings.SLACK_CLIENT_ID,
"client_secret": settings.SLACK_CLIENT_SECRET,
"code": code
})
doc = result.json()
if doc.get("ok"):
channel = Channel()
channel.user = request.team.user
channel.kind = "slack"
channel.value = result.text
channel.save()
channel.assign_all_checks()
messages.success(request, "The Slack integration has been added!")
else:
s = doc.get("error")
messages.warning(request, "Error message from slack: %s" % s)
return redirect("hc-channels")
def badge(request, username, signature, tag):
if not check_signature(username, tag, signature):
return HttpResponseBadRequest()
status = "up"
q = Check.objects.filter(user__username=username, tags__contains=tag)
for check in q:
if tag not in check.tags_list():
continue
if status == "up" and check.in_grace_period():
status = "late"
if check.get_status() == "down":
status = "down"
break
svg = get_badge_svg(tag, status)
return HttpResponse(svg, content_type="image/svg+xml")
def set_password(request, token):
profile = request.user.profile
if not check_password(token, profile.token):
return HttpResponseBadRequest()
if request.method == "POST":
form = SetPasswordForm(request.POST)
if form.is_valid():
password = form.cleaned_data["password"]
request.user.set_password(password)
request.user.save()
profile.token = ""
profile.save()
# Setting a password logs the user out, so here we
# log them back in.
u = authenticate(username=request.user.email, password=password)
auth_login(request, u)
messages.success(request, "Your password has been set!")
return redirect("hc-profile")
return render(request, "accounts/set_password.html", {})
def updateData(request, table):
data = request.data
if table == "user":
username = data['username']
if not User_data.objects.filter(username=username).exists():
return HttpResponseBadRequest('User record with username ' + username + ' does not exist')
else:
data.pop('username', None)
user.objects.filter(username=username).update(**data)
return HttpResponse('Put is successful')
elif table == "program":
pid = data['pid']
if not Program.objects.filter(pid=pid).exists():
return HttpResponseBadRequest('Program record with pid ' + str(pid) + ' does not exist')
else:
prog = Program.objects.get(pid=pid)
data.pop('pid', None)
Program.objects.filter(pid=pid).update(**data)
return HttpResponse('Put is successful')
else:
return HttpResponseBadRequest('Put is not successful')
def deleteData(request, table):
data = request.data
if table == "user":
username = data['username']
if not User_data.objects.filter(username=username).exists():
return HttpResponseBadRequest('User record with username ' + username + ' does not exist')
else:
user = User_data.objects.get(username=username)
user.delete()
elif table == "program":
pid = data['pid']
if not Program.objects.filter(pid=pid).exists():
return HttpResponseBadRequest('Program record with pid ' + str(pid) + ' does not exist')
else:
prog = Program.objects.get(pid=pid)
prog.delete()
else:
return HttpResponseBadRequest('Wrong table name')
return HttpResponse('Delete is successful')
def parseRequest(request, table, id):
data = request.data
if table == 'user':
username = data['username']
try:
data = User_data.objects.filter(username=username).values()
print(data)
except User_data.DoesNotExist:
return HttpResponse(status=404)
return HttpResponse(data)
elif table == "program":
pid = data['pid']
try:
data = Program.objects.filter(pid=id).values()
except Program.DoesNotExist:
return HttpResponse(status=404)
return HttpResponse(data)
else:
return HttpResponseBadRequest('Wrong table name')
def image_to_pickle(request):
if request.method == 'POST':
try:
params = json.loads(request.body)
except:
return HttpResponseBadRequest(json.dumps({'error':'Json required'}),content_type="application/json")
if not params.get('image_path') or not params.get('output_path'):
return HttpResponseBadRequest(json.dumps({'error':'image_path and output_path required'}),content_type="application/json")
try:
data = get_data_from_image(params.get('image_path'))
save_to_pickle(data,str(params.get('output_path'))+"/data.pickle")
return HttpResponse(json.dumps({'success':True}),content_type="application/json")
except Exception as e:
return HttpResponseBadRequest(json.dumps({'error':str(e)}),content_type="application/json")
else:
raise Http404()
def run_algo(request):
if request.method == 'POST':
try:
params = json.loads(request.body)
except:
return HttpResponseBadRequest(json.dumps({'error':'Json required'}),content_type="application/json")
if not params.get("image_pickle_file_path") or not params.get("algo") or not params.get('cluster_number') or not params.get('output_path'):
return HttpResponseBadRequest(json.dumps({'error':'output_path ,image_pickle_file_path,cluster_number and algo manadatory,only .pickle file accepted, valid algo are '+str(default_params.algo_details.keys())}),content_type="application/json")
pid_element = Results.objects.create(pid=None)
params['id'] = pid_element.id
params = json.dumps(params)
command = "python segment_hsi.py '"+str(params)+"' &"
proc = subprocess.Popen(command,shell=True)
return HttpResponse(json.dumps({'success':True,'task_id':pid_element.id}),content_type="application/json")
else:
raise Http404()
def get_beta(request):
if request.method == 'POST':
try:
params = json.loads(request.body)
except:
return HttpResponseBadRequest(json.dumps({'error':'Json required'}),content_type="application/json")
if not params.get("output_path") or not params.get("image_pickle_file_path"):
return HttpResponseBadRequest(json.dumps({'error':'output_path and image_pickle_file_path manadatory'}),content_type="application/json")
pid_element = Results.objects.create(pid=None)
params['id'] = pid_element.id
params = json.dumps(params)
command = "python make_beta.py '"+str(params)+"' &"
proc = subprocess.Popen(command,shell=True)
return HttpResponse(json.dumps({'success':True,'task_id':pid_element.id}),content_type="application/json")
else:
raise Http404()
def get_weight(request):
if request.method == 'POST':
try:
params = json.loads(request.body)
except:
return HttpResponseBadRequest(json.dumps({'error':'Json required'}),content_type="application/json")
if not params.get("output_path") or not params.get("image_pickle_file_path"):
return HttpResponseBadRequest(json.dumps({'error':'output_path and image_pickle_file_path manadatory'}),content_type="application/json")
pid_element = Results.objects.create(pid=None)
params['id'] = pid_element.id
params = json.dumps(params)
command = "python make_weight.py '"+str(params)+"' &"
proc = subprocess.Popen(command,shell=True)
return HttpResponse(json.dumps({'success':True,'task_id':pid_element.id}),content_type="application/json")
else:
raise Http404()
def kill_task(request):
if request.method == 'POST':
try:
params = json.loads(request.body)
except:
return HttpResponseBadRequest(json.dumps({'error':'Json required'}),content_type="application/json")
if not params.get("task_id"):
return HttpResponseBadRequest(json.dumps({'error':'task_id manadatory'}),content_type="application/json")
tasks = Results.objects.filter(id = params['task_id'])
for task in tasks:
try:
parent = psutil.Process(task.pid)
for child in parent.children(recursive=True):
child.kill()
parent.kill()
except Exception as e:
pass
task.status_text = 'Killed'
task.is_done = True
task.save()
return HttpResponse(json.dumps({'success':True}),content_type="application/json")
else:
raise Http404()
def get_task_status(request):
if request.method == 'POST':
try:
params = json.loads(request.body)
except:
return HttpResponseBadRequest(json.dumps({'error':'Json required'}),content_type="application/json")
if not params.get("task_id"):
return HttpResponseBadRequest(json.dumps({'error':'task_id manadatory'}),content_type="application/json")
try:
task = Results.objects.get(id=params['task_id'])
data = {'task_id':task.id,'result_file_name':task.result_file_name,'error':task.error,'percentage_done':task.percentage_done,
'status_text':task.status_text,'is_done':task.is_done,'pid':task.pid}
return HttpResponse(json.dumps(data),content_type="application/json")
except Results.DoesNotExist as e:
return HttpResponseBadRequest(json.dumps({'error':'Invalid task_id'}),content_type="application/json")
else:
raise Http404()
def get(self, request, **kwargs):
"""
Validate account from link sent by email.
This endpoint tests if the token is in the database and
if it's not expired, correspond to the correct user and
if it's not consumed yet, then the user account will be
validate after that.
"""
try:
token = EmailValidationToken.objects.get(token=request.GET['token'])
if not token.is_valid(request.GET['email']):
raise ValueError('invalid token')
token.consume()
if not request.user.is_authenticated:
self.login_user(token.user)
messages.success(request, 'Email validated')
return redirect('main:index')
except (EmailValidationToken.DoesNotExist, ValueError) as e:
print(e)
return HttpResponseBadRequest('Something went wrong with your token, please try again')
def setUserStatus(request):
"""set user status to either active (is_active=True), banned(is_active=False), or admin(is_superuser=True)"""
try:
username = request.POST['username']
status = request.POST['status']
except KeyError:
return HttpResponseBadRequest()
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
raise Http404()
if status == 'active':
user.is_active = True
user.is_superuser = False
elif status == 'banned':
user.is_active = False
user.is_superuser = False
elif status == 'admin':
user.is_active = True
user.is_superuser = True
else:
return HttpResponseBadRequest()
user.save()
return HttpResponse()
def set_info(request, tracker_id):
"""Set browser infos.
:param request:
:param tracker_id:
:return:
"""
if not request.POST.get('infos'):
return HttpResponseBadRequest()
tracker = TrackerInfos.objects.filter(
target_tracker_id=tracker_id, raw=None).order_by('created_at').last()
if not tracker:
return HttpResponseNotFound()
tracker.raw = request.POST['infos']
tracker.save()
return HttpResponse('')
def get(self, request, uuid=None):
"""Handles GET requests."""
user_profile = models.UserProfile.objects.get(user=request.user)
try:
tower = models.BTS.objects.get(uuid=uuid,
network=user_profile.network)
except models.BTS.DoesNotExist:
return http.HttpResponseBadRequest()
endaga_version = json.loads(tower.package_versions)['endaga_version']
context = {
'networks': get_objects_for_user(request.user, 'view_network', klass=models.Network),
'user_profile': user_profile,
'tower': tower,
'endaga_version': endaga_version,
'status': tower.get_status_display(),
}
# Render template.
edit_template = template.loader.get_template(
'dashboard/tower_detail/deregister.html')
html = edit_template.render(context, request)
return http.HttpResponse(html)
def addmoney(request):
if request.method == 'POST':
amt = cents2mc(int(float(request.POST['amount']) * 100))
user_profile = UserProfile.objects.get(user=request.user)
network = user_profile.network
try:
charge = network.authorize_card(amt, "credit", "Add Credit")
network.add_credit(amt)
network.capture_charge(charge.id)
messages.add_message(request, messages.SUCCESS,
"addmoney_stripe_success",
extra_tags="billing_resp_code")
return redirect("/dashboard/billing")
except stripe.StripeError:
logger.error("Failed to add money, stripe.CardError: %s", request)
messages.add_message(request, messages.WARNING,
"addmoney_stripe_error",
extra_tags="billing_resp_code")
return redirect("/dashboard/billing")
else:
return HttpResponseBadRequest()
def get(self, request, imsi=None):
"""Handles GET requests."""
user_profile = UserProfile.objects.get(user=request.user)
network = user_profile.network
try:
subscriber = Subscriber.objects.get(imsi=imsi,
network=network)
except Subscriber.DoesNotExist:
return HttpResponseBadRequest()
initial_form_data = {
'imsi': subscriber.imsi
}
# Set the response context.
context = {
'networks': get_objects_for_user(request.user, 'view_network', klass=Network),
'user_profile': user_profile,
'subscriber': subscriber,
'send_sms_form': dform.SubscriberSendSMSForm(
initial=initial_form_data)
}
# Render template.
template = get_template('dashboard/subscriber_detail/send_sms.html')
html = template.render(context, request)
return HttpResponse(html)
def delete(self, request, imsi=None):
"""Handle the deletion of Pending Credit Updates."""
user_profile = UserProfile.objects.get(user=request.user)
network = user_profile.network
request_data = QueryDict(request.body)
if "pending_id" not in request_data:
return HttpResponseBadRequest()
pending_id = request_data['pending_id']
try:
update = PendingCreditUpdate.objects.get(uuid=pending_id)
except PendingCreditUpdate.DoesNotExist:
return HttpResponseBadRequest()
if update.subscriber.network != network:
return HttpResponseBadRequest()
update.delete()
return HttpResponse()
def post(self, request, imsi=None):
"""Handles POST requests to change subscriber info."""
user_profile = UserProfile.objects.get(user=request.user)
network = user_profile.network
try:
subscriber = Subscriber.objects.get(imsi=imsi,
network=network)
except Subscriber.DoesNotExist:
return HttpResponseBadRequest()
if (request.POST.get('name') and
subscriber.name != request.POST.get('name')):
subscriber.name = request.POST.get('name')
subscriber.save()
if request.POST.get('prevent_automatic_deactivation'):
protected = (
request.POST.get('prevent_automatic_deactivation') == 'True')
subscriber.prevent_automatic_deactivation = protected
subscriber.save()
messages.success(request, "Subscriber information updated.",
extra_tags="alert alert-success")
kwargs = {
'imsi': imsi
}
return redirect(urlresolvers.reverse('subscriber-edit', kwargs=kwargs))
def update_contact(request):
"""Handles a user changing their background contact info."""
if request.method == 'POST':
if 'email' in request.POST:
try:
validate_email(request.POST['email'])
request.user.email = request.POST['email']
except ValidationError:
messages.error(request, "Invalid email address.",
extra_tags="contact alert alert-danger")
return redirect("/dashboard/profile")
if 'first_name' in request.POST:
request.user.first_name = request.POST['first_name']
if 'last_name' in request.POST:
request.user.last_name = request.POST['last_name']
user_profile = UserProfile.objects.get(user=request.user)
if 'timezone' in request.POST:
user_profile.timezone = request.POST['timezone']
user_profile.save()
request.user.save()
messages.success(request, "Profile information updated.",
extra_tags="contact alert alert-success")
return redirect("/dashboard/profile")
return HttpResponseBadRequest()
