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 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
def decode_json(cls, text):
return json.loads(text)
