def test_waiting_period(self):
# When the insuree already reaches his limit of visits
# Given
from core import datetime
insuree = create_test_insuree()
child_insuree = create_test_insuree(custom_props={
"dob": datetime.datetime(2020, 1, 1),
"family": insuree.family
})
self.assertIsNotNone(insuree)
product = create_test_product("CSECT")
policy = create_test_policy(product, insuree, link=True)
policy_child = create_test_policy(product, child_insuree, link=True)
service = create_test_service("C")
product_service = create_test_product_service(
product, service, custom_props={"waiting_period_adult": 6, "waiting_period_child": 0})
pricelist_detail = add_service_to_hf_pricelist(service)
# A first claim for a visit within the waiting period should be refused
claim1 = create_test_claim({"insuree_id": insuree.id})
service1 = create_test_claimservice(claim1, custom_props={"service_id": service.id})
errors = validate_claim(claim1, True)
self.assertEqual(len(errors), 1, "An adult visit within the waiting period should be refused")
self.assertEqual(claim1.services.first().rejection_reason, REJECTION_REASON_WAITING_PERIOD_FAIL)
# a visit after the waiting period should be fine
claim2 = create_test_claim({
"insuree_id": insuree.id,
"date_from": datetime.datetime(2020, 2, 1),
"date_to": datetime.datetime(2020, 2, 1),
"date_claimed": datetime.datetime(2020, 2, 1),
})
service2 = create_test_claimservice(claim2, custom_props={"service_id": service.id})
errors = validate_claim(claim2, True)
self.assertEqual(len(errors), 0, "This one should be accepted as after the waiting period")
# a child should not have the waiting period
claim3 = create_test_claim({"insuree_id": child_insuree.id})
service3 = create_test_claimservice(claim3, custom_props={"service_id": service.id})
errors = validate_claim(claim3, True)
self.assertEqual(len(errors), 0, "The child has no waiting period")
# tearDown
service3.delete()
claim3.delete()
service2.delete()
claim2.delete()
service1.delete()
claim1.delete()
policy.insuree_policies.all().delete()
policy.delete()
policy_child.insuree_policies.all().delete()
policy_child.delete()
product_service.delete()
pricelist_detail.delete()
service.delete()
product.delete()
def test_frequency(self):
# When the insuree already reaches his limit of visits
# Given
insuree = create_test_insuree()
self.assertIsNotNone(insuree)
product = create_test_product("CSECT")
policy = create_test_policy(product, insuree, link=True)
service = create_test_service("C",
custom_props={
"code": "G34B",
"frequency": 180
})
product_service = create_test_product_service(product, service)
pricelist_detail = add_service_to_hf_pricelist(service)
# A first claim for a visit should be accepted
claim1 = create_test_claim({"insuree_id": insuree.id})
service1 = create_test_claimservice(
claim1, custom_props={"service_id": service.id})
errors = validate_claim(claim1, True)
mark_test_claim_as_processed(claim1)
self.assertEquals(len(errors), 0, "The first visit should be accepted")
# a second visit should be denied
claim2 = create_test_claim({"insuree_id": insuree.id})
service2 = create_test_claimservice(
claim2, custom_props={"service_id": service.id})
errors = validate_claim(claim2, True)
self.assertGreater(
len(errors), 0,
"The second service should be refused as it is withing 180 days")
# Then
claim1.refresh_from_db()
claim2.refresh_from_db()
# tearDown
service2.delete()
claim2.delete()
service1.delete()
claim1.delete()
policy.insuree_policies.first().delete()
policy.delete()
product_service.delete()
pricelist_detail.delete()
service.delete()
product.delete()
def test_validate_family(self):
# When the insuree family is invalid
# Given
invalid_insuree = Insuree.objects.filter(
family__in=Family.objects.filter(
validity_to__isnull=False)).first()
self.assertIsNotNone(invalid_insuree)
claim = create_test_claim({"insuree_id": invalid_insuree.id})
service1 = create_test_claimservice(claim, "S")
item1 = create_test_claimitem(claim, "D")
# When
errors = validate_claim(claim, True)
# Then
claim.refresh_from_db()
item1.refresh_from_db()
self.assertGreaterEqual(len(errors), 1,
"Should raise at least one error")
error7 = [e for e in errors if e['code'] == 7]
self.assertGreaterEqual(
len(error7), 1, "There should be 1 error code 7: invalid insuree")
self.assertEquals(item1.rejection_reason, 7,
"Database was updated with rejection reason")
# tearDown
service1.delete()
item1.delete()
claim.delete()
def test_validate_pricelist_hf1(self):
# When the claimitem points to a pricelist that doesn't correspond to the claim HF
hf_without_pricelist = HealthFacility.objects.filter(
items_pricelist__id__isnull=True).first()
self.assertIsNotNone(
hf_without_pricelist,
"This test requires a health facility without a price list item")
# Given
claim = create_test_claim(
{"health_facility_id": hf_without_pricelist.id})
service1 = create_test_claimservice(claim, "S")
item1 = create_test_claimitem(claim, "D")
# When
errors = validate_claim(claim, True)
# Then
claim.refresh_from_db()
service1.refresh_from_db()
item1.refresh_from_db()
self.assertGreaterEqual(len(errors), 1,
"Should raise at least one error")
error1 = [e for e in errors if e['code'] == 1] # all services rejected
self.assertGreaterEqual(len(error1), 1,
"There should be an error code 1")
self.assertEquals(item1.rejection_reason, 2,
"Database was updated with rejection reason")
# tearDown
service1.delete()
item1.delete()
claim.delete()
def test_validate_patient_category(self):
# When the insuree already reaches his limit of visits
# Given
insuree = create_test_insuree()
self.assertIsNotNone(insuree)
product = create_test_product("VISIT", custom_props={"max_no_visits": 1})
policy = create_test_policy(product, insuree, link=True)
service = create_test_service("V", custom_props={"patient_category": 1})
product_service = create_test_product_service(product, service)
pricelist_detail = add_service_to_hf_pricelist(service)
# The insuree has a patient_category of 6, not matching the service category
claim1 = create_test_claim({"insuree_id": insuree.id})
service1 = create_test_claimservice(claim1, custom_props={"service_id": service.id})
errors = validate_claim(claim1, True)
# Then
claim1.refresh_from_db()
self.assertEquals(len(errors), 1)
self.assertEquals(errors[0]['code'], 1) # claimed rejected because all services are rejected
self.assertEquals(claim1.services.first().rejection_reason, 4) # reason is wrong insuree mask
# tearDown
service1.delete()
claim1.delete()
policy.insuree_policies.first().delete()
policy.delete()
product_service.delete()
pricelist_detail.delete()
service.delete()
product.delete()
def test_limit_surgery(self):
# When the insuree already reaches his limit of visits
# Given
insuree = create_test_insuree()
self.assertIsNotNone(insuree)
product = create_test_product("DELIV",
custom_props={"max_no_surgery": 1})
policy = create_test_policy(product, insuree, link=True)
service = create_test_service("S", custom_props={"code": "SSSS"})
product_service = create_test_product_service(product, service)
pricelist_detail = add_service_to_hf_pricelist(service)
# A first claim for a delivery should be accepted
claim1 = create_test_claim({"insuree_id": insuree.id})
service1 = create_test_claimservice(
claim1, custom_props={"service_id": service.id})
errors = validate_claim(claim1, True)
mark_test_claim_as_processed(claim1)
self.assertEquals(len(errors), 0,
"The first surgery should be accepted")
# a second delivery should be denied
claim2 = create_test_claim({"insuree_id": insuree.id})
service2 = create_test_claimservice(
claim2, custom_props={"service_id": service.id})
errors = validate_claim(claim2, True)
self.assertGreater(
len(errors), 0,
"The second service should fail because there is already one surgery"
)
# Then
claim1.refresh_from_db()
claim2.refresh_from_db()
# tearDown
service2.delete()
claim2.delete()
service1.delete()
claim1.delete()
policy.insuree_policies.first().delete()
policy.delete()
product_service.delete()
pricelist_detail.delete()
service.delete()
product.delete()
def test_validate_max_visits(self):
# When the insuree already reaches his limit of visits
# Given
insuree = create_test_insuree()
self.assertIsNotNone(insuree)
product = create_test_product("VISIT",
custom_props={"max_no_visits": 1})
policy = create_test_policy(product, insuree, link=True)
service = create_test_service("V")
product_service = create_test_product_service(product, service)
pricelist_detail = add_service_to_hf_pricelist(service)
# A first claim for a visit should be accepted
claim1 = create_test_claim({"insuree_id": insuree.id})
service1 = create_test_claimservice(
claim1, custom_props={"service_id": service.id})
errors = validate_claim(claim1, True)
self.assertEquals(len(errors), 0, "The first visit should be accepted")
# a second visit should be denied
claim2 = create_test_claim({"insuree_id": insuree.id})
service2 = create_test_claimservice(claim2, "V")
errors = validate_claim(claim2, True)
# TODO Temporarily disabled
# self.assertGreater(len(errors), 0, "The second visit should be refused")
# Then
claim1.refresh_from_db()
claim2.refresh_from_db()
# tearDown
service2.delete()
claim2.delete()
service1.delete()
claim1.delete()
policy.insuree_policies.first().delete()
policy.delete()
product_service.delete()
pricelist_detail.delete()
service.delete()
product.delete()
def async_mutate(cls, user, **data):
if not user.has_perms(ClaimConfig.gql_mutation_process_claims_perms):
raise PermissionDenied(_("unauthorized"))
errors = []
for claim_uuid in data["uuids"]:
logger.debug("ProcessClaimsMutation: processing %s", claim_uuid)
c_errors = []
claim = Claim.objects \
.filter(uuid=claim_uuid) \
.prefetch_related("items") \
.prefetch_related("services") \
.first()
if claim is None:
errors += {
'title':
claim_uuid,
'list': [{
'message': _("claim.validation.id_does_not_exist") % {
'id': claim_uuid
}
}]
}
continue
claim.save_history()
logger.debug("ProcessClaimsMutation: validating claim %s",
claim_uuid)
c_errors += validate_claim(claim, False)
logger.debug(
"ProcessClaimsMutation: claim %s validated, nb of errors: %s",
claim_uuid, len(c_errors))
if len(c_errors) == 0:
c_errors = validate_assign_prod_to_claimitems_and_services(
claim)
logger.debug(
"ProcessClaimsMutation: claim %s assigned, nb of errors: %s",
claim_uuid, len(c_errors))
c_errors += process_dedrem(claim, user.id_for_audit, True)
logger.debug(
"ProcessClaimsMutation: claim %s processed for dedrem, nb of errors: %s",
claim_uuid, len(errors))
c_errors += set_claim_processed_or_valuated(claim, c_errors, user)
logger.debug(
"ProcessClaimsMutation: claim %s set processed or valuated",
claim_uuid)
if c_errors:
errors.append({'title': claim.code, 'list': c_errors})
if len(errors) == 1:
errors = errors[0]['list']
logger.debug("ProcessClaimsMutation: claim %s done, errors: %s",
claim_uuid, len(errors))
return errors
def test_simple_monthly_batch_run(self) -> None:
insuree1 = create_test_insuree()
self.assertIsNotNone(insuree1)
product = create_test_product("TEST1",
custom_props={
"location_id": 1,
"period_rel_prices": 4
})
policy = create_test_policy(product, insuree1, link=True)
service = create_test_service("V")
product_service = create_test_product_service(
product,
service,
custom_props={"price_origin": ProductService.ORIGIN_RELATIVE})
pricelist_detail = add_service_to_hf_pricelist(service)
premium = create_test_premium(policy_id=policy.id, with_payer=True)
create_test_rel_distr_range(product.id,
RelativeDistribution.TYPE_QUARTER,
RelativeDistribution.CARE_TYPE_BOTH, 10)
claim1 = create_test_claim({"insuree_id": insuree1.id})
service1 = create_test_claimservice(claim1,
custom_props={
"service_id": service.id,
"price_origin":
ProductService.ORIGIN_RELATIVE,
"product": product
})
errors = validate_claim(claim1, True)
self.assertEquals(len(errors), 0)
errors = validate_assign_prod_to_claimitems_and_services(claim1)
self.assertEquals(len(errors), 0)
_mark_as_processed(claim1)
claim1.refresh_from_db()
result = process_batch(1, location_id=1, period=6, year=2019)
# tearDown
premium.delete()
premium.payer.delete()
service1.delete()
claim1.delete()
policy.insuree_policies.first().delete()
policy.delete()
product_service.delete()
pricelist_detail.delete()
service.delete()
for rd in product.relative_distributions.all():
rd.delete()
product.delete()
def validate_and_process_dedrem_claim(claim, user, is_process):
errors = validate_claim(claim, False)
logger.debug("ProcessClaimsMutation: claim %s validated, nb of errors: %s",
claim.uuid, len(errors))
if len(errors) == 0:
errors = validate_assign_prod_to_claimitems_and_services(claim)
logger.debug(
"ProcessClaimsMutation: claim %s assigned, nb of errors: %s",
claim.uuid, len(errors))
errors += process_dedrem(claim, user.id_for_audit, is_process)
logger.debug(
"ProcessClaimsMutation: claim %s processed for dedrem, nb of errors: %s",
claim.uuid, len(errors))
else:
# OMT-208 the claim is invalid. If there is a dedrem, we need to clear it (caused by a review)
deleted_dedrems = ClaimDedRem.objects.filter(claim=claim).delete()
if deleted_dedrems:
logger.debug(
f"Claim {claim.uuid} is invalid, we deleted its dedrem ({deleted_dedrems})"
)
if is_process:
errors += set_claim_processed_or_valuated(claim, errors, user)
return errors
def test_submit_claim_dedrem(self):
# When the insuree already reaches his limit of visits
# Given
insuree = create_test_insuree()
self.assertIsNotNone(insuree)
product = create_test_product("VISIT", custom_props={})
policy = create_test_policy(product, insuree, link=True)
service = create_test_service("V", custom_props={})
item = create_test_item("D", custom_props={})
product_service = create_test_product_service(product, service)
product_item = create_test_product_item(product, item)
pricelist_detail1 = add_service_to_hf_pricelist(service)
pricelist_detail2 = add_item_to_hf_pricelist(item)
claim1 = create_test_claim({"insuree_id": insuree.id})
service1 = create_test_claimservice(
claim1, custom_props={"service_id": service.id})
item1 = create_test_claimitem(claim1,
"D",
custom_props={"item_id": item.id})
errors = validate_claim(claim1, True)
errors += validate_assign_prod_to_claimitems_and_services(claim1)
errors += process_dedrem(claim1, -1, True)
self.assertEqual(len(errors), 0)
# Then
claim1.refresh_from_db()
item1.refresh_from_db()
service1.refresh_from_db()
self.assertEqual(len(errors), 0)
self.assertEqual(item1.price_adjusted, 100)
self.assertEqual(item1.price_valuated, 700)
self.assertEqual(item1.deductable_amount, 0)
self.assertEqual(item1.exceed_ceiling_amount, 0)
self.assertIsNone(item1.exceed_ceiling_amount_category)
self.assertEqual(item1.remunerated_amount, 700)
self.assertEqual(claim1.status, Claim.STATUS_VALUATED)
self.assertEqual(claim1.audit_user_id_process, -1)
self.assertIsNotNone(claim1.process_stamp)
self.assertIsNotNone(claim1.date_processed)
dedrem_qs = ClaimDedRem.objects.filter(claim=claim1)
self.assertEqual(dedrem_qs.count(), 1)
dedrem1 = dedrem_qs.first()
self.assertEqual(dedrem1.policy_id, item1.policy_id)
self.assertEqual(dedrem1.insuree_id, claim1.insuree_id)
self.assertEqual(dedrem1.audit_user_id, -1)
self.assertEqual(dedrem1.ded_g, 0)
self.assertEqual(dedrem1.rem_g, 1400)
self.assertEqual(dedrem1.rem_op, 1400)
self.assertIsNone(dedrem1.rem_ip)
self.assertEqual(dedrem1.rem_surgery, 0)
self.assertEqual(dedrem1.rem_consult, 0)
self.assertEqual(dedrem1.rem_hospitalization, 0)
self.assertIsNotNone(claim1.validity_from)
self.assertIsNone(claim1.validity_to)
# tearDown
dedrem_qs.delete()
service1.delete()
item1.delete()
claim1.delete()
policy.insuree_policies.first().delete()
policy.delete()
product_item.delete()
product_service.delete()
pricelist_detail1.delete()
pricelist_detail2.delete()
service.delete()
item.delete()
product.delete()
"max_amount_delivery": 55,
})
product_service = create_test_product_service(product, service)
product_item = create_test_product_item(product, item)
policy = create_test_policy(product, insuree, link=True)
pricelist_detail1 = add_service_to_hf_pricelist(service)
pricelist_detail2 = add_item_to_hf_pricelist(item)
# The insuree has a patient_category of 6, not matching the service category
claim1 = create_test_claim({"insuree_id": insuree.id})
service1 = create_test_claimservice(
claim1, custom_props={"service_id": service.id})
item1 = create_test_claimitem(claim1,
"D",
custom_props={"item_id": item.id})
errors = validate_claim(claim1, True)
errors += validate_assign_prod_to_claimitems_and_services(claim1)
errors += process_dedrem(claim1, -1, True)
self.assertEqual(len(errors), 0)
# Then
claim1.refresh_from_db()
item1.refresh_from_db()
service1.refresh_from_db()
self.assertEqual(len(errors), 0)
self.assertEqual(item1.price_adjusted, 100)
self.assertEqual(item1.price_valuated, 55)
self.assertEqual(item1.deductable_amount, 0)
self.assertEqual(item1.exceed_ceiling_amount, 0)
self.assertIsNone(item1.exceed_ceiling_amount_category)
self.assertEqual(item1.remunerated_amount, 55)
def test_review_reject_delete_dedrem(self):
"""
This test creates a claim, submits it so that it gets dedrem entries,
then submits a review rejecting part of it, then process the claim.
It should not be processed (which was ok) but the dedrem should be deleted.
"""
# Given
insuree = create_test_insuree()
self.assertIsNotNone(insuree)
service = create_test_service("A", custom_props={"name": "test_review_reject_delete_dedrem"})
item = create_test_item("A", custom_props={"name": "test_review_reject_delete_dedrem"})
product = create_test_product("BCUL0001", custom_props={
"name": "Basic Cover Ultha deldedrem",
"lump_sum": 10_000,
})
product_service = create_test_product_service(product, service)
product_item = create_test_product_item(product, item)
policy = create_test_policy(product, insuree, link=True)
pricelist_detail1 = add_service_to_hf_pricelist(service)
pricelist_detail2 = add_item_to_hf_pricelist(item)
claim1 = create_test_claim({"insuree_id": insuree.id})
service1 = create_test_claimservice(
claim1, custom_props={"service_id": service.id, "qty_provided": 2})
item1 = create_test_claimitem(
claim1, "A", custom_props={"item_id": item.id, "qty_provided": 3})
errors = validate_claim(claim1, True)
errors += validate_assign_prod_to_claimitems_and_services(claim1)
errors += process_dedrem(claim1, -1, False)
self.assertEqual(len(errors), 0)
# Make sure that the dedrem was generated
dedrem = ClaimDedRem.objects.filter(claim=claim1).first()
self.assertIsNotNone(dedrem)
self.assertEquals(dedrem.rem_g, 500) # 100*2 + 100*3
# Review the claim and reject all of it
# A partial rejection would still trigger the process_dedrem and be fine
item1.qty_approved = 0
item1.price_approved = 0
item1.status = ClaimItem.STATUS_REJECTED
item1.rejection_reason = -1
item1.audit_user_id_review = -1
item1.justification = "Review comment item"
item1.save()
service1.qty_approved = 0
service1.price_approved = 0
service1.status = ClaimItem.STATUS_REJECTED
service1.rejection_reason = -1
service1.audit_user_id_review = -1
service1.justification = "Review comment svc"
service1.save()
claim1.refresh_from_db()
item1.refresh_from_db()
service1.refresh_from_db()
set_claims_status([claim1.uuid], "review_status", Claim.REVIEW_DELIVERED)
update_claims_dedrems([claim1.uuid], User.objects.first())
errors = validate_claim(claim1, True)
if len(errors) == 0:
errors += validate_assign_prod_to_claimitems_and_services(claim1)
errors += process_dedrem(claim1, -1, False)
# The claim should be globally rejected since the review rejected all items/svc
claim1.refresh_from_db()
item1.refresh_from_db()
service1.refresh_from_db()
self.assertEquals(claim1.status, Claim.STATUS_REJECTED)
self.assertEquals(claim1.rejection_reason, REJECTION_REASON_INVALID_ITEM_OR_SERVICE)
self.assertEquals(item1.status, ClaimDetail.STATUS_REJECTED)
self.assertEquals(item1.rejection_reason, -1)
self.assertEquals(service1.status, ClaimDetail.STATUS_REJECTED)
self.assertEquals(service1.rejection_reason, -1)
# Then dedrem should have been deleted
dedrem = ClaimDedRem.objects.filter(claim=claim1).first()
self.assertIsNone(dedrem)
# tearDown
# dedrem.delete() # already done if the test passed
delete_claim_with_itemsvc_dedrem_and_history(claim1)
policy.insuree_policies.first().delete()
policy.delete()
product_item.delete()
product_service.delete()
pricelist_detail1.delete()
pricelist_detail2.delete()
service.delete()
item.delete()
product.delete()
