async def delete_post(self, task_message: DeletePostTaskMessage) -> bool:
post = get_object_or_none(Post, pk=task_message.post_id)
if not post:
logger.error('Post Not Found Post id {}'.format(
task_message.post_id))
return False
social_uid, access_token = self._get_vk_credentials(post.user)
method = WallDeleteMethod(priority=task_message.priority,
access_token=access_token,
owner_id=format_group_id(
post.group.group_id),
post_id=post.post_id)
response_dict = await method.execute()
status = self.check_response(post,
response_dict,
fail_status=Post.FAILED_DELETE,
delete_status=Post.IS_DELETED)
if not status:
return False
post.status = Post.IS_DELETED if task_message.delete_status == Post.IS_DELETED else task_message.delete_status
post.save()
return True
async def delete_video(self, task_message: DeleteVideoTaskMessage) -> bool:
video = get_object_or_none(Video, pk=task_message.video_id)
if not video:
logger.error('Video Not Found vid: {}'.format(
task_message.video_id))
return False
social_uid, access_token = self._get_vk_credentials(video.user)
method = VideoDeleteMethod(access_token=access_token,
video_id=video.vid,
owner_id=video.owner,
priority=task_message.priority)
response_dict = await method.execute()
status = self.check_response(video,
response_dict,
fail_status=Video.DELETE_FAIL,
delete_status=Video.IS_DELETED)
if not status:
return False
video.status = Video.IS_DELETED
video.save()
return True
def form_valid(self, form):
# This method is called when valid form data has been POSTed.
# It should return an HttpResponse.
date_of_birth = form.cleaned_data.get('date_of_birth')
gender = form.cleaned_data.get('gender')
address = form.cleaned_data.get('address')
zip_code = form.cleaned_data.get('zip_code')
city = form.cleaned_data.get('city')
state = form.cleaned_data.get('state')
email = form.cleaned_data.get('email')
cell_phone = form.cleaned_data.get('cell_phone')
emergency_contact_name = form.cleaned_data.get(
'emergency_contact_name')
emergency_contact_phone = form.cleaned_data.get(
'emergency_contact_phone')
patient_id = self.request.session.get('checkedin_patient')
patient = get_object_or_none(Patient, pk=patient_id)
if patient:
access_token = self.request.session.get('access_token')
patient_api = PatientEndpoint(access_token)
updated_fields = {
'email': email,
'gender': gender,
'date_of_birth': date_of_birth,
'address': address,
'city': city,
'state': state,
'zip_code': zip_code,
'cell_phone': cell_phone,
}
response = {}
try:
response = patient_api.update(patient_id, updated_fields)
updated_patient, created = update_or_create_object(
Patient, updated_fields, pk=patient_id)
return super(DemographicsView, self).form_valid(form)
except APIException:
context = {
'form':
form,
'message':
'Trouble updating your data, Please consult a staff member',
}
return render(self.request, "checkin.html", context)
context = {
'form':
form,
'message':
'Patient demographics not updated, please check with attendent',
}
return render(self.request, "checkin.html", context)
def form_valid(self, form):
# This method is called when valid form data has been POSTed.
# It should return an HttpResponse.
first_name = form.cleaned_data.get('first_name')
last_name = form.cleaned_data.get('last_name')
# dob = form.cleaned_data.get('date_of_birth')
# TODO: Use ssn to get the patient
ssn = form.cleaned_data.get('social_security_number')
patient = get_object_or_none(Patient,
first_name=first_name,
last_name=last_name,
social_security_number=str(ssn))
if patient:
access_token = self.request.session['access_token']
apppointment_api = AppointmentEndpoint(access_token)
appointments = Appointment.today.filter(patient=patient.id)
updateddate = datetime.now().isoformat()
for appointment in appointments:
updated_fields = {
'appointment_status': 'Checked In',
'checkedin_status': True,
'checkedin_time': updateddate,
}
data = {'status': 'Checked In', 'updated_at': updateddate}
response = {}
try:
response = apppointment_api.update(appointment.id, data)
updated_appointment, created = update_or_create_object(
Appointment, updated_fields, pk=appointment.id)
self.request.session['checkedin_patient'] = patient.id
return super(CheckinView, self).form_valid(form)
except APIException:
context = {
'form':
form,
'message':
'Trouble checking you in, Please consult a staff member',
}
return render(self.request, "checkin.html", context)
context = {
'form': form,
'message': 'Appointment for the Patient not found',
}
return render(self.request, "checkin.html", context)
context = {
'form': form,
'message': 'Patient not found',
}
return render(self.request, "checkin.html", context)
def serve_document(request, pk, type=None, order=None):
if request.path.startswith('/api/'):
DigestAuthentication().is_authenticated(request)
doc = get_object_or_404(Document, pk=pk)
#pack = doc.packs.objects.get(type='pdf')
object = None
if type:
type = str(type)
if type.endswith('/'):
type = type[:-1]
if not order:
order = '0'
if order.endswith('/'):
order = order[:-1]
object = get_object_or_none(DerivedFile,
pack__derived_from=doc, pack__type__exact=type, order=int(order))
# If you document is a pdf and they want a pdf, serve the original
if (type == 'pdf') and (not object) and (doc.file.name.lower().endswith('.pdf')):
object = doc
else:
object = doc
if not object:
raise Http404
if settings.DEBUG:
return serve(request, object.file.name, settings.MEDIA_ROOT)
else:
fullpath = os.path.join(settings.MEDIA_ROOT, object.file.name)
mimetype, encoding = mimetypes.guess_type(fullpath)
mimetype = mimetype or 'application/octet-stream'
response = HttpResponse(mimetype=mimetype)
if encoding:
response["Content-Encoding"] = encoding
try:
response['X-Accel-Redirect'] = object.file.name
except UnicodeEncodeError:
raise Http404
return response
def get_and_store_data(self, doctor=None, date=None):
params = {}
# get all the appointments for today from the appointments api endpoint
if doctor:
params['doctor'] = doctor.id
else:
doctor = utils.get_object_first(Doctor)
if date == None:
date = datetime.now(tz=pytz.timezone(
doctor.timezone)).strftime('%Y-%m-%d')
appointments = self.list(params=params, date=date)
for appointment in appointments:
if appointment['status'] in ('Cancelled', 'Rescheduled'):
continue
patient = utils.get_object_or_none(
Patient, id=appointment['patient'])
patient_name = '{}, {}'.format(
patient.first_name,
patient.last_name
)
updated_fields = {
'patient': patient,
'patient_name': patient_name,
'doctor': doctor,
'appointment_time': appointment['scheduled_time'],
'appointment_status': appointment['status'],
'duration': appointment['duration'],
'exam_room': appointment['exam_room'],
'reason': appointment['reason'],
}
if appointment['status'] in ('Complete', 'No Show'):
updated_fields['queue_status'] = 'past'
if appointment['status'] in ('Checked In', 'Arrived'):
updated_fields['checkedin_status'] = True
updated_appointment, created = utils.update_or_create_object(
Appointment, updated_fields, pk=appointment['id'])
async def bulk_delete_post(self, task_message: BulkDeletePostTaskMessage) -> bool:
user = get_object_or_none(User, pk=task_message.user_id)
if not user:
logger.error('User not found {}'.format(task_message.user_id))
return False
social_uid, access_token = self._get_vk_credentials(user)
posts_queryset = Post.objects.filter(pk__in=task_message.post_ids)
posts_list = list(posts_queryset)
call_method_list = []
post_splits = split_list(posts_list, 25)
for post_split in post_splits:
for post in post_split:
args = {
VK_MESSAGE_KEY.OWNER_ID: format_group_id(post.group.group_id),
VK_MESSAGE_KEY.POST_ID: post.post_id
}
call = ExecuteMethod.construct(
ExecuteMethod.WALL_ENTITY,
ExecuteMethod.DELETE_METHOD,
json.dumps(args)
)
call_method_list.append(call)
method = ExecuteMethod(
priority=task_message.priority,
access_token=access_token,
code=ExecuteMethod.construct_code(call_method_list)
)
response_dict = await method.execute()
if not response_dict:
error = DefaultError(
error_key=ErrorCode.RESPONSE_IS_EMPTY_KEY,
text=ErrorCode.RESPONSE_IS_EMPTY_TEXT
)
for post in posts_list:
post.vk_response = error.to_json()
post.status = Post.FAILED_DELETE
post.save()
return False
if VK_MESSAGE_KEY.ERROR in response_dict:
# берем ошибку по коду ответа (только в execute)
error_dict = response_dict.get(VK_MESSAGE_KEY.ERROR)
error = DefaultError.get_error_from_response(
error_dict=error_dict,
error_key=VK_MESSAGE_KEY.ERROR_CODE
)
sentry_error = {
'error': response_dict,
'error_msg': error,
'user_id': user.pk,
'username': user.get_full_name()
}
sentry_logger.error(msg=sentry_error)
for post in posts_list:
post.vk_response = error
post.status = Post.FAILED_DELETE
post.save()
return False
response_list = response_dict.get(VK_MESSAGE_KEY.RESPONSE)
if VK_MESSAGE_KEY.EXECUTE_ERRORS in response_dict:
error_list = response_dict.get(VK_MESSAGE_KEY.EXECUTE_ERRORS)
sentry_logger.warning(msg="Execute errors while post deleting", extra={
'error': response_dict,
'user_id': user.pk,
'username': user.get_full_name()
})
false_response_posts = []
# порядок постов в сплите совпадает с порядко постов в ответе
for index, post in enumerate(post_split):
if not response_list[index]:
false_response_posts.append(post)
if false_response_posts:
for index, post in enumerate(false_response_posts):
concrete_error = error_list[index]
concrete_error_msg = DefaultError.get_error_from_response(
error_dict=concrete_error,
error_key=VK_MESSAGE_KEY.ERROR_MSG
)
# error code 7, Access denied распознаем, как удаленные
error_message = concrete_error.get(VK_MESSAGE_KEY.ERROR_MSG)
if error_message == ErrorCode.WALL_DELETE_ACCESS_DENIED_KEY:
post.status = Post.IS_DELETED
else:
post.status = Post.FAILED_DELETE
post.vk_response = concrete_error_msg
post.save()
self.log_to_sentry(post, concrete_error_msg, level='warning')
else:
for index, post in enumerate(post_split):
if response_list[index]:
post.status = Post.IS_DELETED
post.save()
call_method_list[:] = []
posts_queryset.update(status=Post.IS_DELETED)
return True
def form_valid(self, form):
context = self.get_context_data()
date = form.cleaned_data['date']
context['rate_asked'] = get_object_or_none(Exchange, exchange_date=date)
return super(ExchangeFormView, self).ajax_render_to_response(context)
def setup(self, *args, **kwargs):
super(LandingView, self).setup(*args, **kwargs)
self.referral_id = self.request.GET.get('link')
self.referral_object = get_object_or_none(Referral, slug=self.referral_id)
async def bulk_delete_video(
self, task_message: BulkDeleteVideoTaskMessage) -> bool:
user = get_object_or_none(User, pk=task_message.user_id)
if not user:
logger.error('User not found {}'.format(task_message.user_id))
return False
social_uid, access_token = self._get_vk_credentials(user)
videos_queryset = Video.objects.filter(pk__in=task_message.video_ids)
video_list = list(videos_queryset)
call_method_list = []
video_splits = split_list(video_list, 25)
for video_split in video_splits:
for video in video_split:
args = {
VK_MESSAGE_KEY.OWNER_ID: video.owner,
VK_MESSAGE_KEY.VIDEO_ID: video.vid
}
call = ExecuteMethod.construct(ExecuteMethod.VIDEO_ENTITY,
ExecuteMethod.DELETE_METHOD,
json.dumps(args))
call_method_list.append(call)
method = ExecuteMethod(
priority=task_message.priority,
access_token=access_token,
code=ExecuteMethod.construct_code(call_method_list))
response_dict = await method.execute()
if not response_dict:
error = DefaultError(error_key=ErrorCode.RESPONSE_IS_EMPTY_KEY,
text=ErrorCode.RESPONSE_IS_EMPTY_TEXT)
for video in video_list:
video.vk_response = error.to_json()
video.status = Video.DELETE_FAIL
video.save()
return False
if VK_MESSAGE_KEY.ERROR in response_dict:
error_dict = response_dict.get(VK_MESSAGE_KEY.ERROR)
error_msg = DefaultError.get_error_from_response(
error_dict=error_dict, error_key=VK_MESSAGE_KEY.ERROR_CODE)
sentry_logger.warning(msg="Error while deleting videos",
extra={
'error': response_dict,
'error_msg': error_msg,
'user_id': user.pk,
'username': user.get_full_name()
})
for video in video_list:
video.vk_response = error_msg
video.status = Video.DELETE_FAIL
video.save()
return False
response_list = response_dict.get(VK_MESSAGE_KEY.RESPONSE)
if VK_MESSAGE_KEY.EXECUTE_ERRORS in response_dict:
error_list = response_dict.get(VK_MESSAGE_KEY.EXECUTE_ERRORS)
false_response_videos = []
# порядок постов в сплите совпадает с порядком постов в ответе
for index, video in enumerate(video_split):
if not response_list[index]:
false_response_videos.append(video)
if false_response_videos:
for index, video in enumerate(false_response_videos):
concrete_error = error_list[index]
concrete_error_msg = DefaultError.get_error_from_response(
error_dict=concrete_error,
error_key=VK_MESSAGE_KEY.ERROR_MSG)
# error code 7, Access denied распознаем, как удаленные
error_message = concrete_error.get(
VK_MESSAGE_KEY.ERROR_MSG)
if error_message == ErrorCode.ACCESS_DENIED_KEY:
video.status = Video.IS_DELETED
else:
video.status = Video.DELETE_FAIL
video.vk_response = concrete_error_msg
video.save()
self.log_to_sentry(video,
concrete_error_msg,
level='warning')
else:
for index, video in enumerate(video_split):
if response_list[index]:
video.status = Video.IS_DELETED
video.save()
call_method_list[:] = []
videos_queryset.update(status=Video.IS_DELETED)
return True