def _set_calculated_deadline(self, deadline, date, initial, user, preview, preview_attribute_data={}): try: if preview: try: identifier = deadline.attribute.identifier except AttributeError: identifier = None project_deadline = preview_attribute_data.get( identifier) or self.deadlines.get(deadline=deadline) else: project_deadline = self.deadlines.get(deadline=deadline) except ProjectDeadline.DoesNotExist: return if project_deadline and date: if preview: return date project_deadline.date = date project_deadline.save() if deadline.attribute: with transaction.atomic(): old_value = json.loads( json.dumps( self.attribute_data.get( deadline.attribute.identifier), default=str, )) new_value = json.loads(json.dumps(date, default=str)) self.update_attribute_data( \ {deadline.attribute.identifier: date}) self.save() if old_value != new_value: action.send( user or self.user, verb=verbs.UPDATED_ATTRIBUTE, action_object=deadline.attribute, target=self, attribute_identifier=deadline.attribute.identifier, old_value=old_value, new_value=new_value, ) return date
def __init__(self, index_type): """ We will be prefixing all aliases with the index name to ensure uniquity, otherwise, we may end up with aliases representing more than one index which may throw off our search results. """ self.index_type = index_type self.index_name = self._generate_index_name() self.alias_prefix = self.index_name self.client = Elasticsearch([settings.ES_HOSTNAME], timeout=settings.ES_TIMEOUT) self.template = retrieve_index_template(f"{self.index_type}_template") self.mappings = json.loads(self.template)["mappings"] self.etl_config = { "index_name": self.index_name, "query_alias_prefix": self.alias_prefix, "verbose": False, "write_alias": self.index_name + "-alias", } self.worker = TaskSpec( base_table=None, base_table_id=None, execute_sql_func=execute_sql_statement, field_for_es_id="award_id" if self.index_type == "award" else "transaction_id", index=self.index_name, is_incremental=None, name=f"{self.index_type} test worker", partition_number=None, primary_key="award_id" if self.index_type == "award" else "transaction_id", sql=None, transform_func=None, view=None, )
def get_request_body(request): try: content = request.body.decode() content = json.loads(request.body.decode("utf-8")) if content else {} except: raise ValueError return content
def my_ajax_view(request): csrf_middleware = CsrfViewMiddleware() response_data = {} if request.method == 'GET': # Get form definition form = ProjectForm() elif request.raw_post_data: request.POST = json.loads(request.raw_post_data) # Process request for CSRF csrf_middleware.process_view(request, None, None, None) form_data = request.POST.get('data', {}) form = ProjectForm(form_data) if form.is_valid(): form.save() field_configuration = { 'include': ['title','duration'], } remote_form = RemoteForm(form, **field_configuration) # Errors in response_data['non_field_errors'] and response_data['errors'] response_data.update(remote_form.as_dict()) response = HttpResponse( json.dumps(response_data, cls=DjangoJSONEncoder), mimetype="application/json" ) # Process response for CSRF csrf_middleware.process_response(request, response) return response
def test_session_expiry_logout_view_during_de_1(self): encoded_result_form_data_entry_start_time =\ json.loads(json.dumps(timezone.now(), cls=DjangoJSONEncoder)) tally = create_tally() tally.users.add(self.user) result_form = create_result_form(form_state=FormState.DATA_ENTRY_1, tally=tally) data_entry_url = 'enter-results/%s/' % tally.pk request = self.factory.get(data_entry_url) request.user = self.user # Adding session middleware = SessionMiddleware() middleware.process_request(request) request.session.save() request.session['encoded_result_form_data_entry_start_time'] =\ encoded_result_form_data_entry_start_time request.session['result_form'] =\ result_form.pk response = views.session_expiry_logout_view(request) self.assertEqual(response.status_code, 302) self.assertEquals( request.session['encoded_result_form_data_entry_start_time'], encoded_result_form_data_entry_start_time) self.assertEquals( request.session['result_form'], result_form.pk)
def setUp(self): self.factory = RequestFactory() self._create_permission_groups() self._create_and_login_user() self.tally = create_tally() self.tally.users.add(self.user) self.encoded_result_form_corrections_start_time =\ json.loads(json.dumps(timezone.now(), cls=DjangoJSONEncoder))
def get_context_data(self, **kwargs): context = super(CenterDetailsView, self).get_context_data(**kwargs) context['tally_id'] = self.kwargs.get('tally_id') context['form_action'] = '' context['header_text'] = _('Intake') self.request.session[ 'encoded_result_form_intake_start_time'] =\ json.loads(json.dumps(timezone.now(), cls=DjangoJSONEncoder)) return context
def handle(self, *args, **options): project_id = options.get("id") if project_id: try: projects = [Project.objects.get(pk=project_id)] except Project.DoesNotExist: projects = Project.objects.all() else: projects = Project.objects.all() for project in projects: old_deadlines = project.deadlines.all() project.update_deadlines() updated_deadlines = old_deadlines.union(project.deadlines.all()) for dl in updated_deadlines: try: new_date = project.deadlines.get(deadline=dl.deadline).date except ProjectDeadline.DoesNotExist: new_date = None try: old_date = old_deadlines.get(deadline=dl.deadline).date except ProjectDeadline.DoesNotExist: old_date = None old_value = json.loads(json.dumps(old_date, default=str)) new_value = json.loads(json.dumps(new_date, default=str)) if old_value != new_value: action.send( project.user, verb=verbs.UPDATED_DEADLINE, action_object=dl.deadline, target=project, deadline_abbreviation=dl.deadline.abbreviation, old_value=old_value, new_value=new_value, )
def pedometer(request): if request.method == 'POST': body_unicode = request.body.decode('utf-8') body = json.loads(body_unicode) way = Way.objects.get(id=1) way.duration = body['duration'] way.steps = body['steps'] way.save() # mydict = {'date': datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%S.%LZ')} mydict = {'steps': 1, 'duration': 1} nowdatetime = json.dumps(mydict) return JsonResponse(mydict)
def post(self, *args, **kwargs): self.request.session[ 'encoded_result_form_clearance_start_time'] =\ json.loads(json.dumps(timezone.now(), cls=DjangoJSONEncoder)) tally_id = kwargs.get('tally_id') post_data = self.request.POST pk = post_data['result_form'] result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id) form_in_state(result_form, FormState.CLEARANCE) self.request.session['result_form'] = result_form.pk return redirect(self.success_url, tally_id=tally_id)
def get_context_data(self, **kwargs): self.request.session[ 'encoded_result_form_clearance_start_time'] =\ json.loads(json.dumps(timezone.now(), cls=DjangoJSONEncoder)) tally_id = self.kwargs.get('tally_id') context = super(CreateClearanceView, self).get_context_data(**kwargs) context['tally_id'] = tally_id context['header_text'] = _('Create Clearance') context['form_action'] = reverse(self.success_url, kwargs={'tally_id': tally_id}) return context
def handle(self, *args, **options): project_id = options.get("id") overwrite_all = options.get("overwrite_all") if project_id: try: projects = [Project.objects.get(pk=project_id)] except Project.DoesNotExist: projects = Project.objects.all() else: projects = Project.objects.all() for project in projects: with transaction.atomic(): if overwrite_all: cleared_attributes = [ deadline.attribute for deadline in Deadline.objects.all() if deadline.attribute and \ project.attribute_data.get(deadline.attribute.identifier) ] else: cleared_attributes = [ project_dl.deadline.attribute for project_dl in project.deadlines.all() if project_dl.deadline.attribute ] project.update_attribute_data( {attr.identifier: None for attr in cleared_attributes}) project.save() for attribute in cleared_attributes: old_value = json.loads( json.dumps( project.attribute_data.get(attribute.identifier), default=str, )) new_value = None if old_value != new_value: action.send( project.user, verb=verbs.UPDATED_ATTRIBUTE, action_object=attribute, target=project, attribute_identifier=attribute.identifier, old_value=old_value, new_value=new_value, ) project.deadlines.all().delete()
def get_context_data(self, **kwargs): tally_id = self.kwargs.get('tally_id') context = super(CorrectionView, self).get_context_data(**kwargs) context['tally_id'] = tally_id context['form_action'] = '' context['header_text'] = _('Corrections') self.request.session[ 'encoded_result_form_corrections_start_time'] =\ json.loads(json.dumps(timezone.now(), cls=DjangoJSONEncoder)) return context
def daily_steps(request): if request.method == 'GET': dailysteps = DailySteps.objects.all() data = [] for day in dailysteps: data.append({'day': day.day, 'steps': day.steps}) return JsonResponse(data, safe=False) elif request.method == 'POST': body_unicode = request.body.decode('utf-8') body = json.loads(body_unicode) daysteps = DailySteps(day=body['day'], steps=body['steps']) daysteps.save() return JsonResponse({'result': 'ok'})
def _log_update(self, attribute, project, value, converted, prefix): old_value = json.loads(json.dumps(value, default=str)) new_value = json.loads(json.dumps(converted, default=str)) labels = {} if attribute.value_type == Attribute.TYPE_CHOICE: if new_value: labels = { **labels, **self._get_labels( new_value if isinstance(new_value, list) else [ new_value ], attribute, ) } if old_value: labels = { **labels, **self._get_labels( old_value if isinstance(old_value, list) else [ old_value ], attribute, ) } if old_value != new_value: action.send( project.user, verb=verbs.UPDATED_ATTRIBUTE, action_object=attribute, target=project, attribute_identifier=prefix + attribute.identifier, old_value=old_value, new_value=new_value, labels=labels, )
def day_steps(request, day_id): if request.method == 'GET': daysteps = DailySteps.objects.get(day=day_id) return JsonResponse({'day': daysteps.day, 'steps': daysteps.steps}) elif request.method == 'PUT': daysteps = DailySteps.objects.get(day=day_id) body_unicode = request.body.decode('utf-8') body = json.loads(body_unicode) daysteps.steps = body['steps'] daysteps.save() return JsonResponse({'result': 'ok'}) elif request.method == 'DELETE': daysteps = DailySteps.objects.get(day=day_id) daysteps.delete() return JsonResponse({'result': 'ok'})
def __init__(self, request): self.request = request au = request.headers.get('Authorization', '') if au: au = au.split(' ') if not self.AuthToken(au): self.err_d('Token ne nayden') if self.request.method == 'GET': self.sid = self.request.GET elif self.request.method == 'POST': self.sid = self.request.GET if self.request.body: self.sl = json.loads(self.request.body) self.post = True else: self.err_d('Metod ne opredelen')
def get(self, *args, **kwargs): tally_id = kwargs.get('tally_id') pk = self.request.session['result_form'] result_form = get_object_or_404(ResultForm, pk=pk, tally__id=tally_id) form_class = self.get_form_class() audit = result_form.audit form = AuditForm( instance=audit) if audit else self.get_form(form_class) self.request.session[ 'encoded_result_form_audit_start_time'] =\ json.loads(json.dumps(timezone.now(), cls=DjangoJSONEncoder)) return self.render_to_response( self.get_context_data(form=form, result_form=result_form, is_clerk=is_clerk(self.request.user), tally_id=tally_id))
def get_context_data(self, **kwargs): context = super(DataEntryView, self).get_context_data(**kwargs) user = self.request.user if user_is_data_entry_1(user): entry_type = 1 elif user_is_data_entry_2(user): entry_type = 2 else: entry_type = 'Admin' context['tally_id'] = self.kwargs.get('tally_id') context['form_action'] = '' context['header_text'] = _('Data Entry %s') % entry_type if entry_type != 'Admin': self.request.session[ 'encoded_result_form_data_entry_start_time'] =\ json.loads(json.dumps(timezone.now(), cls=DjangoJSONEncoder)) return context
def raw_receive(self, message, **kwargs): if "text" in message: self.receive(json.loads(message['text']), **kwargs) else: raise ValueError("No text section for incoming WebSocket frame!")
def decode_json(cls, text): return json.loads(text)
def setUp(self): self.factory = RequestFactory() self._create_permission_groups() self.encoded_result_form_data_entry_start_time =\ json.loads(json.dumps(timezone.now(), cls=DjangoJSONEncoder))
def handle_instance_form(request, app_label, model_name, instance_id=None): if not request.user.is_authenticated(): return HttpResponse('Unauthorized', status=401) csrf_middleware = CsrfViewMiddleware() response_data = { 'meta': { 'app_label': app_label, 'model_name': model_name }, 'admin': {} } instance = None for model, model_admin in site._registry.items(): if app_label != model._meta.app_label or model_name != model._meta.module_name: continue field_configuration = { 'include': model_admin.fields or [], 'exclude': model_admin.exclude or [], 'ordering': model_admin.fields or [], 'fieldsets': model_admin.fieldsets or {}, 'readonly': model_admin.readonly_fields or [] } if instance_id is not None: response_data[instance_id] = instance_id try: instance = model.objects.get(pk=instance_id) except model.DoesNotExist: raise Http404('Invalid instance ID') current_model = model CurrentModelForm = None if CurrentModelForm is None: class CurrentModelForm(forms.ModelForm): class Meta: model = current_model if request.method == 'GET': # Return instance form for given model name # Return initial values if instance ID is supplied, otherwise return empty form if instance is None: form = CurrentModelForm() else: form = CurrentModelForm(instance=instance) for field_name, initial_value in form.initial.items(): if initial_value is not None and field_name in form.fields: form.fields[field_name].initial = initial_value response_data['csrfmiddlewaretoken'] = get_token(request) remote_form = RemoteForm(form, **field_configuration) response_data.update(remote_form.as_dict()) elif request.raw_post_data: request.POST = json.loads(request.raw_post_data) csrf_middleware.process_view(request, None, None, None) if 'data' in request.POST: if instance_id is None: form = CurrentModelForm(request.POST['data']) else: form = CurrentModelForm(request.POST['data'], instance=instance) if form.is_valid(): if not request.POST['meta']['validate']: form.save() remote_form = RemoteForm(form, **field_configuration) response_data.update(remote_form.as_dict()) response = HttpResponse(json.dumps(response_data, cls=LazyEncoder), mimetype="application/json") csrf_middleware.process_response(request, response) return response