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 info(request): # step 1 - get the hex hex_p = subprocess.Popen(['multichain-cli', 'food2', 'getinfo'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) out, err = hex_p.communicate() big_string = ''.join(out.split('\n\n')[1]).strip() resp = json.loads(big_string) # step 3 - index into json to get either prev txid or coinbase # new_txid = resp['vin'][0]['txid'] # sender_address = resp['vout'][1]['scriptPubKey']['addresses'][0] # print "Prev txid is ", new_txid # print "Sender address is ", sender_address # prev_owner = User.objects.get(address=sender_address).name # print "sender name is ", prev_owner # step 4 - look for coinbase response = JsonResponse(resp) response.__setitem__("Access-Control-Allow-Origin", "*") return response
def send_token(request): if request.method == 'POST': urn_tel = request.POST.get('phone') email_address = request.POST.get('text') session_ureporter = Ureporter.objects.get(urn_tel=urn_tel) existing_ureporter = Ureporter.objects.filter(user__email=email_address).first() if existing_ureporter: tasks.delete_user_from_rapidpro(existing_ureporter) existing_ureporter.uuid = session_ureporter.uuid existing_ureporter.urn_tel = session_ureporter.urn_tel existing_ureporter.user.username = session_ureporter.user.username session_ureporter.delete() existing_ureporter.save() if not existing_ureporter.token: data = {'send_token': 'exists'} else: data = {'send_token': 'send'} tasks.send_verification_token.delay(existing_ureporter) else: session_ureporter.user.email = email_address session_ureporter.save() data = {'send_token': 'send'} tasks.send_verification_token.delay(session_ureporter) response = JsonResponse(data) response.status_codecode = 200 return response
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 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 post(self, request): """""" # 获取参数 sku_id = request.POST.get("sku_id") # 参数校验 if not sku_id: return JsonResponse({"code": 1, "message": "参数缺失"}) # 业务处理, 删除购物车数据 if not request.user.is_authenticated(): # 用户未登录,操作cookie cart_json = request.COOKIES.get("cart") if cart_json is not None: cart = json.loads(cart_json) # 判断cart字典中是否存在sku_id键 if sku_id in cart: # 删除cookie中cart字典的商品记录 del cart[sku_id] response = JsonResponse({"code": 0, "message": "删除成功"}) response.set_cookie("cart", json.dumps(cart)) return response else: return JsonResponse({"code": 0, "message": "删除成功"}) else: # 用户已登录,操作redis redis_conn = get_redis_connection("default") user_id = request.user.id # 删除redis中的sku_id字段的记录 redis_conn.hdel("cart_%s" % user_id, sku_id) return JsonResponse({"code": 0, "message": "删除成功"})
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 get_matches_by_player(player): user = User.objects.get(username=player) wins = Match.objects.filter(winner=user) losses = Match.objects.filter(loser=user) rating_history = dict() for win in wins: rating_history[win.match_date] = win.winner_after_elo for loss in losses: rating_history[loss.match_date] = loss.loser_after_elo sorted_rating_history = collections.OrderedDict() for k in sorted(rating_history.keys()): sorted_rating_history[k] = rating_history[k] #javascript wants a zero based month, what the hell? resp = [{'x': 'new Date(' + ','.join(str(a) for a in [date.year, date.month - 1, date.day, date.hour, date.minute, date.second]) + ')', 'y': elo} for date, elo in sorted_rating_history.items()] resp = JsonResponse( resp, safe=False ) #Unfortunate formatting adjustments to give canvasjs what it wants resp = str(resp.content.decode('utf-8')).replace("\"", '') resp = resp.replace("Content-Type: application/json", "") return resp
def index(request): response = JsonResponse({'foo':'bar'}) # Get the number of visits to the site. # We use the COOKIES.get() function to obtain the visits cookie. # If the cookie exists, the value returned is casted to an integer. # If the cookie doesn't exist, we default to zero and cast that. visits = request.session.get('visits') reset_last_visit_time = False # Does the cookie last_visit exist? if 'last_visit' in request.COOKIES: # Yes it does! Get the cookie's value. last_visit = request.COOKIES['last_visit'] # Cast the value to a Python date/time object. last_visit_time = datetime.strptime(last_visit[:-7], "%Y-%m-%d %H:%M:%S") # If it's been more than a day since the last visit... #if (datetime.now() - last_visit_time).days > 0: visits = visits + 1 # ...and flag that the cookie last visit needs to be updated reset_last_visit_time = True else: print('nenhuma visita anterior') # Cookie last_visit doesn't exist, so flag that it should be set. reset_last_visit_time = True if reset_last_visit_time: response.set_cookie('last_visit', datetime.now()) response.set_cookie('visits', visits) # Return response back to the user, updating any cookies that need changed. 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 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 dispatch(self, request: HttpRequest, *args, **kwargs): self.request = request try: result = super().dispatch(request, *args, **kwargs) if isinstance(result, HttpResponse): return result http_code = self.http_code api_result = dict( data=result, ) except rmr.Error as error: response_logger.log( error.level, '%(code)s: %(message)s', dict(message=error.message, code=error.code), ) http_code = error.http_code api_result = dict( error=dict( code=error.code, description=error.message, ), ) response = JsonResponse(api_result, status=http_code, safe=False) response.setdefault('Content-Length', len(response.content)) return response
def get(self, request): response = JsonResponse({"status":"success", "msg":"" }) response.delete_cookie("token") response.delete_cookie("logined") return response
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): """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 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 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 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 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 cookie_test(request): # o = request.COOKIES['login_cookie'] # decrypted = crypto.decrypt(o,crypto.PRIVATE_KEY) print request.COOKIES print request.method decrypted = "helloWorld" resp = JsonResponse({}) resp.set_cookie("tempcokie","fdgfdgfdg",httponly=True,secure=True,max_age=30); 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 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 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 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 authorize(r): username, password = r.POST['username'], r.POST['password'] user = authenticate(username=username, password=password) if user is None: print('invalid username/password: {} and {}'.format(username, password)) return JsonResponse({'status': 'invalid'}, status=403) resp = JsonResponse({'status': 'valid'}) auth = ClientAuthorization.objects.create(user=user) resp.set_cookie('user_id', user.pk) resp.set_cookie('token', auth.token) return resp
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 total_chart_area(request): data, date_distance, checks = [], -1, 12 accounts = Account.objects.filter(user=request.user) profile_currency = Profile.objects.get(user=request.user).currency object = Income if request.get_full_path( ) == '/users/dashboard/incomes-chart-area/' else Spending first_object = object.objects.filter(user=request.user).first() last_object = object.objects.filter(user=request.user).last() if first_object and last_object: date_distance = (last_object.created_date - first_object.created_date).days if 1 <= date_distance <= 365: year, month = first_object.created_date.year, first_object.created_date.month while checks: date = datetime(year, month, 1) if month == 12: objects = total_currency_converter(request.user, object, accounts, profile_currency, year, month) data.append({date.strftime('%b'): objects}) month = 1 year += 1 else: objects = total_currency_converter(request.user, object, accounts, profile_currency, year, month) data.append({date.strftime('%b'): objects}) month += 1 checks -= 1 elif date_distance > 0: year, month = last_object.created_date.year - 1, last_object.created_date.month + 1 while checks: date = datetime(year, month, 1) if month == 12: objects = total_currency_converter(request.user, object, accounts, profile_currency, year, month) data.append({date.strftime('%b'): objects}) month = 1 year += 1 else: objects = total_currency_converter(request.user, object, accounts, profile_currency, year, month) data.append({date.strftime('%b'): objects}) month += 1 checks -= 1 elif date_distance == 0: year, month = first_object.created_date.year, first_object.created_date.month while checks: date = datetime(year, month, 1) if month == 12: objects = total_currency_converter(request.user, object, accounts, profile_currency, year, month) data.append({date.strftime('%b'): objects}) month = 1 year += 1 else: objects = total_currency_converter(request.user, object, accounts, profile_currency, year, month) data.append({date.strftime('%b'): objects}) month += 1 checks -= 1 return JsonResponse(data, safe=False)
def register_exist(request): uname = request.GET.get('uname') count = UserInfo.object.filter(uname=uname).count() return JsonResponse ({'conut':count})
def response(data={}, message='', status=200): result = { 'data': data, 'message': message, } return JsonResponse(result, status=status)
def article_view_all(request): articles = Article.objects.all() data = list(articles.values()) return JsonResponse(data, safe=False, json_dumps_params={'ensure_ascii': False})
def JsonResponseMessage(status=500, message=None, status_message='error'): response = {'status': status_message} if message is not None: response['message'] = message return JsonResponse(response, status=status)
def vacancies_top(request, top_number): vacancies = Vacancy.objects.all() vacancies = vacancies.order_by('salary').reverse()[:top_number] vacancies_json = [vacancy.to_json() for vacancy in vacancies] return JsonResponse(vacancies_json, safe=False)
def render_json_response(context): return JsonResponse(context)
def vacancies_list(request): vacancies = Vacancy.objects.all() vacancies_json = [vacancy.to_json() for vacancy in vacancies] return JsonResponse(vacancies_json, safe=False)
def vacancy_detail(request, vacancy_id): try: vacancy = Vacancy.objects.get(id=vacancy_id) except Vacancy.DoesNotExist as e: return JsonResponse({'error': str(e)}) return JsonResponse(vacancy.to_json())
def company_detail(request, company_id): try: company = Company.objects.get(id=company_id) except Company.DoesNotExist as e: return JsonResponse({'error': str(e)}) return JsonResponse(company.to_json())
def hello3(request): jsonresult = { 'result': 'success', 'data': ['hello', 1, 2, True, ('a', 'b', 'c')] } return JsonResponse(jsonresult)
def requestDownload(request): if request.is_ajax(): if request.method == 'POST': json_data = json.loads(request.body) try: downRequest = downman_models.DownloadRequest() """ # if any of the resoures requires authorization: usage = json_data.get('downloadAuthorizationUsage', '') if not usage: # return an error pass """ if request.user and not request.user.is_anonymous(): downRequest.requested_by_user = request.user.username else: downRequest.requested_by_external = json_data.get( 'email', '') if not downRequest.requested_by_external: pass downRequest.language = get_language() downRequest.validity = downman_models.get_default_validity() downRequest.request_random_id = date.today().strftime( "%Y%m%d") + get_random_string(length=32) downRequest.json_request = request.body.decode("UTF-8") tracking_url = reverse('download-request-tracking', args=(downRequest.request_random_id, )) resources = json_data.get('resources', []) if downman_models.get_shopping_cart_max_items() > 0 and len( resources ) > downman_models.get_shopping_cart_max_items(): return JsonResponse({ "status": "error", 'error_message': "Invalid request" }) if len(resources) == 0 and json_data.get('request_desc'): downRequest.pending_authorization = True downRequest.generic_request = True shared_view_state = json_data.get('shared_view_state') shv_pid = shared_view_state.get('pid') shv_state = shared_view_state.get('view_state') shv_description = shared_view_state.get('description', '') shv_expiration = date(9999, 12, 31) shv = gvsigol_core.views.do_save_shared_view( shv_pid, shv_description, shv_state, shv_expiration, request.user, True) downRequest.shared_view_url = shv.url downRequest.save() for resource in json_data.get('resources', []): createResourceLocator(resource, downRequest) except: logger.exception('error creating DownloadRequest') raise try: #processDownloadRequest(downRequest.id) # this requires the Celery worker to be started, see README processDownloadRequest.apply_async( args=[downRequest.id], queue='resolvreq') #@UndefinedVariable notifyReceivedRequest.apply_async( args=[downRequest.id], queue='notify') #@UndefinedVariable except: logger.exception("error queuing task") downRequest.request_status = downman_models.DownloadRequest.QUEUEING_ERROR downRequest.save() return JsonResponse({ "status_code": downRequest.request_status, "status": downRequest.status_desc, 'download_id': downRequest.request_random_id, 'tracking_url': tracking_url }) # TODO: error handling return JsonResponse({"status": "error"})
def chart_area(request, pk): data, date_distance, checks = [], -1, 12 account = Account.objects.get(id=pk) if pk else None object = Income if '/users/dashboard/incomes-chart-area/' in request.get_full_path( ) else Spending first_object = object.objects.filter( user=request.user, account=account).first() if account else object.objects.filter( user=request.user).first() last_object = object.objects.filter( user=request.user, account=account).last() if account else object.objects.filter( user=request.user).last() if first_object and last_object: date_distance = (last_object.created_date - first_object.created_date).days if 1 <= date_distance <= 365: year, month = first_object.created_date.year, first_object.created_date.month while checks: date = datetime(year, month, 1) if month == 12: objects = object.objects.filter(user=request.user, account=account, created_date__year=year, created_date__month=month) data.append({date.strftime('%b'): assembly(objects)}) month = 1 year += 1 else: objects = object.objects.filter(user=request.user, account=account, created_date__year=year, created_date__month=month) data.append({date.strftime('%b'): assembly(objects)}) month += 1 checks -= 1 elif date_distance > 0: year, month = last_object.created_date.year - 1, last_object.created_date.month + 1 while checks: date = datetime(year, month, 1) if month == 12: objects = object.objects.filter(user=request.user, account=account, created_date__year=year, created_date__month=month) data.append({date.strftime('%b'): assembly(objects)}) month = 1 year += 1 else: objects = object.objects.filter(user=request.user, account=account, created_date__year=year, created_date__month=month) data.append({date.strftime('%b'): assembly(objects)}) month += 1 checks -= 1 elif date_distance == 0: year, month = first_object.created_date.year, first_object.created_date.month while checks: date = datetime(year, month, 1) if month == 12: objects = object.objects.filter(user=request.user, account=account, created_date__year=year, created_date__month=month) data.append({date.strftime('%b'): assembly(objects)}) month = 1 year += 1 else: objects = object.objects.filter(user=request.user, account=account, created_date__year=year, created_date__month=month) data.append({date.strftime('%b'): assembly(objects)}) month += 1 checks -= 1 return JsonResponse(data, safe=False)
def status(request): return JsonResponse({'status':'OK'})
def get_queryset(self): if self.request.is_ajax(): return JsonResponse(list(Doctor.objects.all().values('id_number', 'name', 'surname', 'clinic__doctor__name')), safe=False) return None
def modal_cookie(request): username = request.GET.get('username', None) return JsonResponse(username)
def wrapper(request, *args, **kwargs): if not request.session['issuperuser']: return JsonResponse({"code": 403, "err": "无权限"}) return func(request, *args, **kwargs)
def GetProfilePicture(data): username = data.GET.get('username') profilePic = User.objects.filter(username=username).first() profilePic = profilePic.profile.profile_picture.url print("sadfsdfsafasdfasdfasdfasdfasdfsd\n\n\n") return JsonResponse({"profile_picture": profilePic})
def getRooms(request): if request.method == 'GET': return JsonResponse({'rooms':roomMapper.getRooms()}) else: return JsonResponse({'getRoomsError': 'Resource only accepts GET requests'}, status=405)
def routes(request): if request.method == "GET": routes = Route.objects.all() serializer = RouteSerializer(routes, many=True) return JsonResponse(serializer.data, safe=False)
def article_view(request, pk): article = Article.objects.filter(pk=pk) data = list(article.values()) return JsonResponse(data, safe=False, json_dumps_params={'ensure_ascii': False})
def save_case(request): '''保存&更新case''' if request.method == "POST": case_id = request.POST.get('cid', "") url = request.POST.get('url', "") method = request.POST.get('method', "") per_type = request.POST.get('per_type', "") header = request.POST.get('header', "") per_value = request.POST.get('per_value', "") result_text = request.POST.get('result_text', "") assert_text = request.POST.get('assert_text', "") assert_type = request.POST.get('assert_type', "") module_id = request.POST.get('module_id', "") case_name = request.POST.get('case_name', "") if method == "get": method_int = 1 elif method == "post": method_int = 2 else: return JsonResponse({"code": 10101, "message": "请求方法错误"}) if per_type == "form": per_type_int = 1 elif per_type == "json": per_type_int = 2 else: return JsonResponse({"code": 10102, "message": "参数类型错误"}) if assert_type == "include": assert_type_int = 1 elif assert_type == "equal": assert_type_int = 2 else: return JsonResponse({"code": 10103, "message": "断言类型错误"}) if case_id == "": TestCase.objects.create(module_id=module_id, name=case_name, url=url, method=method_int, header=header, parameter_type=per_type_int, parameter_body=per_value, result=result_text, assert_type=assert_type_int, assert_text=assert_text, ) return JsonResponse({"code": 10200, "message": "create success"}) else: case = TestCase.objects.get(id=case_id) case.module_id = module_id case.name = case_name case.url = url case.method = method_int case.case.header = header case.parameter_type = per_type_int case.parameter_body = per_value case.result = result_text case.assert_type = assert_type_int case.assert_text = assert_text case.save() return JsonResponse({"code": 10200, "message": "save success"})
def goods_del(request,id): if request.method == 'POST': # ajax删除商品 JsonResponse Goods.objects.filter(pk=id).delete() return JsonResponse({'code':200,'msg':'请求成功'})
def get_conf(request): response = { "shopping_cart_max_items": downman_models.get_shopping_cart_max_items() } return JsonResponse(response)
def compiHistoryView(request): return JsonResponse({'Access_Token':'Hello'})
def view_endorsement_payload(request, endorsement_id): e = get_object_or_404(Endorsement, id=endorsement_id) return JsonResponse(e.payload())
def friendShowDetails(request, format=None): details = UserDetails.objects.get( userId__username=request.GET.get('username')) username = request.GET.get('username') full_name = User.objects.get(username=request.GET.get( 'username')).first_name + " " + User.objects.get( username=request.GET.get('username')).last_name img_url = details.profilePhoto.url occupation = details.occupation total_friends = UserFriends.objects.get(userId=UserDetails.objects.get( userId__username=request.GET.get('username'))).friends.all().count() curr_lat = details.current_lat curr_long = details.current_long formedAt = "" isFriend = False if (FriendsFormedDetails.objects.filter( Q(user__userId__username=request.GET.get('username')) | Q(friend_name__userId__username=request.GET.get('username'))). count() > 0): obj = FriendsFormedDetails.objects.get( Q(user__userId__username=request.GET.get('username'), friend_name__userId__username=request.user.username) | Q(friend_name__userId__username=request.GET.get('username'), user__userId__username=request.user.username)) formedAt = obj.formedAt isFriend = obj.friend_or_Request total_notes = NotesDetails.objects.filter( admin__userId__username=request.GET.get('username')).count() curr_ShowUserFriends = FriendsFormedDetails.objects.filter( Q(user__userId__username=request.GET.get('username'), friend_or_Request=True)).values('friend_name__userId') curr_ShowUserFriends1 = FriendsFormedDetails.objects.filter( Q(friend_name__userId__username=request.GET.get('username'), friend_or_Request=True)).values('user__userId') mutual_friends = FriendsFormedDetails.objects.filter( Q(friend_name__userId__username=request.user.username, user__userId__in=curr_ShowUserFriends) | Q(friend_name__userId__in=curr_ShowUserFriends, user__userId__username=request.user.username)).count() mutual_friends1 = FriendsFormedDetails.objects.filter( Q(friend_name__userId__username=request.user.username, user__userId__in=curr_ShowUserFriends1) | Q(friend_name__userId__in=curr_ShowUserFriends1, user__userId__username=request.user.username)).count() print(mutual_friends, mutual_friends1) return JsonResponse({ "username": username, "formedAt": formedAt, "isFriend": isFriend, "total_notes": total_notes, "img_url": img_url, "name": full_name, "occupation": occupation, "total_friends": total_friends, "curr_lat": curr_lat, "curr_long": curr_long, "mutual": mutual_friends, "mutual1": mutual_friends1, "status": "200" })
def wrapper(request, *args, **kwargs): if request.method != 'POST': return JsonResponse({"code": 405, "err": "方法不允许"}) return func(request, *args, **kwargs)
def get(self, request, *args, **kwargs): return JsonResponse({ "url": request.build_absolute_uri(), "status": 200, "data": [self.serialize(post) for post in self.get_queryset()], })
def searchable_list(request, *args, **kwargs): searchables = Searchable.objects.exclude(location_name='') serializer = SearchableSerializer(searchables, many=True) return JsonResponse(serializer.data, safe=False)