def resolve_claims(self, info, **kwargs):
if not info.context.user.has_perms(ClaimConfig.gql_query_claims_perms):
raise PermissionDenied(_("unauthorized"))
query = Claim.objects
code_is_not = kwargs.get('codeIsNot', None)
if code_is_not:
query = query.exclude(code=code_is_not)
variance = kwargs.get('diagnosisVariance', None)
if variance:
from core import datetime, datetimedelta
last_year = datetime.date.today() + datetimedelta(years=-1)
diag_avg = Claim.objects \
.filter(*filter_validity(**kwargs)) \
.filter(date_claimed__gt=last_year) \
.values('icd__code') \
.filter(icd__code=OuterRef('icd__code')) \
.annotate(diag_avg=Avg('approved')).values('diag_avg')
variance_filter = Q(claimed__gt=(1 + variance / 100) *
Subquery(diag_avg))
if not ClaimConfig.gql_query_claim_diagnosis_variance_only_on_existing:
diags = Claim.objects \
.filter(*filter_validity(**kwargs)) \
.filter(date_claimed__gt=last_year).values('icd__code').distinct()
variance_filter = (variance_filter | ~Q(icd__code__in=diags))
query = query.filter(variance_filter)
return gql_optimizer.query(query.all(), info)
def async_mutate(cls, user, **data):
try:
if not user.has_perms(
ClaimConfig.gql_mutation_update_claims_perms):
raise PermissionDenied(_("unauthorized"))
queryset = ClaimAttachment.objects.filter(*filter_validity())
if settings.ROW_SECURITY:
from location.models import UserDistrict
dist = UserDistrict.get_user_districts(user._u)
queryset = queryset.select_related("claim") \
.filter(
claim__health_facility__location__id__in=[
l.location_id for l in dist]
)
attachment = queryset \
.filter(id=data['id']) \
.first()
if not attachment:
raise PermissionDenied(_("unauthorized"))
attachment.delete_history()
return None
except Exception as exc:
return [{
'message':
_("claim.mutation.failed_to_delete_claim_attachment") % {
'code': attachment.claim.code,
'filename': attachment.filename
},
'detail': str(exc)
}]
def async_mutate(cls, user, **data):
try:
if user.is_anonymous or not user.has_perms(
ClaimConfig.gql_mutation_update_claims_perms):
raise PermissionDenied(_("unauthorized"))
if "client_mutation_id" in data:
data.pop('client_mutation_id')
if "client_mutation_label" in data:
data.pop('client_mutation_label')
claim_uuid = data.pop("claim_uuid")
queryset = Claim.objects.filter(*filter_validity())
if settings.ROW_SECURITY:
dist = UserDistrict.get_user_districts(user._u)
queryset = queryset.filter(health_facility__location__id__in=[
l.location_id for l in dist
])
claim = queryset.filter(uuid=claim_uuid).first()
if not claim:
raise PermissionDenied(_("unauthorized"))
create_attachment(claim.id, data)
return None
except Exception as exc:
return [{
'message': _("claim.mutation.failed_to_attach_document") % {
'code': claim.code
},
'detail': str(exc)
}]
def _resolve_insuree(info, **kwargs):
if not info.context.user.has_perms(InsureeConfig.gql_query_insurees_perms):
raise PermissionDenied(_("unauthorized"))
return Insuree.objects.get(
Q(chf_id=kwargs.get('chfId')),
*filter_validity(**kwargs)
)
def resolve_insuree_family_members(self, info, **kwargs):
if not info.context.user.has_perms(InsureeConfig.gql_query_insurees_perms):
raise PermissionDenied(_("unauthorized"))
insuree = Query._resolve_insuree(info=info, **kwargs)
return Insuree.objects.filter(
Q(family=insuree.family),
*filter_validity(**kwargs)
).order_by('-head')
def prices(element, parent, child, element_id, **kwargs):
list_id = kwargs.get(element_id)
if list_id is None:
return []
element_list = element.objects.filter(Q(**{parent: list_id}),
*filter_validity(**kwargs))
return [
PriceCompactGQLType(id=getattr(e, child), p=e.price_overrule)
for e in element_list.all()
]
def resolve_claims(self, info, **kwargs):
if (not info.context.user.has_perms(ClaimConfig.gql_query_claims_perms)
and settings.ROW_SECURITY):
raise PermissionDenied(_("unauthorized"))
query = Claim.objects
code_is_not = kwargs.get("code_is_not", None)
if code_is_not:
query = query.exclude(code=code_is_not)
variance = kwargs.get("diagnosisVariance", None)
items = kwargs.get("items", None)
services = kwargs.get("services", None)
if items:
query = query.filter(items__item__code__in=items)
if services:
query = query.filter(services__service__code__in=services)
json_ext = kwargs.get("json_ext", None)
if json_ext:
query = query.filter(json_ext__jsoncontains=json_ext)
if variance:
from core import datetime, datetimedelta
last_year = datetime.date.today() + datetimedelta(years=-1)
diag_avg = (Claim.objects.filter(*filter_validity(
**kwargs)).filter(
date_claimed__gt=last_year).values("icd__code").filter(
icd__code=OuterRef("icd__code")).annotate(
diag_avg=Avg("approved")).values("diag_avg"))
variance_filter = Q(claimed__gt=(1 + variance / 100) *
Subquery(diag_avg))
if not ClaimConfig.gql_query_claim_diagnosis_variance_only_on_existing:
diags = (Claim.objects.filter(*filter_validity(
**kwargs)).filter(date_claimed__gt=last_year).values(
"icd__code").distinct())
variance_filter = variance_filter | ~Q(icd__code__in=diags)
query = query.filter(variance_filter)
return gql_optimizer.query(query.all(), info)
def resolve_claim_admins_str(self, info, **kwargs):
if not info.context.user.has_perms(
ClaimConfig.gql_query_claim_admins_perms):
raise PermissionDenied(_("unauthorized"))
filters = [*filter_validity(**kwargs)]
str = kwargs.get('str')
if str is not None:
filters += [
Q(code__icontains=str) | Q(last_name__icontains=str)
| Q(other_names__icontains=str)
]
return ClaimAdmin.filter_queryset().filter(*filters)
def resolve_items_pricelists(self, info, **kwargs):
if not info.context.user.has_perms(
MedicalPricelistConfig.gql_query_pricelists_medical_items_perms
):
raise PermissionDenied(_("unauthorized"))
filters = []
show_history = kwargs.get("show_history", False)
if not show_history:
filters = [*filter_validity(**kwargs)]
location_uuid = kwargs.get("location__uuid")
if location_uuid is not None:
filters += [
Q(location__uuid=location_uuid)
| Q(location__parent__uuid=location_uuid)
]
query = ItemsPricelist.objects.filter(*filters).order_by("name")
return gql_optimizer.query(query.all(), info)
def attach(request):
queryset = ClaimAttachment.objects.filter(*core.filter_validity())
if settings.ROW_SECURITY:
from location.models import UserDistrict
dist = UserDistrict.get_user_districts(request.user._u)
queryset = queryset.select_related("claim")\
.filter(
claim__health_facility__location__id__in=[
l.location_id for l in dist]
)
attachment = queryset\
.filter(id=request.GET['id'])\
.first()
if not attachment:
raise PermissionDenied(_("unauthorized"))
if ClaimConfig.claim_attachments_root_path and attachment.url is None:
response = HttpResponse(status=404)
return response
if not ClaimConfig.claim_attachments_root_path and attachment.document is None:
response = HttpResponse(status=404)
return response
response = HttpResponse(content_type=(
"application/x-binary" if attachment.mime is None else attachment.mime
))
response[
'Content-Disposition'] = 'attachment; filename=%s' % attachment.filename
if ClaimConfig.claim_attachments_root_path:
f = open(
'%s/%s' %
(ClaimConfig.claim_attachments_root_path, attachment.url), "r")
response.write(f.read())
f.close()
else:
response.write(base64.b64decode(attachment.document))
return response
def fetch(self, uuid):
from .models import Claim
queryset = Claim.objects.filter(*core.filter_validity())
if settings.ROW_SECURITY:
from location.models import UserDistrict
dist = UserDistrict.get_user_districts(self.user._u)
queryset = queryset.filter(health_facility__location__id__in=[
l.location_id for l in dist
])
claim = queryset\
.select_related('health_facility') \
.select_related('insuree') \
.filter(uuid=uuid)\
.first()
if not claim:
raise PermissionDenied(_("unauthorized"))
return {
"code": claim.code,
"visitDateFrom":
claim.date_from.isoformat() if claim.date_from else None,
"visitDateTo":
claim.date_to.isoformat() if claim.date_to else None,
"claimDate":
claim.date_claimed.isoformat() if claim.date_claimed else None,
"healthFacility": str(claim.health_facility),
"insuree": str(claim.insuree),
"claimAdmin": str(claim.admin) if claim.admin else None,
"icd": str(claim.icd),
"icd1": str(claim.icd1) if claim.icd_1 else None,
"icd2": str(claim.icd1) if claim.icd_2 else None,
"icd3": str(claim.icd1) if claim.icd_3 else None,
"icd4": str(claim.icd1) if claim.icd_4 else None,
"guarantee": claim.guarantee_id,
"visitType": claim.visit_type,
"claimed": claim.claimed,
"services": [formatClaimService(s) for s in claim.services.all()],
"items": [formatClaimItem(i) for i in claim.items.all()],
}
def get_queryset(cls, queryset, info):
queryset = queryset.filter(*filter_validity())
return queryset
def filter_queryset(cls, queryset=None):
if queryset is None:
queryset = cls.objects.all()
queryset = queryset.filter(*core.filter_validity())
return queryset
