def action(request):
try:
user = get_user_model()\
.objects\
.filter(user_account__account_id=user_account_id)\
.select_related()\
.get()
user_account = user.user_account
response = {
'success': True,
'user_account': user_account.as_dict()
}
status = 200
except ObjectDoesNotExist as e:
logger.exception(e)
response = {
'success': False,
'message': 'User not found.',
}
status = 404
except Exception as e:
logger.exception(e)
response = {'success': False, 'message': 'Error fetching data'}
status = 502
return JsonResponse(response, status=status)
def action(request):
response = {'success': False}
try:
reset_pin_code = api.get_reset_pin_code(pin_reset_id)
except ResetPINCode.DoesNotExist:
status = 404
response['message'] = 'Reset PIN expired or invalid'
else:
form = forms.ResetPINForm(request.POST, request.user)
if form.is_valid():
with db_transaction.atomic():
pin = form.cleaned_data['pin']
try:
response['success'] = api.reset_pin(
reset_pin_code, pin)
status = 200
except Exception as e:
logger.exception(e)
status = 500
response['success'] = False
response['message'] = 'Error setting PIN.'
else:
response['errors'] = form.errors
status = 500
return JsonResponse(response, status=status)
def action(request):
if request.user.is_authenticated:
response = {
'success': False,
'message': 'Already registered bruh!'
}
status = 302
else:
form = forms.VerifyInviteeForm(request.POST)
if not form.is_valid():
response = {
'success': False,
'errors': dict(form.errors.items()),
'message': 'Error registering the user.'
}
status = 402
else:
response = {
'success': True,
'message': 'Validation successful.'
}
status = 200
return JsonResponse(response, status=status)
def reversal_result_url(request, organization_id=None, reference=None):
try:
with db_transaction.atomic():
mpesa_transaction = get_object_or_404(
MpesaTransaction.objects.filter(
command_id=enums.CommandID.UTILITY_TRANSACTION_REVERSAL,
sender_account__organization__organization_id=
organization_id,
transaction_id=reference,
transaction_time__isnull=True,
transaction_amount__isnull=True,
response_payload__isnull=True))
return process_request(request,
mpesa.process_reversal_result,
mpesa_transaction=mpesa_transaction)
except (ObjectDoesNotExist, Http404) as e:
logger.exception(e)
status = 404
response = {"message": "Item not found", "success": False}
except Exception as e:
logger.exception(e)
response = {"message": "Internal error", "success": False}
status = 400
return JsonResponse(response, status=status)
def authenticate(request, organization_id=None):
try:
form = forms.AuthenticationForm(request.POST)
if form.is_valid():
short_code = form.cleaned_data['short_code']
response = {
"authentication_token":
mpesa.request_authentication(request.user, organization_id,
short_code),
}
status = 200
except (ObjectDoesNotExist, Http404) as e:
logger.exception(e)
response = {
"message": "Please complete system setup first",
"success": False
}
status = 404
except Exception as e:
logger.exception(e)
response = {"message": "Internal Error", "success": False}
status = 500
return JsonResponse(response, status=status)
def b2c_result_url(request, organization_id=None, reference=None):
logger.info("Processing B2C Request result for %s transaction id %s" %
(organization_id, reference))
try:
with db_transaction.atomic():
_qs = MpesaTransaction.objects.filter(
command_id=enums.CommandID.B2C_BUSINESS_PAYMENT,
sender_account__organization__organization_id=organization_id)
_qs = _qs.filter(transaction_id=reference,
transaction_time__isnull=True)
_qs = _qs.filter(transaction_amount__isnull=True,
response_payload__isnull=True)
mpesa_transaction = get_object_or_404(_qs)
logger.info("mpesa transaction %s found, and processed" %
mpesa_transaction.transaction_id)
return process_request(request,
mpesa.process_b2c_result,
mpesa_transaction=mpesa_transaction)
except (ObjectDoesNotExist, Http404) as e:
logger.exception(e)
status = 404
response = {"message": "Item not found", "success": False}
except Exception as e:
logger.exception(e)
response = {"message": "Internal error", "success": False}
status = 400
return JsonResponse(response, status=status)
def process_request(request, processor, *args, **kwargs):
logger.info("Processing request: %s" % processor)
try:
data = json.loads(request.body)
logger.debug(data)
result_code = processor(data, *args, **kwargs)
if result_code == enums.ResultCode.success:
logger.debug("Result processed successfully")
response = {
"ResultCode": enums.ResultCode.success,
"ResultDesc": "Accepted"
}
else:
logger.debug(f"Result not processed successfully {result_code}")
response = {"ResultCode": result_code, "ResultDesc": "Rejected"}
status = 200
except Exception as e:
logger.exception("Error processing request")
status = 500
response = {
"ResultCode": enums.ResultCode.internal_failure,
"ResultDesc": "Rejected"
}
logger.info("Finished processing request: %s" % processor)
return JsonResponse(response, status=status)
def loan_limit(request, loan_profile_id=None):
try:
loan_profile = api.get_loan_profile(loan_profile_id=loan_profile_id)
response = {
'success':
True,
'eligible': (loan_profile.loan_limit > 0)
and loan_profile.status != enums.LoanProfileStatus.BLACKLISTED,
'loan_limit': ((D('0.0') if (loan_profile.loan_limit < D('0.0'))
else loan_profile.loan_limit)
or settings.HARD_LOAN_LIMIT)
}
status = HTTPStatus.OK
except (ObjectDoesNotExist, Http404) as e:
logger.exception(e)
response.update({
"message": "Please complete system setup first",
"success": False
})
status = HTTPStatus.NOT_FOUND
except Exception as e:
logger.exception(e)
response.update({"message": "Internal Error", "success": False})
status = HTTPStatus.INTERNAL_SERVER_ERROR
return JsonResponse(response, status=status)
def action(request):
if request.user.is_authenticated:
response = {
'success': False,
'message': 'Already authenticated bruh!'
}
status = 302
else:
form = forms.LoginForm(request.POST)
if not form.is_valid():
response = {
'success': False,
'errors': dict(form.errors.items()),
'message': 'Error registering the user.'
}
status = 402
else:
token = form.generate_token()
response = {
'success': True,
'token': {
'user_account_id': token.user.user_account.account_id,
'access': token.access,
'refresh': token.refresh,
'expires': 3600
}
}
status = 200
return JsonResponse(response, status=status)
def c2b_validation_url(request, organization_id=None, reference=None):
try:
logger.debug(request.body)
data = json.loads(request.body)
logger.debug(data)
form = forms.APIC2BForm(data)
status = 200
if form.is_valid():
return process_request(request,
mpesa.process_c2b_validation_request,
organization_id=organization_id,
reference=reference)
else:
status = 400
response = {
"message": "Error in values passed",
"success": False,
"errors": form.errors
}
except (ObjectDoesNotExist, Http404) as e:
logger.exception(e)
status = 404
response = {"message": "Item not found", "success": False}
except Exception as e:
logger.exception(e)
response = {"message": "Internal error", "success": False}
status = 400
return JsonResponse(response, status=status)
def action(request):
response = {}
try:
form = forms.InviteMemberForm(request.POST, request.user)
status = 200
if form.is_valid():
phone_number_invited = form.cleaned_data['phone_number']
try:
invitation = api.get_pending_invitation(
request.user, phone_number_invited)
logger.debug("And invitation exists to this user")
is_verified = False
except ObjectDoesNotExist:
logger.debug("Not invitation exists to this user")
#1. Check if the phone number is already the system and verified
is_verified = identity_is_verified(phone_number_invited)
#2. Create a connection if the user is verified or not
invitation = api.create_member_invitation(
request.user,
phone_number_invited,
is_verified=is_verified)
#3. update the response
response.update(
success=True,
message='Member Invited successfully',
invitation=dict(
phone_number=phone_number_invited,
invitee_is_verified=is_verified,
invitation_id=invitation.invitation_id,
invited_by=invitation.invited_by.account_id,
invitation_code=invitation.invitation_code,
expires_at=invitation.expires_at))
else:
logger.debug(form.errors)
response.update(
success=False,
message=
"Error inviting member. The phone number is invalid or Connection already exists.",
errors=dict(form.errors.items()))
except ObjectDoesNotExist as e:
logger.exception(e)
response = {'success': False, 'message': 'User not found.'}
status = 404
except Exception as e:
logger.exception(e)
response = {'success': False, 'message': 'Error fetching data'}
status = 502
return JsonResponse(response, status=status)
def phone_number_verification(request):
response = {}
if request.method == "POST":
pass
else:
pass
return JsonResponse(response)
def check_bank_account_balances(request):
response = {}
if request.method == "POST":
api.update_balance_sheet()
response.update(success=True)
return JsonResponse(response)
def verify_identity(request):
response = {}
try:
if api.request_mpesa_verification(request.user):
response['success'] = True
except Exception as e:
logger.exception(e)
return JsonResponse(response)
def mpesa_express_stk_push(request, organization_id):
form = forms.B2CForm(request.POST)
if form.is_valid():
transaction = mpesa.request_mpesa_express_stk_push(
organization_id, form.cleaned_data['short_code'],
form.cleaned_data['phone_number'], form.cleaned_data['amount'])
response = {'success': True, 'transaction': transaction.as_dict()}
else:
response = {"errors": dict(form.errors.items()), "success": False}
return JsonResponse(response, status=200)
def loan_profile(request):
response = {}
try:
response['success'] = True
response['loan_profile'] = api.get_loan_profile(request.user).as_dict()
status = 200
except Exception as e:
logger.exception(e)
response['success'] = False
status = 500
return JsonResponse(response, status=status)
def action(request):
response = {}
try:
form = forms.SecureAccountForm(request.POST)
if form.is_valid():
pin = form.cleaned_data['pin']
user = get_object_or_404(
User, user_account__account_id=user_account_id)
expiry_date = (timezone.now() +
datetime.timedelta(days=(30 * 3)))
try:
authentication = Authentication.objects.get(
user=user, expires__gt=timezone.now())
authentication.expires_at = expiry_date
authentication.save()
except Authentication.DoesNotExist as e:
logger.debug(
"No password set, creating a new password to expire in on"
)
Authentication.objects.create(
user=user,
security_pin=make_password(pin),
expires=expiry_date)
response = {
'success': True,
'message': 'Security PIN set successfully'
}
status = 200
else:
response['errors'] = form.errors
except ObjectDoesNotExist as e:
logger.exception(e)
response = {'success': False, 'message': 'User not data.'}
status = 404
except Exception as e:
logger.exception(e)
response = {'success': False, 'message': 'Error fetching data'}
status = 502
return JsonResponse(response, status=status)
def b2b_transact(request):
form = forms.B2BForm(request.POST)
if form.is_valid():
b2b_account_sender_short_code = form.cleaned_data['sender_short_code']
b2b_account_receiver_short_code = form.cleaned_data[
'receiver_short_code']
amount = form.cleaned_data['amount']
response = mpesa.request_b2b_transaction(
b2b_account_sender_short_code, b2b_account_receiver_short_code,
amount, request.user)
else:
response = form.errors
return JsonResponse(response)
def create_organization(request):
form = forms.OrganizationForm(request.POST)
if form.is_valid():
with db_transaction.atomic():
organization = form.save()
response = {
"organization_id": organization.organization_id,
"success": True
}
status = 200
else:
response = {"errors": form.errors, "success": False}
status = 400
return JsonResponse(response, status=status)
def transaction_reverse(request):
form = forms.B2CForm(request.POST)
if form.is_valid():
transaction_id = form.cleaned_data['transaction_id']
comment = form.cleaned_data['comment']
occassion = form.cleaned_data['occassion']
response = mpesa.request_transaction_reverse(transaction_id,
remarks=comment,
occassion=occassion)
status = 200
else:
response = {"errors": dict(form.errors.items()), "success": False}
status = 400
return JsonResponse(response, status=status)
def check_transaction_status(request):
form = forms.CheckTransactionStatusForm(request.POST)
if form.is_valid():
transaction_id = form.cleaned_data['transaction_id']
notes = form.cleaned_data['notes']
mpesa_user = request.user.mpesa_user
response = mpesa.request_check_transaction_status(transaction_id,
mpesa_user,
remarks=notes)
status = 200
else:
response = {"errors": dict(form.errors.items()), "success": False}
status = 400
return JsonResponse(response, status=status)
def action(request):
try:
logger.debug(request.body)
data = json.loads(request.body)
logger.debug(data)
response = api.reversal_queue_timeout_url(
data, organization_id=organization_id, reference=reference)
status = 200
except Exception as e:
logger.exception(e)
response = {"message": "Internal error", "success": False}
status = 400
return JsonResponse(response, status=status)
def loan_status(request, loan_account_id=None):
loan_account = api.get_active_loan_account(request.user,
loan_account_id=loan_account_id)
response = {'loan_account': loan_account.account_id}
if loan_account.status in (enums.LoanStatus.PAID_OFF,
enums.LoanStatus.WRITTEN_OFF,
enums.LoanStatus.CLOSED):
response.update({
'loan_balance':
0,
'success':
False,
'message':
"Loan repayment unsuccessful. Your loan has already been closed."
})
status = HTTPStatus.PRECONDITION_REQUIRED
elif loan_account.status in (enums.LoanStatus.ACTIVE,
enums.LoanStatus.DISBURSED,
enums.LoanStatus.IN_ARREARS):
try:
loan_balance = loan_account.outstanding_balance
response.update({'loan_balance': loan_balance, "success": True})
status = HTTPStatus.OK
except (ObjectDoesNotExist, Http404) as e:
logger.exception(e)
response.update({
"message": "Please complete system setup first",
"success": False
})
status = HTTPStatus.NOT_FOUND
except Exception as e:
logger.exception(e)
response.update({"message": "Internal Error", "success": False})
status = HTTPStatus.INTERNAL_SERVER_ERROR
else:
response.update({'success': False, 'message': "Invalid Loan state."})
return JsonResponse(response, status=status)
def c2b_stk_push_callback_url(request, organization_id=None, reference=None):
try:
return process_request(request,
mpesa.process_c2b_mpesa_express_response,
organization_id=organization_id,
reference=reference)
except (ObjectDoesNotExist, Http404) as e:
logger.exception(e)
status = 404
response = {"message": "Item not found", "success": False}
except Exception as e:
logger.exception(e)
response = {"message": "Internal error", "success": False}
status = 400
return JsonResponse(response, status=status)
def b2c_transact(request, organization_id=None):
try:
form = forms.B2CForm(request.POST)
if form.is_valid():
sender_short_code = form.cleaned_data['short_code']
receiver_phone_number = form.cleaned_data['phone_number']
amount = form.cleaned_data['amount']
notes = form.cleaned_data['notes']
transaction = mpesa.request_b2c_transaction(organization_id,
sender_short_code,
receiver_phone_number,
amount,
request.user,
remarks=notes)
response = {
'success': True,
'message': 'B2C Transaction successful',
'transaction_id': transaction.transaction_id
}
status = 200
else:
response = {"errors": dict(form.errors.items()), "success": False}
status = 400
except ObjectDoesNotExist as e:
logger.exception(e)
response = {
"message": "Please complete system setup first",
"success": False
}
status = 404
except Exception as e:
logger.exception(e)
response = {"message": "Internal Error", "success": False}
status = 500
return JsonResponse(response, status=status)
def action(request):
logger.info("Processing B2C Request result for %s transaction id %s" %
(organization_id, reference))
try:
logger.debug(request.body)
data = json.loads(request.body)
logger.debug(data)
response = api.b2c_result_url(data,
organization_id=organization_id,
reference=reference)
status = 200
except Exception as e:
logger.exception(e)
response = {"message": "Internal error", "success": False}
status = 400
return JsonResponse(response, status=status)
def action(request):
response = {'success': False}
logger.debug(f"User is super user? = {request.user.is_superuser}")
form = forms.RequestResetPINForm(request.POST)
if form.is_valid():
requestee_phone_number = form.cleaned_data[
'requestee_phone_number']
reset_pin_code = api.request_user_pin_reset(
request.user, requestee_phone_number)
response.update(success=True,
reset_pin_code=reset_pin_code.as_dict())
status = 200
else:
response['errors'] = form.errors
status = 500
return JsonResponse(response, status=status)
def create_personal_account(request, organization_id=None):
form = forms.PersonalAccountForm(request.POST)
if form.is_valid():
try:
data = form.cleaned_data
personal_mpesa_account = mpesa.create_personal_account(
organization_id, data['phone_number'])
response = {
"mpesa_account_id": personal_mpesa_account.account_id,
"success": True
}
status = 200
except Http404:
status = 404
response = {"success": False, "message": "Error creating account"}
else:
response = {"errors": form.errors, "success": False}
status = 400
return JsonResponse(response, status=status)
def balance_check_queue_timeout_url(request,
organization_id=None,
reference=None):
try:
with db_transaction.atomic():
mpesa_transaction = get_object_or_404(
MpesaTransaction.objects.filter(
command_id=enums.CommandID.UTILITY_ACCOUNT_BALANCE,
sender_account__organization__organization_id=
organization_id,
transaction_id=reference,
transaction_time__isnull=True,
transaction_amount__isnull=True,
response_payload__isnull=True))
logger.debug(request.body)
data = json.loads(request.body)
logger.debug(data)
mpesa_transaction.response_payload = data
mpesa_transaction.save()
response = {"message": "Received successfully.", "success": True}
status = 200
except (ObjectDoesNotExist, Http404) as e:
logger.exception(e)
status = 404
response = {"message": "Item not found", "success": False}
except Exception as e:
logger.exception(e)
response = {"message": "Internal error", "success": False}
status = 400
return JsonResponse(response, status=status)
def c2b_register_urls(request, organization_id):
try:
form = forms.C2BForm(request.POST)
if form.is_valid():
short_code = form.cleaned_data['short_code']
validation_url = form.cleaned_data['validation_url']
confirmation_url = form.cleaned_data['confirmation_url']
mpesa_registered_url = mpesa.request_c2b_register_urls(
organization_id,
short_code,
validation_url=validation_url,
confirmation_url=confirmation_url)
response = {
"success": True,
"mpesa_registered_url": mpesa_registered_url.reference
}
status = 200
else:
status = 400
response = {"errors": dict(form.errors.items()), "success": False}
except (ObjectDoesNotExist, Http404) as e:
logger.exception(e)
response = {
"message": "Please complete system setup first",
"success": False
}
status = 404
except Exception as e:
logger.exception(e)
response = {"message": "Internal Error", "success": False}
status = 500
return JsonResponse(response, status=status)
