def adduser(request):
email = request.session.get('email', None)
user_type = request.session.get('user_type', None)
if email and user_type == 1:
if request.method == "POST":
first_name = request.POST.get('first_name', None)
last_name = request.POST.get('last_name', None)
email = request.POST.get('email', None)
address = request.POST.get('address', None)
password = request.POST.get('password', None)
amount = request.POST.get('amount', None)
context_dict = dict()
if (first_name == '') or (last_name == '') or (email == '') or (address == '') or (password == '' )or (amount == '' ):
context_dict['messages'] = "First name, Last name, email, password, Amount, address can't be empty. all fields required."
context_dict['status'] = 0
else:
check_email = email__exist(email)
if check_email:
context_dict['messages'] = "This email is already registered please enter another one."
context_dict['status'] = 0
else:
gmt = time.gmtime()
userData = AuthUser()
dataDeposit = Deposit()
accuntData = CustomerAccountdetail()
tran = Transaction()
userData.first_name = first_name.capitalize()
userData.last_name = last_name
userData.email = email.capitalize()
userData.password = make_password(password,salt=None,hasher='default')
userData.username = email
userData.is_superuser = 2
userData.is_staff = 1
userData.is_active = 1
userData.date_joined = datetime.now()
userData.save()
# print(userData.id)
accuntData.address = address
accuntData.account_no = calendar.timegm(gmt)
accuntData.acc_user_id = userData.id
accuntData.created = datetime.now()
accuntData.save()
dataDeposit.amount += int(amount)
dataDeposit.date = datetime.now()
dataDeposit.dep_user_id = userData.id
dataDeposit.save()
tran.amount = amount
tran.account_no = accuntData.account_no
tran.tran_type = 'Deposit'
tran.date = datetime.now()
tran.tran_user_id = userData.id
tran.save()
context_dict['messages'] = "Successfully Created Account."
context_dict['status'] = 1
return JsonResponse(context_dict)
elif email:
return HttpResponseRedirect('/account/summary')
else:
return HttpResponseRedirect('/')
def send_money(request):
request_details = request.data
try:
amount = decimal.Decimal(request_details['amount'])
sender = User.objects.get(email=request_details['sender'])
receiver = User.objects.get(email=request_details['receiver'])
except ObjectDoesNotExist:
return Response({'error': 'Account Does Not Exist'},
status=status.HTTP_404_NOT_FOUND)
if request_details['sender'] == request_details['receiver']:
return Response({'error': 'You cannot send to same account'},
status=status.HTTP_422_UNPROCESSABLE_ENTITY)
if amount < 10.0:
return Response(
{'error': "Transaction Failed, Amount is less than 10"},
status=status.HTTP_400_BAD_REQUEST)
# sender Account deducted
sender_acc = Account.objects.get(user=sender)
if sender_acc.balance > amount and sender_acc.balance > 1:
sender_balance = sender_acc.balance - amount
sender_acc.balance = sender_balance
sender_acc.save()
# receiver Account added
receiver_acc = Account.objects.get(user=receiver)
receiver_balance = receiver_acc.balance + amount
receiver_acc.balance = receiver_balance
receiver_acc.save()
# Add transaction
tran = Transaction(transact_account=sender_acc,
sender=sender.email,
receiver=receiver.email,
amount=amount,
transaction_type="send")
tran.save()
push_notify(
"Wallet Transaction successful",
str("Transfer cash of Ksh " + str(amount) + " From " +
str(sender.email) + " To " + str(receiver.email)))
return Response({'success': "Transaction successful"})
else:
return Response(
{
'error':
"You have insufficient Amount in account to complete the transaction"
},
status=status.HTTP_400_BAD_REQUEST)
def clean(self):
description = self.cleaned_data.get("description")
amount = self.cleaned_data.get("amount")
source = self.cleaned_data.get("sourceiban")
destinationiban = self.cleaned_data.get("destinationiban")
if source.user != self.request.user:
raise ValidationError("This is not your Account")
try:
destination = Accounts.objects.get(iban = destinationiban)
except Accounts.DoesNotExist:
raise ValidationError("Wrong Destination IBAN")
if source.amount > amount:
transaction = Transaction()
transaction.amount = amount
transaction.description = description
transaction.sourceaccount = source
transaction.destinationaccount = destination
transaction.currency_type = source.currency_type
transaction.sending_date = date.today()
transaction.make_transaction()
else:
raise ValidationError("Not Enough Account Balance")
def close_accounts(self, request):
accounts = Account.objects.filter(is_active=True,
account_type__category__in=[2, 3, 4])
income_value = 0
debits = []
credits = []
has_income_adjustment = False
closing_journal = JournalEntry(
date=timezone.now(),
creator=request.user,
description="Auto-generated closing journal",
entry_type=JournalEntryTypes.CLOSING,
is_approved=None)
closing_journal.save()
for account in accounts:
balance = account.get_balance()
if balance == 0:
# No need to close an account that does not have a balance
continue
closer = Transaction(affected_account=account,
journal_entry=closing_journal,
is_debit=not account.is_debit(),
value=abs(balance))
if account.account_type.category == 3 or account.account_type.category == 4:
has_income_adjustment = True
if closer.is_debit:
debits.append(closer)
else:
credits.append(closer)
income_value += closer.get_value()
elif account.account_type.category == 2 and "Drawing" in account.name:
# NOTE: We are only accounting for business owner equity here, not shareholders equity.
try:
equity_adjuster = Account.objects.get_by_natural_key(
account.name.replace("Drawing", "Capital"))
if not equity_adjuster.is_active:
equity_adjuster.is_active = True
equity_adjuster.save()
except Model.DoesNotExist:
closing_journal.delete()
return Response({
'message': 'The Drawing account "%s" does not have a corresponding Capital account to adjust.' % \
account.name }, status=403)
debits.append(
Transaction(affected_account=equity_adjuster,
journal_entry=closing_journal,
value=abs(balance),
is_debit=True))
credits.append(closer)
if not len(debits) and not len(credits):
closing_journal.delete()
return Response({'message': 'Accounts have already been closed.'},
status=200)
if has_income_adjustment:
try:
income_account = Account.objects.get_by_natural_key(
'Retained Earnings')
if not income_account.is_active:
income_account.is_active = True
income_account.save()
except Model.DoesNotExist:
closing_journal.delete()
return Response(
{
'message':
'There is no acccount named "Retaining Earnings".'
},
status=403)
income_adjuster = Transaction(affected_account=income_account,
journal_entry=closing_journal,
value=abs(income_value))
income_adjuster.is_debit = income_value < 0 # if income_value is positive, it debits the Retained Earnings else credits
if income_adjuster.is_debit:
debits.append(income_adjuster)
else:
credits.append(income_adjuster)
transaction_list = debits + credits
for transaction in transaction_list:
transaction.save()
return Response({'message': 'Closing Entry has been created.'},
status=200)
def transaction_for_account(request):
if request.user.is_authenticated():
json_obj = json.loads(request.body)
data = json_obj['data']
Acc_list = data.get("Acc_list")
transaction_date = data.get("transaction_date")
transactiontype = data.get("transactiontype")
transactiontype_obj = TransactionType(optionType=transactiontype)
transactiontype_obj.save()
user_obj = User.objects.get(id=request.user.id)
transaction_date = datetime.datetime.fromtimestamp(transaction_date /
1000)
description = data.get("description")
try:
accountingyear_obj = AccountingYear.objects.get(
start_date__lte=transaction_date,
end_date__gte=transaction_date,
user__id=request.user.id)
except AccountingYear.DoesNotExist:
if transaction_date <= datetime.datetime(transaction_date.year, 03,
31, 23, 59, 59):
start_date = datetime.datetime(transaction_date.year - 1, 04,
01, 00, 00, 00)
end_date = datetime.datetime(transaction_date.year, 03, 31, 23,
59, 59)
user_obj = User.objects.get(id=request.user.id)
accountingyear_obj = AccountingYear(start_date=start_date,
end_date=end_date,
duration=1,
user=user_obj)
accountingyear_obj.save()
else:
year = int(transaction_date.year)
start_date = datetime.datetime(transaction_date.year, 04, 01,
00, 00, 00)
end_date = datetime.datetime(transaction_date.year + 1, 03, 31,
23, 59, 59)
user_obj = User.objects.get(id=request.user.id)
accountingyear_obj = AccountingYear(start_date=start_date,
end_date=end_date,
duration=1,
user=user_obj)
accountingyear_obj.save()
transaction_obj = Transaction(transaction_date=transaction_date,
description=description,
transactiontype=transactiontype_obj,
user=user_obj)
transaction_obj.save()
accountingyear_obj.transaction.add(transaction_obj)
accountingyear_obj.save()
for i in Acc_list:
amount = i['amount']
account = i['account']
account_id = account.get("id")
is_debit = i['is_debit']
print is_debit.capitalize()
if is_debit == "D":
is_debit = True
else:
is_debit = False
account_obj = Account.objects.get(id=account_id)
print account_obj
transactionrecord_queries = TransactionRecord(amount=amount,
is_debit=is_debit,
account=account_obj)
transactionrecord_queries.save()
transaction_obj.transaction_record.add(transactionrecord_queries)
transaction_obj.save()
print "Transaction saved Successfully..."
return HttpResponse(json.dumps({
"validation": "Transaction Saved Successfully",
"status": True
}),
content_type="application/json")
