def post(self): # get the user details from the request sent by the client user_details = user_parser.parse_args() # check if the user exists before registering them user_db_row = User.get_user_by_email(user_details['email']) if user_db_row: err_msg = f"{user_details['email']} already exists" response_msg = helper.make_rest_fail_response(err_msg) return make_response(response_msg, 409) # check if user phone number exists phone_number = UserProfile.get_profile_by_phone_number( user_details["phone"]) if phone_number: err_msg = f"{user_details['phone']} already exists" response_msg = helper.make_rest_fail_response(err_msg) return make_response(response_msg, 409) # save the user authentication details and profile details # in their respective database tables user_uuid = uuid.uuid4() new_user_authentication = User(user_uuid, user_details['email'], user_details['password']) new_user_authentication.save() new_user_profile = UserProfile(new_user_authentication.id, user_details['first_name'], user_details['last_name'], user_details['phone']) new_user_profile.save() new_user_role = UserRolePlacement( new_user_authentication.id, Role.fetch_role_by_name(user_details['role'])) new_user_role.save() # Account confirmation email generation # Save extra user details depending on their role role = user_details["role"] self.onboard_client(role, new_user_authentication.id, user_details) # Send a confirmation link to the user for account confirmation confirmation_code = token_handler.user_account_confirmation_token( new_user_authentication.id) email_template = helper.generate_confirmation_template( application.config['CONFIRMATION_ENDPOINT'], confirmation_code) subject = "Your account is inactive, please confirm account or check with your administrator" email_text = f"Use this link {application.config['CONFIRMATION_ENDPOINT']}/{confirmation_code}" \ f" to confirm your account" helper.send_email(user_details['email'], subject, email_template, email_text) response_msg = helper.make_rest_success_response( "Registration successful, kindly" " check your email for confirmation link") return make_response(response_msg, 200)
def post(self): # this is the POST request resource to handle user signin user_details = user_parser.parse_args() # check whether the user exists before confirming user_db_row = User.get_user_by_email(user_details['email']) if not user_db_row: response_msg = helper.make_rest_fail_response( "User email does not exist") return make_response(response_msg, 404) # good, let's go ahead and authenticate the user now # we also need to check whether the user account is verified or not # we don't want inactive accounts accessing our system if user_db_row.check_password_hash(user_details['password']): if user_db_row.is_active: # generate an access and refresh tokens for the user, for obvious reasons # also return the user role as a token claim, we'll need that for subsequent # requests from the client role = self.get_user_role(user_db_row.id) if role in ("IASTF", "BRSTF", "TASTF"): # if the user is a staff, # we need to make sure that the account has not been deactivated # by their respective administrator if staff_handler.check_account_status( role, user_db_row.id) == False: msg = "Your account has been blocked by your administrator" return make_response( helper.make_rest_fail_response(msg), 400) auth_tokens = token_handler.create_user_token( user_db_row.id, role) response_dict = { "authentication": auth_tokens, "role": role, "is_complete": user_db_row.is_complete } if role in ("BRSTF", "TASTF", "IASTF"): # if the authenticated user is a staff member, # get the corresponding permissions response_dict[ 'permission'] = UserPermissions.get_permission_by_user_id( user_db_row.id) response_msg = helper.make_rest_success_response( "Welcome", response_dict) return make_response(response_msg, 200) else: response_msg = helper.make_rest_fail_response( "Please confirm your account before signing in.") return make_response(response_msg, 400) else: # wrong credentials passed, return the appropriate message response_msg = helper.make_rest_fail_response( "Wrong credentials passed, please try again") return make_response(response_msg, 400)
def post(self): """ send the user an email containing a link to set a new password :arg email {string} user email whose account we intend to recover :return: """ user_details = user_parser.parse_args() user_row = User.get_user_by_email(user_details['email']) if user_row: profile_details = UserProfile.get_profile_by_user_id(user_row.id) account_token = token_handler.user_account_confirmation_token( user_row.id) email_text = f"To reset your account password, please follow this link " \ f"{application.config['ACCOUNT_RESET_ENDPOINT']}/{account_token}" email_template = helper.generate_account_recovery_template( application.config['ACCOUNT_RESET_ENDPOINT'], account_token, profile_details.first_name) subject = "Account Password Recovery" helper.send_email(user_details['email'], subject, email_template, email_text) response_msg = helper.make_rest_success_response( "Successfully sent account recovery steps, check your" " email") return make_response(response_msg, 200) response_msg = helper.make_rest_fail_response( "There is not account associated with this email") return make_response(response_msg, 404)
def get_customer_details(self, user_id): # use the user id to determine the customer's role, whether IND or ORG role_id = UserRolePlacement.fetch_role_by_user_id(user_id) # get role name using role_id role = Role.fetch_role_by_id(role_id) if role == 'IND': customer_no = IndividualCustomer.get_customer_number(user_id) if customer_no: user_profile = UserProfile.get_profile_by_user_id(user_id) data = { "customer_number": customer_no, "first_name": user_profile.first_name, "last_name": user_profile.last_name, "phone_number": user_profile.phone, "kra_pin": user_profile.kra_pin, "id_passport": user_profile.id_passport, } return data else: response_msg = helper.make_rest_fail_response( "Customer does not exist") return make_response(response_msg, 404) elif role == 'ORG': # When the customer is an organization, their details are stored directly in the organization model # (not linked with the user profile) customer = OrganizationCustomer.get_customer_by_contact(user_id) if customer: # get customer details data = {} # TODO: Confirm from Tony whether to fetch organization details or contact person pass
def get(self): data = OrganizationTypes.get_organization_customer_types() if data: message = "Request successful" response = helper.make_rest_success_response(message, data) return make_response(response, 200) message = "No data was found" response = helper.make_rest_fail_response(message) return make_response(response, 404)
def get(self, object_name): bucket_name = app.config['S3_BUCKET'] client_method = "put_object" s3_handler = S3FileHandler(bucket_name, object_name) response = s3_handler.generate_pre_signed_url(client_method) if response: return make_response( helper.make_rest_success_response("Success", response), 200) return make_response(helper.make_rest_fail_response("Failed"), 500)
def get(self): """ Get all loadings """ loadings = Loadings.get_all_loadings() if loadings: response_msg = helper.make_rest_success_response( "Loadings", loadings) return make_response(response_msg, 200) return make_response( helper.make_rest_fail_response("No data was found"), 404)
def get(self): """ Get all extensions """ extensions = Extension.get_all_extensions() if extensions: response = helper.make_rest_success_response( "Extensions", extensions) return make_response(response, 200) return make_response( helper.make_rest_fail_response("No data was found"), 404)
def get(self): """ Get all benefits """ benefits = Benefit.get_all_benefits() if benefits: response_msg = helper.make_rest_success_response( "Benefits", benefits) return make_response(response_msg, 200) return make_response( helper.make_rest_fail_response("No data was found"), 404)
def get(self): """ Get all cars classified under a particular car make """ # get car makes cars = CarMake.get_all_car_makes() if cars: response = helper.make_rest_success_response( "Success", {"cars": cars}) return make_response(response, 200) return make_response( helper.make_rest_fail_response("No data was found"), 404)
def get(self, object_name): """ get the presigned url to fetch file from s3 resource :param object_name {String} the name of object to be uploaded """ bucket_name = app.config['S3_BUCKET'] s3_handler = S3FileHandler(bucket_name, object_name) response = s3_handler.generate_pre_signed_url() if response: return make_response( helper.make_rest_success_response("Success", response), 200) return make_response(helper.make_rest_fail_response("Failed"), 500)
def get(self, master_id): """ get the master policy and associated child policies :return: """ result = MasterController.fetch_master_policy(master_id) if result: return make_response( helper.make_rest_success_response("Successfully fetched", result), 200) return make_response( helper.make_rest_fail_response("Policy was not found"), 404)
def put(self): """ update staff details may be user permissions or to block staff member account """ staff_details = user_parser.parse_args() staff = User.get_user_by_email(staff_details['email']) if staff_details['email'] and not staff: response_msg = helper.make_rest_fail_response( "User does not exist") return make_response(response_msg, 404) if staff_details['permissions']: if user_update.update_staff_permissions( staff.id, staff_details['permissions']): response_msg = helper.make_rest_success_response( "Update successful!") return make_response(response_msg, 200) else: response_msg = helper.make_rest_success_response( "Failed to update staff permissions") return make_response(response_msg, 500) if type(staff_details['is_active']) == bool: # de/activate staff account claims = get_jwt_claims() role = claims['role'] if staff_handler.update_account_status(role, staff_details['staff_id'], staff_details['is_active']): return make_response( helper.make_rest_success_response("Update successful"), 200) else: return make_response( helper.make_rest_fail_response(staff_details['is_active']), 500)
def get(self, customer_number): """ get the customer active child policies this is needed for the payments module where user's active policy payments will be tracked :return: """ customers = ChildPolicy.get_child_policies(customer_number) if customers: return make_response( helper.make_rest_success_response("success", customers), 200) return make_response( helper.make_rest_fail_response("No customer policies were found"), 404)
def get(self): """ get user profile details """ user_id = get_jwt_identity() claims = get_jwt_claims() role = claims['role'] profile_data = self.fetch_profile_data(role, user_id) if profile_data is None: response = helper.make_rest_fail_response("No user was found") return make_response(response, 404) response = helper.make_rest_success_response(None, profile_data) return make_response(response, 200)
def post(self): """ make a new policy payment to the database """ payment_details = payments_parser.parse_args() new_installment = PolicyPayments( payment_details['transaction_type'], payment_details['amount'], payment_details['customer_no'], payment_details['child_policy_id'], payment_details['next_date'], payment_details['amount_due'], payment_details['transaction_code']) if new_installment.add(): response_message = "Successfully made new installment" return make_response( helper.make_rest_success_response(response_message), 200) response_message = "Failed to make new payment installmnet" return make_response(helper.make_rest_fail_response(response_message), 500)
def get(self, child_id): """ Process request to get all unselected benefits and extensions of a policy holder, and the rest of the policy details :param policy_id: :return: """ child = ChildPolicy.get_child_by_id(child_id).serialize() result = ChildController.get_unselected_benefits_extensions(child_id) if child: if result: child.update({"unselected_benefits": result}) return make_response( helper.make_rest_success_response("Success", child), 200) else: return make_response( helper.make_rest_fail_response("Policy does not exist"), 404)
def put(self): """ when the user resets the password, we will update the same here :return: """ user_id = get_jwt_identity() user_details = user_parser.parse_args() user = User.get_user_by_id(user_id) if user: updateController.update_user_password(user_details['new_password'], user_id) response_msg = helper.make_rest_success_response( "Successfully recovered user account") return make_response(response_msg, 200) response_msg = helper.make_rest_fail_response( "Sorry, user does not exist in this database") return make_response(response_msg, 404)
def get(self): """ get agent specific customers :return: """ current_user = get_jwt_identity() current_user_claims = get_jwt_claims() current_user_role = current_user_claims['role'] agency_id = customer.get_agent_id(current_user_role, current_user) agency_customers = customer.get_customer_details( current_user_role, agency_id) if agency_customers: return make_response( helper.make_rest_success_response("Success", agency_customers), 200) else: return make_response( helper.make_rest_fail_response( "No customers, better get to work!"), 404)
def put(self): """ authentication token is sent here for confirmation token must be valid for account to be activated """ # the user id is needed to needed to know the user whose account we are activating user_id = get_jwt_identity() user_row = User.get_user_by_id(user_id) if user_row: if user_row.is_active: response = helper.make_rest_success_response( "Your account is already active, please login") return make_response(response, 200) data = {'is_active': True} user_row.update(data) response = helper.make_rest_success_response( "Your account has been activated, you can now log in") return make_response(response, 200) # the user has not been found in the database response = helper.make_rest_fail_response("User does not exist") return make_response(response, 404)
def get(self, user_id): """ If the jwt token has expired a user can request for another token here simple by passing in the user_id """ user_row = User.get_user_by_id(user_id) if user_row: # awesome, user account exists, let's go ahead and resend the activation email to the user confirmation_code = token_handler.user_account_confirmation_token( user_id) email_template = helper.generate_confirmation_template( application.config['CONFIRMATION_ENDPOINT'], confirmation_code) subject = "Please confirm your account" email_text = f"Use this link {application.config['CONFIRMATION_ENDPOINT']}/{confirmation_code}" \ f" to confirm your account" helper.send_email(user_row.email, subject, email_template, email_text) response = helper.make_rest_success_response( "Please check your email to confirm your account") return make_response(response, 200) response = helper.make_rest_fail_response( "User was not found, please try again or register a new account") return make_response(response, 404)
def post(self): # get the staff details from the request sent by the client user_details = user_parser.parse_args() # check if the staff exists before registering them user_db_row = User.get_user_by_email(user_details['email']) if user_db_row: err_msg = f"{user_details['first_name']} {user_details['last_name']} already exists" response_msg = helper.make_rest_fail_response(err_msg) return make_response(response_msg, 409) # create user account user_uuid = uuid.uuid4() # Create temporary seven digit password temporary_pass = helper.create_user_password() new_user = User(user_uuid, user_details['email'], temporary_pass) new_user.save() # create user profile new_user_profile = UserProfile(new_user.id, user_details['first_name'], user_details['last_name'], user_details['phone']) new_user_profile.save() # get organization details from JWT, such as the role of the client enrolling the staff, and their UID uid = get_jwt_identity() # get user role claims = get_jwt_claims() role = claims['role'] # role = 'BR' # get agency_id agency_id = staff_handler.get_agency_id(role, uid) # Add staff to the appropriate table: i.e BRStaff, TRStaff, IAStaff # We also assign the staff roles at this stage, # depending on the entities they operate under, i.e BRSTF, IASTF, TASTF self.add_staff(role, agency_id, new_user.id) # store staff permissions self.set_permissions(user_details['permissions'], new_user.id) # send email to with the activation details for the staff # Temporary password email email_template = helper.generate_temporary_password_template( application.config['LOGIN_ENDPOINT'], temporary_pass) subject = "Nexure Temporary Password" email_text = f"Follow {application.config['LOGIN_ENDPOINT']} to login and use {temporary_pass} as your temporary password" helper.send_email(user_details['email'], subject, email_template, email_text) # Generate a user account activation email confirmation_code = token_handler.user_account_confirmation_token( new_user.id) email_template = helper.generate_confirmation_template( application.config['CONFIRMATION_ENDPOINT'], confirmation_code) subject = "Please confirm your account" email_text = f"Use this link {application.config['CONFIRMATION_ENDPOINT']}/{confirmation_code}" \ f" to confirm your account" helper.send_email(user_details['email'], subject, email_template, email_text) response = helper.make_rest_success_response( "Registration successful. Please check the staff email to activate your account." ) return make_response(response, 200)
def post(self): customer_details = customer_parser.parse_args() # we need to check for all the unique values to a user to ensure there is no duplicate customer = UserProfile.check_account_duplicate( customer_details['phone'], customer_details['id_passport'], customer_details['kra_pin']) customer_number = None if not customer: # Create temporary seven digit password temporary_pass = helper.create_user_password() # create a new user account if not existing user_id = uuid.uuid4() # create new user customer = User(user_id, customer_details['email'], temporary_pass) customer.save() # if on boarding an individual customer if customer_details['type'] == 'Individual': customer = User.get_user_by_email(customer_details['email']) customer_id = customer.id # create individual customer's profile new_individual_profile = UserProfile( customer_id, customer_details["first_name"], customer_details["last_name"], customer_details["phone"], customer_details["gender"], customer_details["avatar_url"], customer_details["occupation"], customer_details["id_passport"], customer_details["kra_pin"], customer_details["birth_date"], customer_details['physical_address'], customer_details['postal_address'], customer_details['postal_code'], customer_details['postal_town'], customer_details['country'], customer_details['county'], customer_details['constituency'], customer_details['ward'], customer_details['facebook'], customer_details['instagram'], customer_details['twitter']) new_individual_profile.save() # create a new individual customer detail customer_number = self.create_customer_number( "IN", customer_id, customer_details['country']) self.create_individual_customer(customer_id, customer_number, customer_details['salutation']) self.role_placement(customer_id, "IND") # send activation email self.send_activation_email(customer_details['email'], customer_id, temporary_pass) # if on boarding an organization elif customer_details['type'] == "Organization": customer_id = customer.id customer_number = self.create_customer_number( customer_details['org_type'], customer_id, customer_details['country']) # Add contact person details contact_person = UserProfile(customer_id, customer_details['first_name'], customer_details['last_name'], customer_details["phone"]) contact_person.save() new_org_customer = OrganizationCustomer( customer_details['org_type'], customer_details["org_name"], customer_details['org_phone'], customer_details['org_email'], customer_details['reg_number'], customer_details['physical_address'], customer_details['postal_address'], customer_details['postal_code'], customer_details['postal_town'], customer_details['county'], customer_details['constituency'], customer_details['ward'], customer_details['facebook'], customer_details['instagram'], customer_details['twitter'], customer_id, customer_number) new_org_customer.save() self.role_placement(customer_id, "ORG") # send activation email self.send_activation_email(customer_details['email'], customer_id, temporary_pass) # create a new affiliation between the customer and broker/agent # each affiliation must only exist once in the db # we need to fetch the role of the agent/broker and associate it into the affiliation uid = get_jwt_identity() # we need to check whether the current user is a staff member or an agent/broker role_name = self.get_role_name(uid) agent_broker = self.check_staff(uid, role_name) if agent_broker: # the current user is not a staff member # we also need to ensure the affiliation created is not a duplicate one if customer_number is None: customer_number = self.fetch_customer_number( role_name, customer.id, agent_broker) if self.is_affiliation_duplicate(role_name, agent_broker, customer_number): response_msg = helper.make_rest_fail_response( "Customer already exists") return make_response(response_msg, 409) self.register_customer(role_name, customer_number, agent_broker, uid) else: broker_agent_id = self.get_broker_agent_id(uid, role_name) if customer_number is None: customer_number = self.fetch_customer_number( role_name, customer.id, broker_agent_id, agent_broker) if self.is_affiliation_duplicate(role_name, broker_agent_id, customer_number): response_msg = helper.make_rest_fail_response( "Customer already exists") return make_response(response_msg, 409) self.register_customer(role_name, customer_number, broker_agent_id) response_msg = helper.make_rest_success_response( "Customer has been on-boarded successfully", {"customer_number": customer_number}) return make_response(response_msg, 200)
def post(self): # get the current agency details uid = get_jwt_identity() # get user role so that you can use it to get the agency_id, claims = get_jwt_claims() role = claims['role'] # get company_id company_id = self.get_agency_id(role, uid) policy_details = underwriting_parser.parse_args() # get the transaction type i.e could be a new policy, renewal or endorsement or extension if policy_details: transaction_type = policy_details['transaction_type'] # if it's a new transaction (customer had not been enrolled into this kind of policy before) if transaction_type == 'NET': # Create master policy, first generate master policy number index = MasterPolicy.query.all() new_policy = PolicyNoGenerator('MS', len(index)) # Get class details after receiving the class id from the front end e.g if name is Motor Private class_details = InsuranceClass.get_class_by_id( policy_details['class_id']) # generate master policy number using the acronym from the class details new_policy.set_mpi(class_details.acronym) ms_policy_number = new_policy.generate_policy_no() master_policy = MasterController.create_master_policy( ms_policy_number, policy_details['customer_number'], policy_details['date_expiry'], policy_details['insurance_company'] ) # create child policy number child_policy_no = self.create_child_policy_number( policy_details) # Create child policy with details child_policy_id = self.create_child( policy_details, child_policy_no, company_id, master_policy) # Send response if successfully onboarded with the onboarded data # data = self.get_cover_data(child_policy_id) response = helper.make_rest_success_response( "Congratulations! The customer was enrolled successfully. Cover will be" " activated after payment is made", child_policy_id) return make_response(response, 200) # if it's an endorsement i.e the customer wants to add an item under the master policy elif transaction_type == 'END': # In this case, you could be endorsing the child policy or master policy # get the master policy by master policy id if policy_details["master_policy_id"]: endorsed_policy = MasterPolicy.get_policy_by_id( policy_details["master_policy_id"]) # check whether the policy has expired. time_difference = ( endorsed_policy.date_expiry - datetime.now()).days if time_difference > 1: # create child policy number child_policy_no = self.create_child_policy_number( policy_details) # Then endorse it with the child policy details: child_policy_id = self.create_child( policy_details, child_policy_no, company_id, endorsed_policy) # endorsement successful response = helper.make_rest_success_response( "Endorsement successful", child_policy_id) return make_response(response, 200) else: response = helper.make_rest_fail_response( "Failed! Policy expired. Kindly renew it then endorse.") return make_response(response, 500) if policy_details["child_policy_id"]: # In this case we add a benefit to the child policy endorsed_policy = ChildPolicy.get_child_by_id( policy_details["child_policy_id"]) # Check whether the policy has expired. time_difference = ( endorsed_policy.date_expiry - datetime.now()).days if time_difference > 1: # revise the child policy with the a new premium amount revised_policy = self.revise_child_policy( "END", endorsed_policy, policy_details, "benefit") # append the new benefit to revised policy child_controller = ChildController() child_controller.add_benefits( policy_details['benefits'], revised_policy) # endorsement successful response = helper.make_rest_success_response( "Endorsement successful", revised_policy) return make_response(response, 200) else: response = helper.make_rest_fail_response( "Failed! Policy expired. Kindly renew it then endorse.") return make_response(response, 500) elif transaction_type == 'RET': # renew the transaction if MasterController.renew_transaction(policy_details['master_policy_id'], policy_details['expiry_date'], transaction_type): return make_response(helper.make_rest_success_response("Policy renewed successfully"), 200) else: return make_response(helper.make_rest_success_response("Failed to renew Policy")) # if the customer want's to extend the cover to cater for extra losses elif transaction_type == 'EXT': # get child policy extended_policy = ChildPolicy.get_child_by_id( policy_details['child_policy_id']) # check whether policy is less than one year old (365) days time_difference = ( datetime.now() - extended_policy.date_activated).days if time_difference < 365: # revise the child policy with the a new premium amount revised_policy = self.revise_child_policy( "EXT", extended_policy, policy_details) # append the new extension to revised policy child_controller = ChildController() child_controller.add_extensions(policy_details["extensions"], revised_policy) return make_response(helper.make_rest_success_response("Policy extended successfully", revised_policy), 200) else: return make_response(helper.make_rest_success_response("Failed to extend policy")) elif transaction_type == 'REF': refund_type = policy_details["refund_type"] # fetch the child policy to be refunded or updated child_policy = ChildPolicy.get_child_by_id( policy_details['child_policy_id'], True) # get premium amount premium_amount = child_policy.premium_amount refund_amount = None # TODO: create model that stores transactions, the amount paid below is dummy data amount_paid = 800 if refund_type == "sold": # deactivate the previous child policy so that we can create a new one child_policy.deactivate() # initialize child controller child_controller = ChildController() child_controller.create_child_policy( child_policy.cp_number, child_policy.customer_number, child_policy.rate, child_policy.date_expiry, # Zero premium amount 0, "REF", child_policy.agency_id, child_policy.company, child_policy.pricing_model, child_policy.master_policy, child_policy.subclass, child_policy.vehicle, "sold" ) # if the policy has lasted for less than thirty days refund full amount paid period_lasted = (datetime.now() - child_policy.date_activated).days if period_lasted <= 30: refund_amount = amount_paid # if more than 30 days, deduct the cost incured for the period the cover has run else: cost_incurred = (premium_amount / 365) * period_lasted if amount_paid >= cost_incurred: refund_amount = amount_paid - cost_incurred # TODO: Create a clause for handling amount paid elif refund_type == "benefit": # deactivate previous policy child_policy.deactivate() # create new transaction with the same child policy number and vehicle details revised_policy = self.revise_child_policy( "REF", child_policy, policy_details, "benefit_removed") # Append any remaining benefits # first get the id of the cancelled benefit cancelled_benefit = policy_details["benefit_id"] # get remaining remaining_benefits = [ i.serialize() for i in child_policy.benefits if i.id != cancelled_benefit] # append them to the revised policy ChildController.add_benefits( remaining_benefits, revised_policy) # get refund amount based on the new recalculated premium amount new_premium_amount = policy_details["premium_amount"] previous_premium = child_policy.premium_amount # difference premium_change = previous_premium - new_premium_amount # If the policy has run for 30 days, refund full difference period_lasted = (datetime.now() - child_policy.date_activated).days amount_to_revise = (period_lasted / 365) * premium_change refund_amount = amount_paid # TODO: Revise transaction table and update date due using the amount to revise elif refund_type == "sum_insured": # create new child policy based on new details after downward revision of sum insured # deactivate previous policy child_policy.deactivate() # create transaction with new details new_child = self.create_child( policy_details, child_policy.cp_number, company_id, child_policy.master_policy) # TODO: update with new dates new_child.activate() # get refund amount based on the new recalculated premium amount new_premium_amount = policy_details["premium_amount"] previous_premium = child_policy.premium_amount # difference premium_change = previous_premium - new_premium_amount # If the policy has run for 30 days, refund full difference period_lasted = (datetime.now() - child_policy.date_activated).days amount_to_revise = (period_lasted / 365) * premium_change refund_amount = amount_to_revise # TODO: Revise transaction table and update date due using the amount to revise return make_response(helper.make_rest_success_response("Refund successful", refund_amount), 200) elif transaction_type == 'CNC': # To cancel a transaction child_controller = ChildController() child_controller.cancel(policy_details['child_policy_id']) return make_response(helper.make_rest_success_response("Policy cancelled successfully"), 200) else: response = helper.make_rest_fail_response("Failed") return make_response(response, 500)
def put(self): """ registration completion of a user and profile update :return: """ # get user id user_id = get_jwt_identity() # get the user details from the request sent by the client user_details = user_parser.parse_args() customer_details = customer_parser.parse_args() if user_details['customer_id']: user_id = user_details['customer_id'] # check if the user exists user = User.get_user_by_id(user_id) # if the user is an agent and is updating # details on behalf of a customer # we can check whether the customer exists or not # if user exists, then update their details if user: # get their role claims = get_jwt_claims() role = claims['role'] if user_details['customer_id']: user = User.get_user_by_id(user_details['customer_id']) role = 'IND' if user_details['update_type'] == "password": updateController.update_user_password( user_details['new_password'], user_id) elif user_details['update_type'] == "personal": user_details.update({ 'birth_date': UserRegister.format_birth_date( str(user_details['birth_date'])) }) updateController.update_personal_details(user_details, user_id) elif user_details['update_type'] == "location": updateController.update_location_details( user_details, role, user_id) elif user_details['update_type'] == "agency": updateController.update_agency_details(user_details, role, user_id) elif user_details['update_type'] == "complete_profile": user_details['birth_date'] = UserRegister.format_birth_date( user_details['birth_date']) updateController.complete_user_profile(user_details, user_id, role) elif user_details['update_type'] == "social": updateController.update_social_profile(user_details, user_id, role) elif user_details['update_type'] == "image": updateController.update_avatar_name(user_details['avatar_url'], user_id, role) elif user_details['update_type'] == "extra_info": updateController.update_extra_info(role, user_id, customer_details) else: # if user does not exist response_msg = helper.make_rest_fail_response( "User does not exist") return make_response(response_msg, 404) # update was successful response_msg = helper.make_rest_success_response(f"Update successful.") return make_response(response_msg, 200)