def renew(self, contract): try: # check rights for renew contract if not self.user.has_perms( ContractConfig.gql_mutation_renew_contract_perms): raise PermissionError("Unauthorized") from core import datetime, datetimedelta contract_to_renew = ContractModel.objects.filter( id=contract["id"]).first() contract_id = contract["id"] # block renewing contract not in Updateable or Approvable state state_right = self.__check_rights_by_status( contract_to_renew.state) # check if we can renew if state_right is not "cannot_update" and contract_to_renew.state is not ContractModel.STATE_TERMINATED: raise ContractUpdateError("You cannot renew this contract!") # create copy of the contract - later we also copy contract detail renewed_contract = copy(contract_to_renew) # TO DO : if a policyholder is set, the contract details must be removed and PHinsuree imported again renewed_contract.id = None # Date to (the previous contract) became date From of the new contract (TBC if we need to add 1 day) # Date To of the new contract is calculated by DateFrom new contract + “Duration in month of previous contract“ length_contract = (contract_to_renew.date_valid_to.year - contract_to_renew.date_valid_from.year) * 12 \ + (contract_to_renew.date_valid_to.month - contract_to_renew.date_valid_from.month) renewed_contract.date_valid_from = contract_to_renew.date_valid_to + datetimedelta( days=1) renewed_contract.date_valid_to = contract_to_renew.date_valid_to + datetimedelta( months=length_contract) renewed_contract.state, renewed_contract.version = ( ContractModel.STATE_DRAFT, 1) renewed_contract.amount_rectified, renewed_contract.amount_due = ( 0, 0) renewed_contract.save(username=self.user.username) historical_record = renewed_contract.history.all().first() renewed_contract.json_ext = json.dumps(_save_json_external( user_id=historical_record.user_updated.id, datetime=historical_record.date_updated, message=f"contract renewed - state " f"{historical_record.state}"), cls=DjangoJSONEncoder) renewed_contract.save(username=self.user.username) # copy also contract details self.__copy_details(contract_id=contract_id, modified_contract=renewed_contract) renewed_contract_dict = model_to_dict(renewed_contract) id_new_renewed = f"{renewed_contract.id}" renewed_contract_dict["id"], renewed_contract_dict["uuid"] = ( id_new_renewed, id_new_renewed) return _output_result_success( dict_representation=renewed_contract_dict) except Exception as exc: return _output_exception(model_name="Contract", method="renew", exception=exc)
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 test_t_user_active_status(self): always_valid = User(username='******', t_user=TechnicalUser(username='******')) self.assertTrue(always_valid.is_active) from core import datetime, datetimedelta not_yet_active = User( username='******', t_user=TechnicalUser(username='******', validity_from=datetime.datetime.now() + datetimedelta(days=1))) self.assertFalse(not_yet_active.is_active) not_active_anymore = User( username='******', t_user=TechnicalUser(username='******', validity_to=datetime.datetime.now() + datetimedelta(days=-1))) self.assertFalse(not_active_anymore.is_active)
def activate_contracted_policies(sender, instance, **kwargs): received_amount = instance.received_amount if instance.received_amount else 0 # check if payment is related to the contract payment_detail = PaymentDetail.objects.filter( payment__id=int(instance.id) ).prefetch_related( 'premium__contract_contribution_plan_details__contract_details__contract' ).prefetch_related( 'premium__contract_contribution_plan_details' ).filter(premium__contract_contribution_plan_details__isnull=False) if len(list(payment_detail)) > 0: if instance.expected_amount <= received_amount: contribution_list_id = [pd.premium.id for pd in payment_detail] contract_list = Contract.objects.filter( contractdetails__contractcontributionplandetails__contribution__id__in=contribution_list_id ).distinct() ccpd_number = ContractContributionPlanDetails.objects.prefetch_related('contract_details__contract').filter( contract_details__contract__in=list(contract_list) ).count() # 1- check if the contract have payment attached to each contributions # (nbr CCPD of all contract in step 0= Paymentdetails in Steps 0) if ccpd_number == len(list(payment_detail)): for contract in contract_list: if contract.state == Contract.STATE_EXECUTABLE: # get the ccpd related to the currenttly processing contract ccpd_list = list( ContractContributionPlanDetails.objects.prefetch_related( 'contract_details__contract').filter( contract_details__contract=contract ) ) from core import datetime, datetimedelta # TODO support Splitted payment and check that # the payment match the value of all contributions for ccpd in ccpd_list: insuree = ccpd.contract_details.insuree pi = InsureePolicy.objects.create( **{ "insuree": insuree, "policy": ccpd.policy, "enrollment_date": ccpd.date_valid_from, "start_date": ccpd.date_valid_from, "effective_date": ccpd.date_valid_from, "expiry_date": ccpd.date_valid_to + datetimedelta( ccpd.contribution_plan.benefit_plan.grace_period ), "audit_user_id": -1, } ) contract.state = Contract.STATE_EFFECTIVE __save_or_update_contract(contract, contract.user_updated)
def __append_contract_cpd_to_list(self, ccpd, cp, date_valid_from, insuree_id, total_amount, calculated_amount, ccpd_list, ccpd_record): """helper private function to gather results to the list ccpd - contract contribution plan details cp - contribution plan return ccpd list and total amount """ from core import datetime, datetimedelta # TODO - catch grace period from calculation rule if is defined # grace_period = cp.calculation_rule etc # length = cp.get_contribution_length(grace_period) length = cp.get_contribution_length() ccpd.date_valid_from = date_valid_from ccpd.date_valid_to = date_valid_from + datetimedelta(months=length) # TODO: calculate the number of CCPD to create in order to cover the contract lenght ccpd_results = self.create_ccpd(ccpd, insuree_id) ccpd_record = model_to_dict(ccpd) ccpd_record["calculated_amount"] = calculated_amount # TODO: support more that 2 CCPD # case 1 - single contribution if len(ccpd_results) == 1: uuid_string = f"{ccpd_results[0].id}" ccpd_record['id'], ccpd_record['uuid'] = (uuid_string, uuid_string) ccpd_list.append(ccpd_record) # case 2 - 2 contributions with 2 policies else: # there is additional contribution - we have to calculate/recalculate total_amount = total_amount - calculated_amount for ccpd_result in ccpd_results: length_ccpd = float((ccpd_result.date_valid_to.year - ccpd_result.date_valid_from.year) * 12 \ + (ccpd_result.date_valid_to.month - ccpd_result.date_valid_from.month)) periodicity = float(ccpd_result.contribution_plan.periodicity) # time part of splited as a fraction to count contribution value for that splited period properly part_time_period = length_ccpd / periodicity # rc - result calculation rc = run_calculation_rules(ccpd, "update", self.user) if rc: calculated_amount = rc[0][1] * part_time_period if rc[0][ 1] not in [None, False] else 0 total_amount += calculated_amount ccpd_record = model_to_dict(ccpd_result) ccpd_record["calculated_amount"] = calculated_amount uuid_string = f"{ccpd_result.id}" ccpd_record['id'], ccpd_record['uuid'] = (uuid_string, uuid_string) ccpd_list.append(ccpd_record) return ccpd_list, total_amount, ccpd_record
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)