def get(self, request, country_name): if country_name == 'world' or country_name == 'World': country_name = 'World' country_cache = os.path.join(settings.CLUSTER_CACHE_DIR, country_name) metadata_file = os.path.join(country_cache, 'metadata') try: f = open(metadata_file, 'r') file_content = f.read() if file_content == 'Start': return Response('Start') try: metadata = json.loads(file_content) except ValueError: return Response('Start') if metadata['total'] == metadata['index']: # check metadata if country_name == 'world' or country_name == 'World': country_name = 'World' queryset = LocalityOSMView.objects.all().order_by('row') else: country = Country.objects.get(name__iexact=country_name) polygons = country.polygon_geometry queryset = LocalityOSMView.objects.in_polygon( polygons).order_by('row') if metadata['total'] == queryset.count() and \ metadata['row'] == queryset.last().row: return Response(metadata) else: return Response(metadata) except IOError: if not os.path.exists(country_cache): os.makedirs(country_cache) try: country_data_into_shapefile_task.delay(country_name) try: file = open(metadata_file, 'w+') file.write('Start') file.close() except Exception: pass return Response('Start') except Country.DoesNotExist: return HttpResponseBadRequest('%s is not found or not a country.' % country_name)
def get(self, request, username): try: user = User.objects.get(username=username) osm_user = get_osm_name(user) if osm_user: username = osm_user except User.DoesNotExist: pass updates_osm = all_locality().filter(changeset_user=username).exclude( changeset_timestamp__isnull=True).order_by('-changeset_timestamp') try: queryset = self.get_query_by_page(updates_osm) except (LessThanOneException, NotANumberException) as e: return HttpResponseBadRequest('%s' % e) return Response(LocalityOSMBasicSerializer(queryset, many=True).data)
def ajax_get_dataset_options(request): selected_dataset_name = request.GET.get('dataset_id') filter_widget_id = request.GET.get('filter_widget_id') param_filter_widget_id = request.GET.get('param_filter_widget_id') try: selected_dataset = Dataset.objects.get(pk=selected_dataset_name) except: return HttpResponseBadRequest("Not a valid dataset") response_data = { 'versions': __render_options(selected_dataset.versions.all().order_by('-pretty_name')), 'variables': __render_options(selected_dataset.variables.all().order_by('id')), 'filters': __render_filters(selected_dataset.filters.filter(parameterised=False), filter_widget_id, parametrised = False), 'paramfilters': __render_filters(selected_dataset.filters.filter(parameterised=True), param_filter_widget_id, parametrised = True), } return JsonResponse(response_data)
def __decorator(self, request, *args, **kwargs): if request.method not in methods: return view(request, *args, **kwargs) try: request.access_token = re.match( '^token (\w+)', request.META['HTTP_AUTHORIZATION']).groups()[0] except (KeyError, AttributeError): request.access_token = None # client_info = ClientTokenHelper.verify(request.access_token) # if not client_info: # return HttpResponseForbidden(json.dumps({ # "message": "Authorization failed"})) # request.client_id = client_info['client_id'] if not _deal_request(request): return HttpResponseBadRequest( json.dumps({"message": "Problems parsing JSON"})) return view(self, request, *args, **kwargs)
def post(self,request,*args, **kwargs): uuid=kwargs['uuid'] if request.user.is_authenticated : return HttpResponseForbidden() user=request.user try: folder = CodeFolder.objects.get(folder_uuid=uuid,user=user) folder.delete() except CodeFolder.DoesNotExist: return HttpResponseNotFound() except: return HttpResponseBadRequest()
def post(self,request,*args, **kwargs): uuid=kwargs['uuid'] user=request.user try: paste = CodePaste.objects.get(paste_uuid=uuid,user=user) paste.delete() return JsonResponse({'detail':'success'}) except CodePaste.DoesNotExist: print('not_forund') return HttpResponseNotFound() except: return HttpResponseBadRequest()
def get_graphql_params(request, data): query = request.GET.get("query") or data.get("query") variables = request.GET.get("variables") or data.get("variables") id = request.GET.get("id") or data.get("id") if variables and isinstance(variables, str): try: variables = json.loads(variables) except Exception: raise HttpError( HttpResponseBadRequest("Variables are invalid JSON.")) operation_name = request.GET.get("operationName") or data.get( "operationName") if operation_name == "null": operation_name = None return query, variables, operation_name, id
def generate_element(request, explore_data_structure_id): """ Generate an element absent from the form. Args: request: explore_data_structure_id: Returns: """ try: element_id = request.POST['id'] explore_data_structure = explore_data_structure_api.get_by_id( explore_data_structure_id) html_form = generate_element_absent( request, element_id, explore_data_structure.template.content) except Exception, e: return HttpResponseBadRequest()
def run(request): resp = get_chooser_or_response(request) if type(resp) == Chooser: route = resp.get_grouped_route() else: return resp if route == None: return HttpResponseBadRequest('Not enough orbs to finish a run!') params = resp.settings.to_display_dict() #used for the next run newseed = random.getrandbits(32) params.update({ 'run': route, 'setting_str': resp.settings.to_setting_str(), 'seed': resp.seed, 'newseed': newseed }) return render(request, 'run.html', params)
def answer(request): if not util.check_active_student(request): return redirect("student_login") if request.method == "GET" and all([x in request.GET for x in ("qid", "ans")]): data = request.GET q = TeambuildingQuestion.objects.get(id=data['qid']) r, created = TeambuildingResponse.objects.get_or_create(question=q, student_id=request.session['sid']) r.answer = q.get_answers()[int(data['ans'])] r.save() q.used = True q.save() return redirect('index') return HttpResponseBadRequest()
def get(self, request, username): page = self.request.GET.get('page', None) if page: try: queryset = self.get_query_by_page( PendingUpdate.objects.filter(uploader__username=username)) except (LessThanOneException, NotANumberException) as e: return HttpResponseBadRequest('%s' % e) else: queryset = PendingUpdate.objects.filter( uploader__username=username) for pending in queryset: validate_pending_update(pending.extension.osm_type, pending.extension.osm_id) queryset = PendingUpdate.objects.filter( uploader__username=username) return Response(PendingUpdateSerializer(queryset, many=True).data)
def order_progress(request, order_pk): """ Returns the current progress of the order in the following format: { “created”: 5, “total”: 20, “progress”: “25%” } """ if not request.is_ajax(): return HttpResponseBadRequest() order = get_object_or_404(Order, service_type=Order.SOCIAL_PROFILES, pk=order_pk) if "view_order" not in get_perms(request.user, order): raise Http404 return JsonResponse(order.order_progress)
def update_transaccion_modal(request, id_transaccion): """ Returns a form that can be used to edit an existing transaccion. """ if request.is_ajax(): context = {} transaccion = get_object_or_404(Transaccion, pk=id_transaccion) id_familia = transaccion.familia.pk context['id_familia'] = id_familia id_transaccion = transaccion.pk context['transaccion_form'] = TransaccionForm( instance=transaccion, initial={'id_transaccion': id_transaccion}) if hasattr(transaccion, 'ingreso'): context['ingreso_form'] = IngresoForm(id_familia, instance=transaccion.ingreso) return render(request, 'captura/edit_ingreso_egreso_form.html', context) return HttpResponseBadRequest()
def post(self, request, *args, **kwargs): form = forms.CreateIssueCommentForm(request.POST) if not form.is_valid(): return HttpResponseBadRequest() i = self.get_object() comment_id = request.POST.get('comment_id', None) try: c = i.comments.get(pk=int(comment_id)) c.content = enhance_html(form.cleaned_data['content']) c.save() return json_response({'comment_id': c.id}) except: c = i.comments.create(content=enhance_html( form.cleaned_data['content']), created_by=request.user) return json_response({'comment_id': c.id})
def get_statuses(request): request_params = request.GET.dict() request_path = request_params.get('request_path') if not request_path: return HttpResponseBadRequest( "Bad request: missing request_path param") url = KIKAR_URL_BASE + request_params.pop('request_path') if 'filter' in request_params: request_filter = request_params.pop('filter').split('=') request_params[request_filter[0]] = request_filter[1] # TODO: Jesus how can this be even tested? should be separated to proxy kikar_res = requests.get(url, params=request_params) logger.debug(kikar_res.url) res = HttpResponse(content=kikar_res.content, content_type='application/json') return res
def post(self, request, *args, **kwargs): if not CourseAccess.allowed(request): return HttpResponseForbidden() wid = self.request.POST.get('metadata-wardenclyffe-id', None) if not wid: return HttpResponseNotFound() qs = self.get_matching_assets(wid) if qs.count() == 0: return HttpResponseNotFound() for asset in self.get_matching_assets(wid): items = request.POST.items() if not self.update_asset(asset, items): return HttpResponseBadRequest() return HttpResponse('updated')
def post(self, request, *args, **kwargs): """ Used to change a proposal status (accept/reject) or a proposal's property completed/not completed """ p = self.get_object() v = request.POST.get('accepted', None) if v: v = int(v) if v not in [ p.statuses.ACCEPTED, p.statuses.REJECTED, p.statuses.IN_DISCUSSION ]: return HttpResponseBadRequest( "Bad value for accepted POST parameter") p.status = v p.save() return redirect(p)
def get_graphql_params(request, data): query = request.GET.get('query') or data.get('query') variables = request.GET.get('variables') or data.get('variables') id = request.GET.get('id') or data.get('id') if variables and isinstance(variables, six.text_type): try: variables = json.loads(variables) except Exception: raise HttpError( HttpResponseBadRequest('Variables are invalid JSON.')) operation_name = request.GET.get('operationName') or data.get( 'operationName') if operation_name == "null": operation_name = None return query, variables, operation_name, id
def get(self,request): ''' 1接收前端传递过来的uuid 2判断uuid是否获取到 3通过调用captcha来生成图片验证码(图片二进制和图片内容) 4将图片内容保存到redis中 uuid-key,图片内容-value,同时设置一个时效 5返回图片二进制 :param request: :return: ''' uuid = request.GET.get('uuid') if uuid is None: return HttpResponseBadRequest('没有传递uuid') text,image = captcha.generate_captcha() redis_conn = get_redis_connection('default') #uuid 过期秒数 图片二进制内容 redis_conn.setex('img:%s'%uuid,300,text) return HttpResponse(image,content_type='image/jpeg')
def process_response(self, request, response): if self.is_not_ignorable_request(request): url = '{0}{1}'.format(settings.NODE_SERVER, self.path) req = urllib2.Request(url, headers=request.META) try: conn = urllib2.urlopen(req) info = conn.info() data = conn.read() return HttpResponse(data, content_type=info.get("content-type")) except HTTPError as e: if e.code == '400': return HttpResponseBadRequest() if e.code == '404': return HttpResponseNotFound() if e.code == '500': return HttpResponseServerError() return response
def post(self, request): # 1.接收数据 mobile = request.POST.get('mobile') password = request.POST.get('password') password2 = request.POST.get('password2') smscode = request.POST.get('sms_code') # 2.验证数据 # 2.1 判断参数是否齐全 if not all([mobile, password, password2, smscode]): return HttpResponseBadRequest('参数不全') # 2.2 手机号是否符合格则 if not re.match(r'^1[3-9]\d{9}$', mobile): return HttpResponseBadRequest('手机号不符合格则') # 2.3 判断密码是否符合格则 if not re.match(r'^[0-9A-Za-z]{8,20}$', password): return HttpResponseBadRequest('密码不符合格则') # 2.4 判断确认密码和密码是否一致 if password2 != password: return HttpResponseBadRequest('密码不一致') # 2.5 判断短信验证码是否正确 redis_conn = get_redis_connection('default') redis_sms_code = redis_conn.get('sms:%s' % mobile) if redis_sms_code is None: return HttpResponseBadRequest('短信验证码已过期') if redis_sms_code.decode() != smscode: return HttpResponseBadRequest('短信验证码错误') # 3.根据手机号进行用户信息的查询 try: user = User.objects.get(mobile=mobile) except User.DoesNotExist: # 5.如果手机号没有查询出用户信息,则进行新用户的创建 try: User.objects.create_user(username=mobile, mobile=mobile, password=password) except Exception: return HttpResponseBadRequest('修改失败,请稍后再试') else: # 4.如果手机号查询出用户信息则进行用户密码的修改 user.set_password(password) # 注意,保存用户信息 user.save() # 6.进行页面跳转,跳转到登录页面 response = redirect(reverse('users:login')) # 7.返回响应 return response
def set_background(self, request: Request, slug: str): """Set Flow background""" flow: Flow = self.get_object() background = request.FILES.get("file", None) clear = request.data.get("clear", "false").lower() == "true" if clear: if flow.background_url.startswith("/media"): # .delete() saves the model by default flow.background.delete() else: flow.background = None flow.save() return Response({}) if background: flow.background = background flow.save() return Response({}) return HttpResponseBadRequest()
def archive_misconfigured_response() -> HttpResponse: """ Returns an error :class:`HttpResponse` describing how the archive is misconfigured. """ missing = [] # type: List[str] if not _archive_attachment_dir: missing.append(SettingsKeys.ARCHIVE_ATTACHMENT_DIR) if not _archive_root_template: missing.append(SettingsKeys.ARCHIVE_ROOT_TEMPLATE) if not _archive_static_dir: missing.append(SettingsKeys.ARCHIVE_STATIC_DIR) if not _archive_template_cache_dir: missing.append(SettingsKeys.ARCHIVE_TEMPLATE_CACHE_DIR) if not _archive_template_dir: missing.append(SettingsKeys.ARCHIVE_TEMPLATE_DIR) return HttpResponseBadRequest( f"Archive not configured. Administrator has not set: {missing!r}")
def post(self, request, *args, **kwargs): domain = request.GET.get('domain') case_type = request.GET.get('case_type') user_name = request.GET.get('user') properties = json.loads(request.body) case_id = properties['case_id'] properties.pop('case_id') couch_user = CommCareUser.get_by_username(user_name) if not couch_user.is_member_of(domain): return HttpResponseForbidden( "This user does not have access to this domain.") case = get_case_or_404(domain, case_id) if not case.type == case_type: return HttpResponseBadRequest("Case type mismatch")
def import_students(request): if request.method == "POST" and "students" in request.POST: in_str = request.POST['students'] for line in in_str.split("\n"): last, first, sid, homeroom = [x.strip() for x in line.split(",")] s, created = Student.objects.get_or_create(id=sid, grade=int(homeroom[0])) s.fname = first s.lname = last s.homeroom = homeroom s.save() return redirect("admin") else: return HttpResponseBadRequest()
def delete_bucket(request): """Delete a bucket. Args: request: Returns: """ try: bucket_id = request.POST["bucket_id"] bucket = bucket_api.get_by_id(bucket_id) bucket_api.delete(bucket) except Exception as e: return HttpResponseBadRequest(escape(str(e))) return HttpResponse(json.dumps({}), content_type="application/javascript")
def generate_choice(request, sandbox_data_structure_id): """Generate a choice branch absent from the form. Args: request: sandbox_data_structure_id: Returns: """ try: element_id = request.POST['id'] sandbox_data_structure = sandbox_data_structure_api.get_by_id( sandbox_data_structure_id) html_form = generate_choice_absent( request, element_id, sandbox_data_structure.template.content) except Exception, e: return HttpResponseBadRequest()
def register(request): post = request.data username = post.get("username", None) password = post.get("password", None) email = post.get("email", None) print(password) if username is None or password is None or email is None: return HttpResponseBadRequest() user = User.objects.create_user(username, email, password) user.save() return Response({ "user": UserSerializer(user, context={ "request": request }).data, "token": jwt_encode_handler(jwt_payload_handler(user)) })
def get(self, request, user_id): user = UserInfo.objects.get(id=user_id) name = user.realname email = user.email qq = user.qq phone = user.phone adress = user.adress if name and email and qq and phone and adress: dataList = { 'name': name, 'email': email, 'qq': qq, 'phone': phone, 'adress': adress, } return JsonResponse(dataList) else: return HttpResponseBadRequest()
def escaped_execute_graphql_request(self, request, data, query, variables, operation_name, show_graphiql=False): if not query: if show_graphiql: return None raise HttpError( HttpResponseBadRequest('Must provide query string.')) source = Source(query, name='GraphQL request') document_ast = parse(source) validation_errors = validate(self.schema, document_ast) if validation_errors: return ExecutionResult( errors=validation_errors, invalid=True, ) if request.method.lower() == 'get': operation_ast = get_operation_ast(document_ast, operation_name) if operation_ast and operation_ast.operation != 'query': if show_graphiql: return None raise HttpError( HttpResponseNotAllowed( ['POST'], 'Can only perform a {} operation from a POST request.'. format(operation_ast.operation))) return self.execute( document_ast, root_value=self.get_root_value(request), variable_values=variables, operation_name=operation_name, context_value=self.get_context(request), middleware=self.get_middleware(request), executor=self.executor, )