def get(self, status):
"""
Get all insurance companies, together with the company details"""
# fetch all companies, then their details.
companies_list = CompanyDetails.get_companies()
list_of_companies = []
if companies_list:
for company in companies_list:
list_of_products = company['products']
licenced_classes = [
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
]
# status 1 for registered and O for unregistered
if status == 0:
# return unregistered companies
# Only return companies that sell general insurance policies and
# don't have an associated insurance company yet
if len(company['products']) != 0 and len(
company['insurance_company']) == 0:
if random.choice(
company['products']) in licenced_classes:
data = {
"id": company['id'],
"name": company['name']
}
list_of_companies.append(data)
if status == 1:
# only return companies that are registered
if len(company['products']) != 0 and len(
company['insurance_company']) != 0:
if random.choice(
company['products']) in licenced_classes:
data = {
"id": company['id'],
"name": company['name'],
"products": company['products']
}
list_of_companies.append(data)
response = helper.make_rest_success_response(
"Success", list_of_companies)
return make_response(response, 200)
else:
response = helper.make_rest_success_response(
"No company registered yet")
return make_response(response, 404)
def get(self, email):
"""
Get customer details using an attribute such as email
"""
# object to store all user data
data = {}
# get the agency id of the organization requesting for customer details
contact_id = get_jwt_identity()
# get user role
claims = get_jwt_claims()
role = claims['role']
# company_id = self.get_agency_id(role, contact_id)
# get user id from customer email
customer = User.get_user_by_email(email)
# get customer details using the user_id
customer_details = self.get_customer_details(customer.id)
data.update({"customer": customer_details})
# get the cover data using the customer number in customer details
cust_no = customer_details["customer_number"]
cover_details = self.get_cover_details(cust_no)
data.update({"cover_details": cover_details})
response_msg = helper.make_rest_success_response(
"Success", data)
return make_response(response_msg, 200)
def post(self):
details = policy_parser.parse_args()
# get the current agency details
uid = get_jwt_identity()
# use the uid to get company through the company contact_id
company = InsuranceCompany.get_company_by_contact_person(uid)
"""
First add the loading to the loadingss table, regardless of insurance company
"""
existing_loadings = Loadings.get_all_loadings()
names = [loading['name'] for loading in existing_loadings]
loading_name = details['name']
# check whether the benefits to be added already exist
if loading_name not in names:
new_loading = Loadings(loading_name)
new_loading.save()
"""
Store loadings offered by a particular company together with limit
"""
# get the loading_id
loading_id = Loadings.get_loading_id_by_name(loading_name)
company_loading = ICLoadings(company.id, loading_id, details['rate'])
company_loading.save()
"""
Send success response
"""
response_msg = helper.make_rest_success_response(
"Loading added successfully")
return make_response(response_msg, 200)
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(self, child_policy_id):
"""
get the transaction history of a particular policy
:return:
"""
transaction_history = PolicyPayments.get_payments_history(
child_policy_id)
if transaction_history:
response_message = "Success"
return make_response(
helper.make_rest_success_response(response_message,
transaction_history), 200)
response_message = "No data was found"
return make_response(
helper.make_rest_success_response(response_message), 404)
def post(self):
# get the insurance company 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 = self.get_agency_id(role, uid)
policy_details = policy_parser.parse_args()
# store the products affiliated with a particular company, one insurance class has many subclasses
insurance_class = policy_details['insurance_class']
subclass = policy_details["sub_class"]
if insurance_class and subclass:
for i in subclass:
new_product = ICProducts(company.id, insurance_class, i)
new_product.save()
if policy_details['rate']:
# set the insurance_company's rate
data = {"rate": policy_details['rate']}
company.update(data)
if policy_details["ncd_rate"]:
data = {"ncd_rate": policy_details["ncd_rate"]}
company.update(data)
response = helper.make_rest_success_response("Success")
return make_response(response, 200)
def post(self):
details = policy_parser.parse_args()
# get the current agency details
uid = get_jwt_identity()
# use the uid to get company through the company contact_id
company = InsuranceCompany.get_company_by_contact_person(uid)
"""
First add the extension to the extensions table, regardless of insurance company
"""
exisiting_extensions = Extension.get_all_extensions()
names = [extension['name'] for extension in exisiting_extensions]
extension_name = details['name']
# check whether the benefits to be added already exist
if extension_name not in names:
new_extension = Extension(extension_name)
new_extension.save()
"""
Store benefits offered by a particular company together with limit
"""
# get the extension_id
extension = Extension.get_extension_id_by_name(extension_name)
company_extension = ICExtensions(company.id, extension.id,
details['free_limit'],
details['max_limit'], details['rate'])
company_extension.save()
"""
Send success response
"""
response_msg = helper.make_rest_success_response(
"Extension added successfully")
return make_response(response_msg, 200)
def post(self):
# benefits handler
details = policy_parser.parse_args()
# get the current agency details
uid = get_jwt_identity()
# use the uid to get company through the company contact_id
company = InsuranceCompany.get_company_by_contact_person(uid)
# First add the benefit to the benefits table, regardless of insurance company
exisiting_benefits = Benefit.get_all_benefits()
names = [benefit['name'] for benefit in exisiting_benefits]
benefit_name = details['name']
# check whether the benefits to be added already exist
if benefit_name not in names:
new_benefit = Benefit(benefit_name)
new_benefit.save()
# Store benefits offered by a particular company together with limit
# get the benefit_id
benefit = Benefit.get_benefit_by_name(benefit_name)
company_benefit = ICBenefits(company.id, benefit.id,
details['free_limit'],
details['max_limit'], details['rate'])
company_benefit.save()
# Send success response
response_msg = helper.make_rest_success_response(
"Benefit added successfully")
return make_response(response_msg, 200)
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 get(self):
"""
get all the organization types for organization customer onboard
:return:
"""
org_types = OrganizationTypes.get_organization_customer_types()
msg = "Request was successful"
response = helper.make_rest_success_response(
msg, {"organizations": org_types})
return make_response(response, 200)
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):
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):
counties = County.get_all_counties()
constituencies = Constituency.get_all_constituencies()
wards = Ward.get_all_wards()
response = {
"counties": counties,
"constituencies": constituencies,
"wards": wards
}
response = helper.make_rest_success_response("Success", response)
return make_response(response, 200)
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):
"""
generate an unfresh token
unfortunately this token is limited to certain CRUD operations
"""
curr_user_id = get_jwt_identity() # Fetch supervisor_id
claims = get_jwt_claims()
role = claims['role']
new_token = token_handler.refresh_user_token(curr_user_id, role)
response = {'access_token': new_token}
return make_response(
helper.make_rest_success_response("Success", response))
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 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 delete(self):
"""
deactivate the user account
:return:
"""
role = get_jwt_claims()['role']
customer = json.dumps(customer_parser.parse_args())
cust_no = customer['cust_no']
# update the customer agency relationship if activated
self.delete_cust_agency_relationship(role, cust_no)
response = helper.make_rest_success_response("User was deleted")
return make_response(response, 200)
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, 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 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):
"""
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 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):
"""
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 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 list of staff associated with a particular agency
# first get agent_id
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 = staff_handler.get_agency_id(role, uid)
# get list of staff associated with company
company_staff = self.get_agency_staff(role, company_id)
response = helper.make_rest_success_response(
"Success", {"staff_list": company_staff})
return make_response(response, 200)
def get(self, company_id):
# get the company linked to the associated company
company = InsuranceCompany.get_by_associated_company(company_id)
# get the benefits, loadings and extensions
benefits = ICBenefits.get_benefits_by_company_id(company.id)
loadings = ICLoadings.get_loadings_by_company_id(company.id)
extensions = ICExtensions.get_extensions_by_company_id(company.id)
data = {
"benefits": benefits,
"loadings": loadings,
"extensions": extensions,
"discount": company.ncd_rate,
"rate": company.rate
}
response_msg = helper.make_rest_success_response("Success", data)
return make_response(response_msg, 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)
