def test_stock_splits_quantity(self):
pf = Portfolio.objects.create(name='Test')
sec = Security()
price = Price()
mysec = sec.add('Test', ['SomeAliasString'], '', 'APC.DE', 'Stock')
split = SecuritySplit()
time_price_1 = timezone.now() - datetime.timedelta(days=20)
time_split = timezone.now() - datetime.timedelta(days=10)
time_price_2 = timezone.now() - datetime.timedelta(days=5)
price.add(mysec, time_price_1, 100)
price.add(mysec, time_price_2, 15)
split.add(mysec, time_split, 7)
t = Transaction()
t.add('b', pf, mysec, time_price_1, 100, 100, 100)
t.add('b', pf, mysec, time_split, 90, 100, 100)
t.add('b', pf, mysec, time_price_2, 80, 100, 100)
result = t.get_total_for_portfolio(pf.name, time_price_1)
# print(result[mysec]['nominal'])
self.assertEqual(result[mysec]['nominal'], Decimal('700'))
# import pdb; pdb.set_trace()
result = t.get_total_for_portfolio(pf.name, time_split)
# print(result[mysec]['nominal'])
self.assertEqual(result[mysec]['nominal'], Decimal('790'))
result = t.get_total_for_portfolio(pf.name, time_price_2)
# print(result[mysec]['nominal'])
self.assertEqual(result[mysec]['nominal'], Decimal('870'))
def transfer_goods(request):
"""
function to transfer money to an account in differnt ban to be used for the transfer of goods and services
"""
try:
id1=request.session.get('user_id')
user_accounts = Bank_Account.objects.filter(ba_user_id=id1)
source_acc=request.POST["account1"]
destination_acc=request.session['acc_no_services']
ifsc_code1=request.session['ifsc_code']
# print "\n\n"
# print "source account "
# print source_acc
# print "\n"
# print "destination account "
# print destination_acc
# print "\n"
amount1=request.session['amount']
# print amount1
# print "everything ok \n"
amount=unicodedata.normalize('NFKD', amount1).encode('ascii','ignore')
account1=Bank_Account.objects.filter(ba_acc_no=source_acc)
error1="Not enough money in your account"
error2="Please enter valid amount"
error5="You entered amount more than your accounts transaction limit"
error6="You entered amount more than connected accounts transaction limit"
i = float(amount)
# print "everything ok \n"
# try:
# i = float(amount)
# except ValueError, TypeError:
# return render_to_response("interbank_transfer.html",{'user_accounts':user_accounts,'connected_accounts':connected_accounts,'error':error3,'STATIC_URL':"/static/"})
# else:
# if (i<=0 ):
# return render_to_response("interbank_transfer.html",{'user_accounts':user_accounts,'connected_accounts':connected_accounts,'error':error2,'STATIC_URL':"/static/"})
for acc in account1:
if ((acc.ba_acc_bal)<Decimal(amount)):
return render_to_response("goods_and_services.html",{'user_accounts':user_accounts,'error':error1,'STATIC_URL':"/static/"},context_instance=RequestContext(request))
elif(acc.ba_transaction_limit<Decimal(amount)):
return render_to_response("goods_and_services.html",{'user_accounts':user_accounts,'error':error5,'STATIC_URL':"/static/"},context_instance=RequestContext(request))
else:
acc.ba_acc_bal=acc.ba_acc_bal-Decimal(amount)
print acc.ba_acc_bal
acc.save()
tran=Transaction(t_amount=amount,t_sender_acc_no=source_acc,t_receiver_acc_no=destination_acc,t_rec_ifsc_code=ifsc_code1,t_start_date=datetime.datetime.now(),t_end_date=datetime.datetime.now(),t_status=1,t_transaction_type=3)
tran.save()
del request.session['acc_no_services']
del request.session['ifsc_code']
del request.session['amount']
del request.session['ref_no']
return render_to_response("transaction_status.html",{'STATIC_URL':"/static/"})
except (KeyError):
error3="Please select one source and destination account"
# print "this was a key error"
id1=request.session.get('user_id')
user_accounts = Bank_Account.objects.filter(ba_user_id=id1)
return render_to_response("goods_and_services.html",{'user_accounts':user_accounts,'error':error3,'STATIC_URL':"/static/"},context_instance=RequestContext(request))
def test_transaction_total_with_odd_values(self):
"""Adding Transaction should lead to correct total"""
time = timezone.now().date()
sec = Security.objects.create(name='TestSec', aliases='Test Alias', isin_id='DETest', yahoo_id='ABC',
type='Stock')
pf = Portfolio.objects.create(name='Test')
t = Transaction()
transaction = t.add('b', pf, sec, time, 100, 100, 100)
self.assertEqual(transaction.total, Decimal(-10100))
def show_interbank_transfer(request):
"""
function to transfer money to an account in differnt bank. It displays the accounts added previously by the
user and also has the option of adding a new receiver. It performs various checks on ifsc code and transfer amount.
"""
verification=request.session.get('verification')
t_type1=request.session.get('t_type')
if ((verification==1) and (t_type1=="interbank_transfer.html")):
try:
id1=request.session.get('user_id')
user_accounts = Bank_Account.objects.filter(ba_user_id=id1)
connected_accounts = Connected_Account_Interbank.objects.filter(ca_host_acc_no=id1)
source_acc=request.POST["account1"]
destination_acc=request.POST["account2"]
#print source_acc
#print destination_acc
amount1=request.POST["amount_to_transfer"]
amount=unicodedata.normalize('NFKD', amount1).encode('ascii','ignore')
account1=Bank_Account.objects.filter(ba_acc_no=source_acc)
account2=Connected_Account_Interbank.objects.filter(ca_acc_no=destination_acc) # RECHECK AGAIN the condition
error1="Not enough money in your account"
#print "\n\n\n"
#print destination_acc
#print "\n\n\n"
error2="Please enter valid amount"
error3="Please enter amount in numeric only"
error4="Please choose different source and destination accounts"
error5="You entered amount more than your accounts transaction limit"
error6="You entered amount more than connected accounts transaction limit"
try:
i = float(amount)
except ValueError, TypeError:
return render_to_response("interbank_transfer.html",{'user_accounts':user_accounts,'connected_accounts':connected_accounts,'error':error3,'STATIC_URL':"/static/"})
else:
if (i<=0 ):
return render_to_response("interbank_transfer.html",{'user_accounts':user_accounts,'connected_accounts':connected_accounts,'error':error2,'STATIC_URL':"/static/"})
for acc in account2:
destination_acc_no=acc.ca_acc_no
ifsc_code1=acc.ca_ifsc_code
if(acc.ca_limit<Decimal(amount)):
return render_to_response("interbank_transfer.html",{'user_accounts':user_accounts,'connected_accounts':connected_accounts,'error':error6,'STATIC_URL':"/static/"})
for acc in account1:
if ((acc.ba_acc_bal)<Decimal(amount)):
return render_to_response("interbank_transfer.html",{'user_accounts':user_accounts,'connected_accounts':connected_accounts,'error':error1,'STATIC_URL':"/static/"})
elif(acc.ba_transaction_limit<Decimal(amount)):
return render_to_response("interbank_transfer.html",{'user_accounts':user_accounts,'connected_accounts':connected_accounts,'error':error5,'STATIC_URL':"/static/"})
else:
acc.ba_acc_bal=acc.ba_acc_bal-Decimal(amount)
#print acc.ba_acc_bal
acc.save()
tran_type=request.session.get('neft_or_rtgs')
tran=Transaction(t_amount=amount,t_sender_acc_no=source_acc,t_receiver_acc_no=destination_acc_no,t_rec_ifsc_code=ifsc_code1,t_start_date=datetime.datetime.now(),t_end_date=datetime.datetime.now(),t_status=1,t_transaction_type=tran_type)
tran.save()
del request.session['neft_or_rtgs']
return render_to_response("transaction_status.html",{'STATIC_URL':"/static/"})
def show_thirdparty_transfer(request):
"""
this function transfer the amount to the receiver of same bank.
It shows all the parties added by the user and also checkes teh transfer limit and other things
"""
verification=request.session.get('verification')
t_type1=request.session.get('t_type')
if ((verification==1) and (t_type1=="third_party.html")):
try:
id1=request.session.get('user_id')
user_accounts = Bank_Account.objects.filter(ba_user_id=id1)
connected_accounts = Connected_Account.objects.filter(ca_host_acc_id=id1)
source_acc=request.POST["account1"]
destination_acc=request.POST["account2"]
amount1=request.POST["amount_to_transfer"]
amount=unicodedata.normalize('NFKD', amount1).encode('ascii','ignore')
account1=Bank_Account.objects.filter(ba_acc_no=source_acc)
#print "\n\n\n"
#print id1
#print "\n\n\n"
print destination_acc
account2=Connected_Account.objects.filter(ca_connected_acc_no=destination_acc)#,ca_host_acc_id=id1) # RECHECK AGAIN the condition
print "jij"
#ifsc_code1=account2.ca_ifsc
error1="Not enough money in your account"
error2="Please enter valid amount"
error3="Please enter amount in numeric only"
error4="Please choose different source and destination accounts"
error5="You entered amount more than your accounts transaction limit"
error6="You entered amount more than connected accounts transaction limit"
try:
i = float(amount)
except ValueError, TypeError:
return render_to_response("third_party.html",{'user_accounts':user_accounts,'connected_accounts':connected_accounts,'error':error3,'STATIC_URL':"/static/"})
else:
if (i<=0 ):
return render_to_response("third_party.html",{'user_accounts':user_accounts,'connected_accounts':connected_accounts,'error':error2,'STATIC_URL':"/static/"})
for acc in account2:
destination_acc_no=acc.ca_connected_acc_no
ifsc_code1=acc.ca_ifsc
#print "hello\n\n\n\n"
if(acc.ca_transfer_limit<Decimal(amount)):
return render_to_response("third_party.html",{'user_accounts':user_accounts,'connected_accounts':connected_accounts,'error':error6,'STATIC_URL':"/static/"})
for acc in account1:
if ((acc.ba_acc_bal)<Decimal(amount)):
return render_to_response("third_party.html",{'user_accounts':user_accounts,'connected_accounts':connected_accounts,'error':error1,'STATIC_URL':"/static/"})
elif(acc.ba_transaction_limit<Decimal(amount)):
return render_to_response("third_party.html",{'user_accounts':user_accounts,'connected_accounts':connected_accounts,'error':error5,'STATIC_URL':"/static/"})
else:
acc.ba_acc_bal=acc.ba_acc_bal-Decimal(amount)
#print acc.ba_acc_bal
acc.save()
tran=Transaction(t_amount=amount,t_sender_acc_no=source_acc,t_receiver_acc_no=destination_acc_no,t_rec_ifsc_code=ifsc_code1,t_start_date=datetime.datetime.now(),t_end_date=datetime.datetime.now(),t_status=1,t_transaction_type=1)
tran.save()
return render_to_response("transaction_status.html",{'STATIC_URL':"/static/"})
def test_list_pf(self):
pf = Portfolio.objects.create(name='Test')
sec = Security()
price = Price()
mysec1 = sec.add('Test', ['SomeAliasString'], '', 'APC.DE', 'Stock')
mysec2 = sec.add('Test2', ['SomeAliasString'], '', 'APC.DE', 'Stock')
time_price_1 = timezone.now() - datetime.timedelta(days=20)
time_price_2 = timezone.now() - datetime.timedelta(days=5)
time_price_3 = timezone.now() - datetime.timedelta(days=2)
time_price_4 = timezone.now() - datetime.timedelta(days=1)
price.add(mysec1, time_price_1, 100)
price.add(mysec1, time_price_2, 15)
price.add(mysec1, time_price_3, 15)
price.add(mysec1, time_price_4, 10)
price.add(mysec2, time_price_1, 40)
price.add(mysec2, time_price_2, 50)
price.add(mysec2, time_price_3, 60)
price.add(mysec2, time_price_4, 70)
t = Transaction()
# def add(self, transaction_type, portfolio, stock_id, date, nominal, price, cost):
t.add('b', pf, mysec1, time_price_1, 10, 100, 0)
t.add('b', pf, mysec1, time_price_2, 10, 50, 0)
t.add('s', pf, mysec1, time_price_3, 10, 15, 0)
t.add('b', pf, mysec2, time_price_1, 10, 40, 0)
result = t.list_pf(pf.name, time_price_1, time_price_4)
# print()
# for item in result:
# print(item['name'], item['profit'])
# print()
self.assertEqual(result[0]['profit'], Decimal('-1250'))
self.assertEqual(result[1]['profit'], Decimal('300'))
self.assertEqual(result[2]['profit'], Decimal('-950'))
def show_funds_transfer(request):
"""
it does sms validation and then show all the accounts of the user and gives the option
to transfer from one account to his another account.
It also performs various checks like whether the amount entered is within limits etc.
"""
verification=request.session.get('verification')
t_type1=request.session.get('t_type')
if ((verification==1) and (t_type1=="funds_transfer.html")):
try:
id=request.session.get('user_id')
user_accounts = Bank_Account.objects.filter(ba_user_id=id)
source_acc=request.POST["account1"]
destination_acc=request.POST["account2"]
amount1=request.POST["amount_to_transfer"]
amount=unicodedata.normalize('NFKD', amount1).encode('ascii','ignore')
account1=Bank_Account.objects.filter(ba_acc_no=source_acc)
account2=Bank_Account.objects.filter(ba_acc_no=destination_acc) # RECHECK AGAIN the condition
error1="Not enough money in your account"
error2="Please enter valid amount"
error3="Please enter amount in numeric only"
error4="Please choose different source and destination accounts"
error5="You entered amount more than your accounts transaction limit"
if (source_acc==destination_acc):
return render_to_response("funds_transfer.html",{'user_accounts':user_accounts,'error':error4,'STATIC_URL':"/static/"})
try:
i = float(amount)
except ValueError, TypeError:
return render_to_response("funds_transfer.html",{'user_accounts':user_accounts,'error':error3,'STATIC_URL':"/static/"})
else:
if (i<=0 ):
return render_to_response("funds_transfer.html",{'user_accounts':user_accounts,'error':error2,'STATIC_URL':"/static/"})
for acc in account1:
if ((acc.ba_acc_bal)<Decimal(amount)):
return render_to_response("funds_transfer.html",{'user_accounts':user_accounts,'error':error1,'STATIC_URL':"/static/"})
elif(acc.ba_transaction_limit<Decimal(amount)):
return render_to_response("funds_transfer.html",{'user_accounts':user_accounts,'error':error5,'STATIC_URL':"/static/"})
else:
acc.ba_acc_bal=acc.ba_acc_bal-Decimal(amount)
#print acc.ba_acc_bal
acc.save()
for acc in account2:
ifsc_code1=acc.ba_ifsc_code
acc.ba_acc_bal=acc.ba_acc_bal+Decimal(amount)
acc.save();
#print acc.ba_acc_bal
tran=Transaction(t_amount=amount,t_sender_acc_no=source_acc,t_receiver_acc_no=destination_acc,t_rec_ifsc_code=ifsc_code1,t_start_date=datetime.datetime.now(),t_end_date=datetime.datetime.now(),t_status=1,t_transaction_type=0)
tran.save()
return render_to_response("transaction_status.html",{'STATIC_URL':"/static/"})
def setUp(self):
self.federico=User.objects.create_user(username="******")
self.nicola=User.objects.create_user(username="******")
self.marco=User.objects.create_user(username="******")
self.gabriele=User.objects.create_user(username="******")
self.t1 = Transaction(description="pizza1", value=12.5, date=datetime.date.today(),
user_one=self.federico, user_two=self.nicola)
self.t2 = Transaction(description="pizza2", value=12.5, date=datetime.date.today(),
user_one=self.nicola, user_two=self.federico)
self.t3 = Transaction(description="pizza3", value=10.3, date=datetime.date.today(),
user_one=self.marco, user_two=self.nicola)
self.t1.save()
self.t2.save()
self.t3.save()
def addTransaction(request, group_id):
post = request.POST
friend_name = post['borrower']
description = post['description']
group = Group.objects.get(id=group_id)
payer = Member.objects.get(user=User.objects.get(id=request.user.id))
amount = '%.2f' % (float(post['amount']))
date = datetime.datetime.now()
if not (friend_present(friend_name)):
nonregfriend= Non_Registered_Member(name=friend_name, connection=payer, amount=0)
nonregfriend.save()
nonregfriend=Non_Registered_Member.objects.get(name=friend_name, connection=payer)
nonregfriend.amount=float(nonregfriend.amount)- float(amount)
nonregfriend.save()
transaction = Transaction(name= nonregfriend.name, description=description, group=group,
payer=payer,amount=amount, date=date)
transaction.save()
return detail(request, group_id)
def a_test_portfolio_overview(self):
sec = Security.objects.create(name='TestSec', aliases='Test Alias', isin_id='DETest', yahoo_id='ABC',
type='Stock')
pf = Portfolio.objects.create(name='Test')
t = Transaction()
time = timezone.now().date()
p = Price()
p.add(sec, time, Decimal(111))
t.add('b', pf, sec, time, 100, 100, 100)
p = t.list_pf(pf.name, time)
self.assertEqual(p, [{
'nominal': Decimal('100'),
'invest': Decimal('-10100'),
'profit': Decimal('1000'),
'name': 'TestSec',
'value': Decimal('11100'),
'price': Decimal('111'),
'cost': Decimal('100')},
{
'name': 'Total',
'value': Decimal('11100')}])
def calc_average(self, from_date=None, to_date=None):
my_set = self.return_complete_sets()
# import pdb; pdb.set_trace()
incomes = []
expenses = []
last_date = None
t = Transaction()
for date, value in sorted(my_set.items()):
if last_date:
invest = t.get_total_invest('All', last_date, date)
divest = t.get_total_divest('All', last_date, date)
dividend = t.get_total_dividend('All', last_date, date)
else:
invest, divest, dividend = 0, 0, 0
last_date = date
# print(10*'---')
# print(date)
# print('Divest', divest)
# print('Invest', invest)
# print('Dividend', dividend)
# print(value['income'])
# print(value['expense'])
# print(value['expense']+ divest + invest + dividend)
incomes.append(value['income'])
expenses.append(value['expense'] + divest + invest + dividend)
incomes = list(incomes)
expenses = list(expenses)
if incomes != []:
median_income = statistics.mean(incomes)
else:
median_income = 0
if expenses != []:
median_expense = statistics.mean(expenses)
else:
median_expense = 0
return median_income, median_expense
def test_rejected_expired(self):
main_account = Account.get_main_account()
with patch('algorand.utils.transaction_info') as mock_transaction_info:
mock_transaction_info.return_value = {
'pool-error': '',
'txn': {
'txn': {
'lv': utils.status()['last-round'] - 1000
}
}
}
tx = Transaction.transfer(main_account, self.user_account, 0.1,
Transaction.ALGO, Transaction.OPT_IN)
self.assertTrue(utils.wait_for_confirmation(tx.txid))
verify_transactions()
tx.refresh_from_db()
self.assertEqual(tx.status, Transaction.REJECTED)
self.assertEqual(Transaction.objects.count(), 2)
def save_transaction(self, serializer):
t = Transaction()
t.origin = serializer.validated_data["origin"]
t.destination = serializer.validated_data["destination"]
t.ammount = serializer.validated_data["ammount"]
t.coin_type = serializer.validated_data["coin_type"]
if t.origin.balance - t.ammount < 0:
raise Exception("El origen no tenia fondos")
t.origin.balance = t.origin.balance - t.ammount
t.destination.balance = t.destination.balance + t.ammount
t.origin.save()
t.destination.save()
serializer.save()
def create(self, request, project_pk=None, task_pk=None):
with transaction.atomic():
project = get_object_or_404(
Project.objects.with_beneficiary_assignment_status(
request.user),
assignment_status=Assignment.ACCEPTED,
pk=project_pk)
task = get_object_or_404(Task, project=project, pk=task_pk)
# Check if smartcontract got sufficient balance to pay reward:
if not project.smartcontract.check_if_sufficient_balance(
task.reward):
return Response({"reward": "Insufficient balance."},
status=status.HTTP_400_BAD_REQUEST)
serializer = self.serializer_class(data=request.data)
serializer.is_valid(raise_exception=True)
activity = serializer.save(user=request.user,
project=project,
task=task)
# Check balance before transfer to determine if after reward investment should be closed:
balance_check = project.smartcontract.check_if_sufficient_balance(
extra=task.reward)
transfer = Transaction.transfer(project.smartcontract.account,
request.user.account,
task.reward,
Transaction.USDC,
Transaction.REWARD,
project=project)
activity.transaction = transfer
activity.save()
if not balance_check:
project.investment.finish()
serializer = self.serializer_class(activity)
return Response(serializer.data, status=status.HTTP_201_CREATED)
def refill(cls, date, account, envelopes, amount, immutable=None):
if len(envelopes) < 1:
raise ValueError('No envelopes to be filled.')
ratio = 1.0
total = 0.0
for envelope in envelopes:
total += float(envelope.monthly_budget)
if total > amount:
if immutable:
raise ValueError(
'Not enough funds to refill the given envelopes.')
else:
ratio = amount / total
transactions = 0
for envelope in envelopes:
transaction_amount = round(
float(envelope.monthly_budget) * ratio, 2)
if transaction_amount > 0.0:
amount -= transaction_amount
transaction = Transaction(account=account,
envelope=envelope,
date=date,
amount=transaction_amount)
transaction.save()
transactions += 1
if amount > 0.0:
transaction = Transaction(account=account,
date=date,
amount=round(amount, 2))
transaction.save()
transactions += 1
return transactions
class ExpensesTestCase(TestCase):
def setUp(self):
self.federico=User.objects.create_user(username="******")
self.nicola=User.objects.create_user(username="******")
self.marco=User.objects.create_user(username="******")
self.gabriele=User.objects.create_user(username="******")
self.t1 = Transaction(description="pizza1", value=12.5, date=datetime.date.today(),
user_one=self.federico, user_two=self.nicola)
self.t2 = Transaction(description="pizza2", value=12.5, date=datetime.date.today(),
user_one=self.nicola, user_two=self.federico)
self.t3 = Transaction(description="pizza3", value=10.3, date=datetime.date.today(),
user_one=self.marco, user_two=self.nicola)
self.t1.save()
self.t2.save()
self.t3.save()
def test_user_order(self):
self.assertEqual(self.t1.user_one, self.t2.user_one)
self.assertEqual(self.t1.user_two, self.t2.user_two)
self.assertTrue(self.t1.value == self.t2.value * -1, "Transaction 2 exchanged users but did not invert value")
def test_same_user(self):
t = Transaction(description="pizza",value=12.5,date=datetime.date.today(),
user_one=self.federico,user_two=self.federico)
self.assertRaises(ValidationError, lambda: t.save())
def test_transactions_lists(self):
transactions_of_federico = Transaction.objects.transactions_of_user(self.federico)
self.assertEquals(transactions_of_federico.count(), 2)
def test_transactions_from_user_to_user(self):
transactions = Transaction.objects.transactions_of_user_to_user(self.federico, self.nicola)
self.assertEquals(transactions.count(), 2)
marco_transactions = Transaction.objects.transactions_of_user_to_user(self.nicola, self.marco)
self.assertEquals(marco_transactions.count(), 1)
def test_insert_transactions(self):
Transaction.objects.insert_transactions("patatine", 5, datetime.date.today(),
self.gabriele, [self.nicola, self.marco])
transactions = Transaction.objects.transactions_of_user(self.gabriele)
self.assertEquals(transactions.count(), 2)
def create(self, validated_data):
comment = validated_data.get('comment')
amount = validated_data['payment_amount']
currency = validated_data['payment_currency']
sender = validated_data['payment_sender']
quota = Transaction.user_quota_remains_today(sender)
reserve = Reserve.user_reserve_remains(sender)
if amount > (quota + reserve):
raise ValidationError(
'Hour amount larger than sum of user daily_quota and user_reserve.'
)
tx = comment.invest(
hour_amount=amount,
payment_currency_label=currency.label.lower(),
investor=sender,
)
if not tx:
raise ValidationError('Bad data')
return tx
def addTransaction(request, member_id, loaning):
post = request.POST
name = post['borrower']
description = post['description']
payer = Member.objects.get(user=User.objects.get(id=request.user.id))
amount = '%.2f' % (float(post['amount']))
date = datetime.datetime.now()
if (group_present(name)):
group=Group.objects.filter(name=name)[0]
addGroupTransaction(group, loaning, amount)
transaction = Transaction(description=description, amount=amount, group=group, date=date)
transaction.save()
return index(request)
if not (friend_present(name)):
nonregfriend= Non_Registered_Member(name=name, connection=payer, amount=0)
nonregfriend.save()
friend=Non_Registered_Member.objects.get(name=name, connection=payer)
calculateFriendBalance(friend, loaning, amount)
transaction = Transaction(description=description,
amount=amount, friend=friend, date=date)
transaction.save()
return index(request)
def rest_add_bonus(request, card_code):
response = {}
if request.method == 'PUT':
user = UserCustom.objects.get(user_id__exact=request.user.pk)
bonus_data = json.loads(request.body.decode())
if not user.administrator:
response['status'] = 'error'
response['message'] = "Недостаточно прав!"
return JsonResponse(response, status=503)
try:
card = Card.objects.get(org_id__exact=user.org.pk,
code__exact=card_code)
except:
response['status'] = 'error'
response['message'] = "Карта с таким кодом не найдена!"
return JsonResponse(response, status=400)
try:
bonus = Bonus()
bonus.card = card
try:
bonus.active_from = datetime.fromtimestamp(
bonus_data['active_from'] / 1000)
except Exception as exc:
bonus.active_from = bonus_data['active_from']
try:
bonus.active_to = datetime.fromtimestamp(
bonus_data['active_to'] / 1000)
except:
bonus.active_to = bonus_data['active_to']
bonus.value = float(bonus_data['value'])
bonus.enabled = True
bonus.save()
trans = Transaction()
trans.card = card
trans.type = 'bonus_add'
trans.date = datetime.now()
trans.org = user.org
trans.bonus_add = bonus.value
trans.workplace = 'ВТИ-ДИСКОНТ'
trans.doc_close_user = user.user.first_name + " " + user.user.last_name
trans.save()
except Exception as err:
response['status'] = 'error'
response['message'] = str(err)
return JsonResponse(response, status=400)
response['status'] = 'success'
response['message'] = 'Бонусы добавлены'
return JsonResponse(response, safe=False)
if request.method == 'DELETE':
user = UserCustom.objects.get(user_id__exact=request.user.pk)
bonus_data = json.loads(request.body.decode())
try:
card = Card.objects.get(org_id__exact=user.org.pk,
code__exact=card_code)
except:
response['status'] = 'error'
response['message'] = "Карта с таким кодом не найдена!"
return JsonResponse(response, status=400)
try:
bonus = Bonus.objects.get(id__exact=int(bonus_data['id']))
bonus.delete()
trans = Transaction()
trans.card = card
trans.type = 'bonus_refund'
trans.date = datetime.now()
trans.org = user.org
trans.bonus_add = bonus.value
trans.workplace = 'ВТИ-ДИСКОНТ'
trans.doc_close_user = user.user.first_name + " " + user.user.last_name
trans.save()
except Exception as err:
response['status'] = 'error'
response['message'] = str(err)
return JsonResponse(response, status=400)
response['status'] = 'success'
response['message'] = 'Бонусы удалены'
return JsonResponse(response, safe=False)
def startashipment(
request,
host_id=None,
transaction_form_submitted=False,
invoice=None,
cal_form_submitted=False,
packagedays_count=None,
):
random3digits = random.randint(100, 999)
#set timezone
local_timezone = request.session.setdefault('django_timezone', 'UTC')
local_timezone = pytz.timezone(local_timezone)
enduser = request.user
calendar_submit_button_text = "Select Dates and Proceed to Payment"
if host_id:
host = get_object_or_404(UserInfo, pk=host_id)
else:
host = None
#Determine if payment is needed or balance will suffice
balance = enduser.account_balance_packages
if balance > 0:
payment_needed = False
amount_due = 0.00
remaining_balance = balance - 1
else:
if enduser.betauser_free:
payment_needed = False
else:
payment_needed = True
amount_due = None #this is processed on the payment page if they aren't applying account balance
remaining_balance = None
connections_all = Connection.objects.filter(end_user=enduser)
#Empty variables for availability/ conflict stuff
days_package_may_come_thismonth = []
days_package_may_come_nextmonth = []
month1days_count = None
month2days_count = None
conflicts_date_from = []
conflicts_startmonths = []
conflicts_startthismonth = []
conflicts_startnextmonth = []
conflicts_startandend_thismonth = []
conflicts_startandend_nextmonth = []
conflicts_startthismonth_endnextmonth = []
conflicts_startthismonth_endlater = []
conflicts_startnextmonth_endlater = []
days_withconflicts_thismonth = []
days_withconflicts_nextmonth = []
days_withconflicts_later = []
#if host/no host - get caklendar_homebrew created fields
if host:
transcount = Transaction.objects.filter(host=host).count(
) + 1 #counts transactions that this receiver_email has received (could change to host email)
#invoice = "H" + str(host.id) + "U" + str(enduser.id) + "N" +str(transcount) +"D" + str(date_today.month) + str(date_today.day) + str(time.hour) + "R" + str(random3digits) #h2u14N13D112210R123 = transaciton between host2, user14, host's 13th transaction
#JMY updating invoice algorithm - removing date to make it smaller
invoice = "H" + str(
host.id
) + "U" + str(enduser.id) + "N" + str(transcount) + "R" + str(
random3digits
) #h2u14N13D112210R123 = transaciton between host2, user14, host's 13th transaction
conflicts = HostConflicts_DateVersion.objects.filter(host=host)
for conflict in conflicts:
if conflict.month == thismonth_num:
days_withconflicts_thismonth.append(conflict.day)
if conflict.month == nextmonth_num:
days_withconflicts_nextmonth.append(conflict.day)
#i think i do this to remove duplicates
days_withconflicts_thismonth = list(set(days_withconflicts_thismonth))
days_withconflicts_nextmonth = list(set(days_withconflicts_nextmonth))
#determine if there is a conflict
host_package_conflict = False
for day in days_package_may_come_thismonth:
if day in days_withconflicts_thismonth:
host_package_conflict = True
for day in days_package_may_come_nextmonth:
if day in days_withconflicts_nextmonth:
host_package_conflict = True
else: #if no host specified that stuff is empty/none
conflicts = None
host_package_conflict = False
#do payment variables/ transaction form stuff once they've checked the calendar day
favortype = 'package'
#transaction_form_submitted = False
#packagedays_count = None
if cal_form_submitted:
cal_form = CalendarCheckBoxes()
packagedays = None
packagedays_string = None
trans_form_package = None
trans = Transaction()
#request.method = 'GET'
if request.method == 'POST':
trans_form_package = CreatePackageTransaction(request.POST)
if trans_form_package.is_valid():
title = trans_form_package.cleaned_data['title']
payment_option = trans_form_package.cleaned_data[
'payment_option']
note_to_host = trans_form_package.cleaned_data['note_to_host']
paypal_quantity = 1
if payment_option == "bundle10":
price = host.price_package_bundle10
youselected = "Bundle of 10 Packages"
balance_created = 9 #10 minus the 1 they just bought
elif payment_option == "bundle20":
price = host.price_package_bundle20
youselected = "Bundle of 20 Packages"
balance_created = 19 #20 minus the 1 they just bought
elif payment_option == "annual":
price = host.price_package_annual
youselected = "Annual"
balance_created = 1000 #Notional - this option is not in place currently
else:
price = host.price_package_per
youselected = "Per Package"
balance_created = None
#Next, add the data to the transaction table
trans.balance_created_packages = balance_created
trans.payment_option = payment_option
trans.title = title
trans.favortype = favortype
trans.note_to_host = note_to_host
trans.price = price
trans.youselected = youselected
trans.paypal_quantity = paypal_quantity
trans.host = host
trans.enduser = enduser
trans.invoice = invoice
#Account balance/ create amount_due
if enduser.account_balance_packages:
if enduser.account_balance_packages > 0:
trans.amount_due = 0
trans.payment_needed = False
else:
trans.amount_due = price
trans.payment_needed = True
else:
trans.amount_due = price
trans.payment_needed = True
arrivalwindow_days_count = trans_form_package.cleaned_data[
'packagedays_count']
trans.arrivalwindow_days_count = arrivalwindow_days_count
day1 = trans_form_package.cleaned_data['arrivalwindow_day1']
day1string = trans_form_package.cleaned_data[
'arrivalwindow_day1string']
if day1:
trans.arrivalwindow_day1 = day1
day2 = trans_form_package.cleaned_data['arrivalwindow_day2']
day2string = trans_form_package.cleaned_data[
'arrivalwindow_day2string']
if day2:
trans.arrivalwindow_day2 = day2
day3 = trans_form_package.cleaned_data['arrivalwindow_day3']
day3string = trans_form_package.cleaned_data[
'arrivalwindow_day3string']
if day3:
trans.arrivalwindow_day3 = day3
day4 = trans_form_package.cleaned_data['arrivalwindow_day4']
day4string = trans_form_package.cleaned_data[
'arrivalwindow_day4string']
if day4:
trans.arrivalwindow_day4 = day4
day5 = trans_form_package.cleaned_data['arrivalwindow_day5']
day5string = trans_form_package.cleaned_data[
'arrivalwindow_day5string']
if day5:
trans.arrivalwindow_day5 = day5
day6 = trans_form_package.cleaned_data['arrivalwindow_day6']
day6string = trans_form_package.cleaned_data[
'arrivalwindow_day6string']
if day6:
trans.arrivalwindow_day6 = day6
day7 = trans_form_package.cleaned_data['arrivalwindow_day7']
day7string = trans_form_package.cleaned_data[
'arrivalwindow_day7string']
if day7:
trans.arrivalwindow_day7 = day7
if arrivalwindow_days_count == 1:
trans.arrivalwindow_string = str(day1string)
trans.arrivalwindow_lastday = day1
if arrivalwindow_days_count == 2:
trans.arrivalwindow_string = str(
day1string) + " or " + str(day2string)
trans.arrivalwindow_lastday = day2
if arrivalwindow_days_count == 3:
trans.arrivalwindow_string = str(day1string) + ", " + str(
day2string) + ", or " + str(day3string)
trans.arrivalwindow_lastday = day3
if arrivalwindow_days_count == 4:
trans.arrivalwindow_string = str(day1string) + ", " + str(
day2string) + ", " + str(day3string) + ", or " + str(
day4string)
trans.arrivalwindow_lastday = day4
if arrivalwindow_days_count == 5:
trans.arrivalwindow_string = str(day1string) + ", " + str(
day2string) + ", " + str(day3string) + ", " + str(
day4string) + ", or " + str(day5string)
trans.arrivalwindow_lastday = day5
if arrivalwindow_days_count == 6:
trans.arrivalwindow_string = str(day1string) + ", " + str(
day2string) + ", " + str(day3string) + ", " + str(
day4string) + ", " + str(
day5string) + ", or " + str(day6string)
trans.arrivalwindow_lastday = day6
if arrivalwindow_days_count == 7:
trans.arrivalwindow_lastday = day7
trans.arrivalwindow_string = str(day1string) + ", " + str(
day2string) + ", " + str(day3string) + ", " + str(
day4string) + ", " + str(day5string) + ", " + str(
day6string) + ", or " + str(day7string)
trans.save()
transaction_form_submitted = True
else:
print trans_form_package.errors
transaction_form_submitted = False
errors_on_trans_form = 'There are errors on the transaction form'
else:
trans_form_package = CreatePackageTransaction()
transaction_form_submitted = False
errors_on_trans_form = 'Method is not POST'
#if cal_form_submitted is false
else:
transaction_form_submitted = False
errors_on_trans_form = 'Cal_form was not submitted'
trans_form_package = None
transaction_form_submitted = False
packagedays = []
packagedays_string = []
#do the cal_form submission stuff
if request.method == 'POST':
cal_form = CalendarCheckBoxes(data=request.POST)
if cal_form.is_valid():
for daynumber in range(
1,
32): #starts at zero otherwise so this will stop at 31
daycheckedmonth1 = cal_form.cleaned_data['month1day' +
str(daynumber)]
if daycheckedmonth1:
#checked day needs to be in YYYY-MM-DD format
checked_day = str(thisyear) + "-" + str(
thismonth_num) + "-" + str(daynumber)
checked_day_string = str(thismonth) + " " + str(
daynumber)
packagedays.append(checked_day)
packagedays_string.append(checked_day_string)
days_package_may_come_thismonth.append(daynumber)
for daynumber in range(1, 32):
daycheckedmonth2 = cal_form.cleaned_data['month2day' +
str(daynumber)]
if daycheckedmonth2:
checked_day = str(nextmonth_calendar_year) + "-" + str(
nextmonth_num) + "-" + str(daynumber)
checked_day_string = str(nextmonth) + " " + str(
daynumber)
packagedays.append(checked_day)
packagedays_string.append(checked_day_string)
days_package_may_come_nextmonth.append(daynumber)
month1days_count = len(days_package_may_come_thismonth)
month2days_count = len(days_package_may_come_nextmonth)
cal_form_submitted = True
else:
print cal_form.errors
else:
cal_form = CalendarCheckBoxes()
packagedays_count = len(packagedays)
#if the transaction form has been submitted redirect to new page
if transaction_form_submitted == True:
cal_form = None
if payment_needed:
return HttpResponseRedirect("/transactions/payment/host" +
str(host.id) + "/invoice" +
str(invoice) + "/favortype" +
str(favortype) + "/")
else:
return HttpResponseRedirect("/transactions/shippackage/host" +
str(host.id) +
"/account_balance/invoice" +
str(invoice) + "/")
#if the transaction form has not been submitted
else:
return render(
request,
'blocbox/startashipment.html',
{
'enduser': enduser,
'host': host,
'connections_all': connections_all,
#'cal_relations_host_count': cal_relations_host_count, 'cal_relations_host': cal_relations_host, 'cal_list_host': cal_list_host,
'here': quote(request.get_full_path()),
#Python calendar variables (independent of conflict app)
'local_timezone': local_timezone,
'date_today': date_today,
'datetime_now': datetime_now,
'thisyear': thisyear,
'nextyear': nextyear,
'thisyeaer_isleap': thisyear_isleap,
'nextyear_isleap': nextyear_isleap,
'thismonth': thismonth,
'nextmonth': nextmonth,
'thismonth_calendar': thismonth_calendar,
'nextmonth_calendar': nextmonth_calendar,
'monthrange_thismonth': monthrange_thismonth,
'monthrange_nextmonth': monthrange_nextmonth,
'days_in_thismonth': days_in_thismonth,
'days_in_nextmonth': days_in_nextmonth,
'today_dayofmonth_num': today_dayofmonth_num,
'nextmonth_calendar_year': nextmonth_calendar_year,
#conflict app variables (if host)
'conflicts': conflicts,
'conflicts_startthismonth': conflicts_startthismonth,
'conflicts_startnextmonth': conflicts_startnextmonth,
'conflicts_startandend_thismonth':
conflicts_startandend_thismonth,
'conflicts_startandend_nextmonth':
conflicts_startandend_nextmonth,
'days_withconflicts_thismonth': days_withconflicts_thismonth,
'days_withconflicts_nextmonth': days_withconflicts_nextmonth,
#days package may come
'days_package_may_come_thismonth':
days_package_may_come_thismonth,
'days_package_may_come_nextmonth':
days_package_may_come_nextmonth,
'host_package_conflict': host_package_conflict,
#Calendar check boxes form
'cal_form': cal_form,
'packagedays': packagedays,
'packagedays_string': packagedays_string,
'packagedays_count': packagedays_count,
'cal_form_submitted': cal_form_submitted,
'calendar_submit_button_text': calendar_submit_button_text,
#payment stuff once the calendar checkboxes are checked
'trans_form_package': trans_form_package,
'invoice': invoice,
'favortype': favortype,
'errors_on_trans_form': errors_on_trans_form,
'transaction_form_submitted': transaction_form_submitted,
'random3digits': random3digits,
'payment_needed': payment_needed,
'amount_due': amount_due,
'remaining_balance': remaining_balance,
'request': request,
})
line.replace(why_prefix, ''))
elif line.startswith(when_prefix):
save_question_response(sr, when_question,
line.replace(when_prefix, ''))
elif line.startswith(improve_prefix):
save_question_response(sr, improve_question,
line.replace(improve_prefix, ''))
elif line.startswith(skills_prefix):
save_question_response(sr, skills_question,
line.replace(skills_prefix, ''))
save_question_response(sr, t_and_c_question, 'Y')
save_question_response(sr, bene_question, 'Y')
if len(row[1]) > 0:
t = Transaction()
t.user = user
t.date = est.localize(dateparser.parse(row[1]))
t.item = common_item
t.qty = 1
t.amount = 3000 if user.email.split(
'@')[1] == "3cross.coop" else 150
t.save()
members_group.user_set.add(user)
else:
pending_group.user_set.add(user)
preferred_shares = 0
if len(row[21]) > 0:
preferred_shares = int(row[21])
def form_valid(self, form):
ok = True
the_student = Student.objects.get(student=self.request.user)
the_tutor = Tutor.objects.get(pk=self.kwargs['tutor_id'])
notAvailable = NotAvailableSlot.objects.filter(tutor=the_tutor)
st = form.instance.start_time
et = st + datetime.timedelta(minutes=the_tutor.timePerSlot)
for slot in notAvailable:
if (slot.start_time <= st) and (slot.end_time >= et):
ok = False
messages.error(self.request,
'Crashed with Tutor Unavailable Slots.')
if ok:
mylist = Session.objects.filter(student=the_student)
for booking in mylist:
if (booking.start_time.date() == st.date()) and (booking.tutor
== the_tutor):
ok = False
messages.error(
self.request,
'Cannot book more than one slot of same tutor in a day.'
)
if (st - timezone.now() <= datetime.timedelta(hours=24)):
ok = False
messages.error(self.request,
'Cannot book session within coming 24 hours.')
if (st - timezone.now() > datetime.timedelta(days=7)):
ok = False
messages.error(self.request,
'Cannot book further than 7 days.')
if (Wallet.objects.get(owner=the_student.student).balance <
(the_tutor.hourlyRate) * 1.05):
ok = False
messages.error(self.request, 'You do not have enough money.')
if (st.time() < datetime.time(hour=9)) or (et.time() >
datetime.time(hour=22)):
ok = False
messages.error(
self.request,
'Exceeded allowable time range. 9am-10pm only.')
if ok:
form.instance.student = the_student
form.instance.tutor = the_tutor
form.instance.end_time = et
w = Wallet.objects.get(owner=the_student.student)
new_unavail = NotAvailableSlot(tutor=the_tutor,
start_time=st,
end_time=et)
w.balance = w.balance - Decimal((the_tutor.hourlyRate) * 1.05)
new_trans = Transaction(owner=self.request.user,
amount=(-(the_tutor.hourlyRate) * 1.05),
timestamp=timezone.now())
body = 'Dear ' + the_tutor.tutor.get_full_name(
) + ',\n' + 'A session is booked by ' + the_student.student.get_full_name(
) + ' from ' + str(st) + ' to ' + str(
et) + '. Go to Tutoria Homepage to check it out.\nTutoria'
mail.send_mail('A session is booked', body, '*****@*****.**',
[the_tutor.tutor.email])
body = 'Dear ' + the_student.student.get_full_name(
) + ',\n' + 'A session taught by ' + the_tutor.tutor.get_full_name(
) + ' from ' + str(st) + ' to ' + str(
et) + ' is booked. Your wallet value now is: $' + str(
w.balance
) + '. Go to Tutoria Homepage to check it out.\nTutoria'
mail.send_mail('A session is cancelled', body, '*****@*****.**',
[the_student.student.email])
new_trans.save()
new_unavail.save()
the_student.save()
w.save()
return super(MakeBooking, self).form_valid(form)
else:
return super(MakeBooking, self).form_invalid(form)
def test_user_can_change_reserve(self):
# Initially, quota should be as defined in settings.
self.assertEqual(Transaction.user_quota_remains_today(self.investor),
4.)
# Initially, reserve should be zero:
self.assertEqual(Reserve.user_reserve_remains(self.investor), 0.)
# After payment, reserve should be more than zero:
payment = Payment.objects.create(request={
"amount": "150",
"currency": "usd",
},
platform=0,
provider=0,
owner=self.investor)
self.assertEqual(Reserve.user_reserve_remains(self.investor),
Decimal('5.71428571'))
self.assertEqual(Transaction.user_quota_remains_today(self.investor),
4.)
# Investment should use up the hours, first from quota,
tx = self.comment.invest(1., 'eur', self.investor)
self.assertEqual(Transaction.user_quota_remains_today(self.investor),
3.)
self.assertEqual(Reserve.user_reserve_remains(self.investor),
Decimal('5.71428571'))
# Try more
tx = self.comment.invest(3., 'eur', self.investor)
self.assertEqual(Transaction.user_quota_remains_today(self.investor),
0.)
self.assertEqual(Reserve.user_reserve_remains(self.investor),
Decimal('5.71428571'))
# Try more
tx = self.comment.invest(1., 'eur', self.investor)
self.assertEqual(Transaction.user_quota_remains_today(self.investor),
0.)
self.assertEqual(Reserve.user_reserve_remains(self.investor),
Decimal('4.71428571'))
credit = Transaction.user_quota_remains_today(self.investor) + \
Reserve.user_reserve_remains(self.investor)
self.assertEqual(credit, Decimal('4.71428571'))
# Remaining credit should be such:
self.assertEqual(
credit,
(Decimal(4.) + Decimal('5.71428571')) - \
(Decimal(1.) + Decimal(3.) + Decimal(1.))
)
# Comment should still have remaining 10. hrs
self.assertEqual(
self.comment.remains(),
Decimal(14.5)+Decimal(0.5) - \
(Decimal(1.) + Decimal(3.) + Decimal(1.))
)
# If we try invest more than available, we should fail:
# Try more
tx = self.comment.invest(4.9, 'eur', self.investor)
# Not created:
self.assertEqual(tx, None)
# But we should be able to invest exactly the remainder:
tx = self.comment.invest(Decimal('4.71428571'), 'eur', self.investor)
self.assertEqual(self.comment.remains(), Decimal('5.28571428'))
credit = Transaction.user_quota_remains_today(self.investor) + \
Reserve.user_reserve_remains(self.investor)
self.assertEqual(credit, 0.)
def test_same_user(self):
t = Transaction(description="pizza",value=12.5,date=datetime.date.today(),
user_one=self.federico,user_two=self.federico)
self.assertRaises(ValidationError, lambda: t.save())
return render_to_response("funds_transfer.html",{'user_accounts':user_accounts,'error':error2,'STATIC_URL':"/static/"})
for acc in account1:
if ((acc.ba_acc_bal)<Decimal(amount)):
return render_to_response("funds_transfer.html",{'user_accounts':user_accounts,'error':error1,'STATIC_URL':"/static/"})
elif(acc.ba_transaction_limit<Decimal(amount)):
return render_to_response("funds_transfer.html",{'user_accounts':user_accounts,'error':error5,'STATIC_URL':"/static/"})
else:
acc.ba_acc_bal=acc.ba_acc_bal-Decimal(amount)
#print acc.ba_acc_bal
acc.save()
for acc in account2:
ifsc_code1=acc.ba_ifsc_code
acc.ba_acc_bal=acc.ba_acc_bal+Decimal(amount)
acc.save();
#print acc.ba_acc_bal
tran=Transaction(t_amount=amount,t_sender_acc_no=source_acc,t_receiver_acc_no=destination_acc,t_rec_ifsc_code=ifsc_code1,t_start_date=datetime.datetime.now(),t_end_date=datetime.datetime.now(),t_status=1,t_transaction_type=0)
tran.save()
return render_to_response("transaction_status.html",{'STATIC_URL':"/static/"})
except (KeyError):
error3="Please select one source and destination account"
#print "this was a key error"
id=request.session.get('user_id')
user_accounts = Bank_Account.objects.filter(ba_user_id=id)
return render_to_response("funds_transfer.html",{'user_accounts':user_accounts,'error':error3,'STATIC_URL':"/static/"})
def transaction_status(request):
"""
it redirects to the status of transaction done by user
"""
return render_to_response("transaction_status.html",{'STATIC_URL':"/static/"})
def get(self, request, *args, **kwargs):
block_hash = kwargs['hash']
block_info = w3_client.eth.getBlock(block_hash)
block_data = web3_to_dict(block_info)
miner = self.get_address(block_data['miner'])
existing_block = Block.objects.filter(hash=block_data['hash'])
if existing_block.exists():
block = existing_block.first()
block.difficulty = block_data['difficulty']
block.gas_limit = block_data['gasLimit']
block.gas_used = block_data['gasUsed']
block.hash = block_data['hash']
block.miner = miner
block.nonce = block_data['nonce']
block.number = block_data['number']
block.parent_hash = Block.objects.filter(
hash=block_data['parentHash']).first()
block.size = block_data['size']
block.timestamp = block_data['timestamp']
block.total_difficulty = block_data['totalDifficulty']
block.save()
else:
# Create Block Instance
block = Block()
block.difficulty = block_data['difficulty']
block.gas_limit = block_data['gasLimit']
block.gas_used = block_data['gasUsed']
block.hash = block_data['hash']
block.miner = miner
block.nonce = block_data['nonce']
block.number = block_data['number']
block.parent_hash = Block.objects.filter(
hash=block_data['parentHash']).first()
block.size = block_data['size']
block.timestamp = block_data['timestamp']
block.total_difficulty = block_data['totalDifficulty']
block.save()
# Create transactions for block
for transaction in block_data['transactions']:
transaction_info = w3_client.eth.getTransaction(transaction)
transaction_data = web3_to_dict(transaction_info)
existing_transaction = Transaction.objects.filter(
hash=transaction_data['hash'])
if existing_transaction.exists():
transaction = existing_transaction.first()
transaction.block_hash = block
transaction.block_number = block.number
# transaction.cumulative_gas_used = ''
transaction.created_contract_address_hash = None
transaction.error = ''
transaction.from_address_hash = self.get_address(
transaction_data['from'])
transaction.gas = transaction_data['gas']
transaction.gas_price = transaction_data['gasPrice']
transaction.gas_used = (transaction_data['gas'] *
transaction_data['gasPrice'])
transaction.hash = transaction_data['hash']
transaction.index = transaction_data['transactionIndex']
transaction.input = transaction_data['input']
transaction.internal_transactions_indexed_at = None
transaction.nonce = transaction_data['nonce']
transaction.r = transaction_data['r']
transaction.s = transaction_data['s']
# transaction.status = ''
transaction.to_address_hash = self.get_address(
transaction_data['to'])
transaction.v = transaction_data['v']
transaction.value = transaction_data['value']
transaction.save()
else:
transaction = Transaction()
transaction.block_hash = block
transaction.block_number = block.number
# transaction.cumulative_gas_used = ''
transaction.created_contract_address_hash = None
transaction.error = ''
transaction.from_address_hash = self.get_address(
transaction_data['from'])
transaction.gas = transaction_data['gas']
transaction.gas_price = transaction_data['gasPrice']
transaction.gas_used = (transaction_data['gas'] *
transaction_data['gasPrice'])
transaction.hash = transaction_data['hash']
transaction.index = transaction_data['transactionIndex']
transaction.input = transaction_data['input']
transaction.internal_transactions_indexed_at = None
transaction.nonce = transaction_data['nonce']
transaction.r = transaction_data['r']
transaction.s = transaction_data['s']
# transaction.status = ''
transaction.to_address_hash = self.get_address(
transaction_data['to'])
transaction.v = transaction_data['v']
transaction.value = transaction_data['value']
transaction.save()
# Create uncle block if exists
for uncle in block_data['uncles']:
uncle_info = w3_client.eth.getBlock(uncle)
uncle_data = web3_to_dict(uncle_info)
miner = self.get_address(uncle_data['miner'])
existing_uncle_block = Block.objects.filter(
hash=uncle_data['hash'])
if existing_uncle_block.exists():
uncle_block = existing_uncle_block.first()
uncle_block.consensus = False
uncle_block.difficulty = uncle_data['difficulty']
uncle_block.gas_limit = uncle_data['gasLimit']
uncle_block.gas_used = uncle_data['gasUsed']
uncle_block.hash = uncle_data['hash']
uncle_block.miner = miner
uncle_block.nonce = uncle_data['nonce']
uncle_block.number = uncle_data['number']
uncle_block.parent_hash = Block.objects.filter(
hash=uncle_data['parentHash']).first()
uncle_block.size = uncle_data['size']
uncle_block.timestamp = uncle_data['timestamp']
uncle_block.total_difficulty = uncle_data['totalDifficulty']
uncle_block.save()
else:
uncle_block = Block()
uncle_block.consensus = False
uncle_block.difficulty = uncle_data['difficulty']
uncle_block.gas_limit = uncle_data['gasLimit']
uncle_block.gas_used = uncle_data['gasUsed']
uncle_block.hash = uncle_data['hash']
uncle_block.miner = miner
uncle_block.nonce = uncle_data['nonce']
uncle_block.number = uncle_data['number']
uncle_block.parent_hash = Block.objects.filter(
hash=uncle_data['parentHash']).first()
uncle_block.size = uncle_data['size']
uncle_block.timestamp = uncle_data['timestamp']
uncle_block.total_difficulty = uncle_data['totalDifficulty']
uncle_block.save()
# Save relation between nephew and uncle
SecondDegreeRelation.objects.get_or_create(
nephew_hash=block,
uncle_hash=uncle_block,
defaults={'uncle_fetched_at': block.timestamp})
# Save transaction relation for uncle block
transaction_index = 0
for transaction in uncle_data['transactions']:
transaction = Transaction.objects.filter(hash=transaction)
if not transaction.exists():
continue
Fork.objects.create(hash=transaction.first(),
index=transaction_index,
uncle_hash=uncle_block)
transaction_index += 1
return JsonResponse(status=200, data=block_data, safe=False)
def test_transfer(self):
main_account = Account.get_main_account()
txid = Transaction.transfer(main_account, self.user_account, 0.1,
Transaction.ALGO, Transaction.OPT_IN)
self.assertTrue(utils.wait_for_confirmation(txid.txid))
def apiToCardFromService(request):
if request.method == 'POST':
data = request.POST
if ('key' in data) and ('vtikeeper' in data):
box = CashBox.get_by_key(data['key'])
if box:
try:
org = box.co_unit.org
except:
org = None
if org is not None:
if org.is_active:
try:
if 'type' in data:
if data['type'] == 'add':
t_type = Operations.sell
if 'value' in data and 'card' in data:
trans = Transaction().create(data)
trans.date = datetime.strptime(
data['datetime'], "%d.%m.%Y %H:%M:%S")
card = Card.objects.get(code=data['card'],
org=org.pk)
trans.bonus_before = card.get_total_bonus()
d_plan = DiscountPlan.objects.get(
org_id__exact=org.pk)
algorithm = d_plan.algorithm
card.accumulation += float(data['value'])
card.last_transaction_date = datetime.now(
).date()
card.save()
# пишем статистику
trans.org = org
trans.card = card
trans.sum = float(data['value'])
trans.bonus_reduce = 0
trans.type = t_type
try:
trans.base_doc_date = parse(
data['base_doc_date'])
except:
trans.base_doc_date = None
trans.save()
try: # Добавляем задание
task = Task(
queue_date=datetime.now(),
execution_date=trans.date +
relativedelta(
days=d_plan.time_delay),
data=data['value'],
card=card,
operation=identify_task_operation(
card, d_plan),
d_plan=d_plan,
transaction=trans,
org=card.org)
task.save()
except:
pass
return HttpResponse(data['value'])
else:
return HttpResponse(status='404')
if data['type'] == 'rem':
t_type = Operations.bonus_reduce
if 'value' in data and 'card' in data:
trans = Transaction().create(data)
trans.date = datetime.strptime(
data['datetime'], "%d.%m.%Y %H:%M:%S")
card = Card.objects.get(code=data['card'],
org=org.pk)
trans.bonus_before = card.get_total_bonus()
# пишем статистику
trans.org = org
trans.card = card
trans.sum = 0
trans.bonus_reduce = float(data['value'])
trans.type = t_type
trans.save()
value = float(data['value'])
rem_bonus(card, value)
return HttpResponse(data['value'])
else:
return HttpResponse(status='404')
except ObjectDoesNotExist as e:
return HttpResponse(status='404')
else:
return HttpResponse(status='503')
else:
return HttpResponse(status='503')
else:
return HttpResponse(status='503')
def apiAddAccumToCard(request, card_code, salt):
t_type = Operations.sell
if request.method == 'POST':
data = request.POST
if ('key' in data) and ('session_key' in data):
box = check_license(data['key'], data['session_key'])
if box:
try:
org = box.co_unit.org
except:
return HttpResponse(status=403)
org = None
else:
return HttpResponse(status=403)
if org is not None:
if org.is_active:
try:
if 'value' in data:
value = float(data['value'])
trans = Transaction().create(data)
trans.date = datetime.now()
card = Card.objects.get(code=card_code, org=org.pk)
trans.bonus_before = card.get_total_bonus()
trans.org = org
trans.card = card
trans.sum = float(data['value'])
trans.bonus_reduce = 0
trans.type = t_type
try:
trans.base_doc_date = parse(
data['base_doc_date'])
except:
trans.base_doc_date = None
d_plan = DiscountPlan.objects.get(
org_id__exact=org.pk)
algorithm = d_plan.algorithm
card.accumulation += float(data['value'])
card.last_transaction_date = datetime.now().date()
card.save()
if value < 0:
t_type = Operations.refund
trans.type = t_type
_handler = __import__(
'core.lib.%s' %
identify_task_operation(card, d_plan),
globals(), locals(), ['count'], 0)
card = _handler.count(value, card, d_plan,
trans)
card.save()
trans.save()
if value > 0:
try: # Добавляем задание
# task = Task(queue_date=datetime.now(),
# execution_date= datetime.now().date() + relativedelta(days=d_plan.time_delay),
# data=data['value'],
# card=card,
# operation=identify_task_operation(card, d_plan),
# d_plan=d_plan,
# transaction=trans,
# org=card.org)
# task.save()
_handler = __import__(
'core.lib.%s' %
identify_task_operation(card, d_plan),
globals(), locals(), ['count'], 0)
card = _handler.count(
value, card, d_plan, trans)
card.save()
except:
pass
return HttpResponse(data['value'])
else:
return HttpResponse(status='404')
except ObjectDoesNotExist as e:
return HttpResponse(status='404')
else:
return HttpResponse(status='503')
else:
return HttpResponse(status='503')
else:
return HttpResponse(status='503')
def startashipment(request, host_id=None, transaction_form_submitted=False, invoice=None, cal_form_submitted=False, packagedays_count = None, ):
random3digits = random.randint(100,999)
#set timezone
local_timezone = request.session.setdefault('django_timezone', 'UTC')
local_timezone = pytz.timezone(local_timezone)
enduser = request.user
calendar_submit_button_text = "Select Dates and Proceed to Payment"
if host_id:
host = get_object_or_404(UserInfo, pk=host_id)
else:
host = None
#Determine if payment is needed or balance will suffice
balance = enduser.account_balance_packages
if balance > 0:
payment_needed = False
amount_due = 0.00
remaining_balance = balance - 1
else:
if enduser.betauser_free:
payment_needed = False
else:
payment_needed = True
amount_due = None #this is processed on the payment page if they aren't applying account balance
remaining_balance = None
connections_all = Connection.objects.filter(end_user=enduser)
#Empty variables for availability/ conflict stuff
days_package_may_come_thismonth = []
days_package_may_come_nextmonth = []
month1days_count = None
month2days_count = None
conflicts_date_from = []
conflicts_startmonths = []
conflicts_startthismonth = []
conflicts_startnextmonth = []
conflicts_startandend_thismonth = []
conflicts_startandend_nextmonth = []
conflicts_startthismonth_endnextmonth = []
conflicts_startthismonth_endlater = []
conflicts_startnextmonth_endlater = []
days_withconflicts_thismonth = []
days_withconflicts_nextmonth = []
days_withconflicts_later = []
#if host/no host - get caklendar_homebrew created fields
if host:
transcount = Transaction.objects.filter(host=host).count() + 1 #counts transactions that this receiver_email has received (could change to host email)
#invoice = "H" + str(host.id) + "U" + str(enduser.id) + "N" +str(transcount) +"D" + str(date_today.month) + str(date_today.day) + str(time.hour) + "R" + str(random3digits) #h2u14N13D112210R123 = transaciton between host2, user14, host's 13th transaction
#JMY updating invoice algorithm - removing date to make it smaller
invoice = "H" + str(host.id) + "U" + str(enduser.id) + "N" +str(transcount) + "R" + str(random3digits) #h2u14N13D112210R123 = transaciton between host2, user14, host's 13th transaction
conflicts = HostConflicts_DateVersion.objects.filter(host=host)
for conflict in conflicts:
if conflict.month == thismonth_num:
days_withconflicts_thismonth.append(conflict.day)
if conflict.month == nextmonth_num:
days_withconflicts_nextmonth.append(conflict.day)
#i think i do this to remove duplicates
days_withconflicts_thismonth = list(set(days_withconflicts_thismonth))
days_withconflicts_nextmonth = list(set(days_withconflicts_nextmonth))
#determine if there is a conflict
host_package_conflict = False
for day in days_package_may_come_thismonth:
if day in days_withconflicts_thismonth:
host_package_conflict = True
for day in days_package_may_come_nextmonth:
if day in days_withconflicts_nextmonth:
host_package_conflict = True
else: #if no host specified that stuff is empty/none
conflicts = None
host_package_conflict = False
#do payment variables/ transaction form stuff once they've checked the calendar day
favortype='package'
#transaction_form_submitted = False
#packagedays_count = None
if cal_form_submitted:
cal_form = CalendarCheckBoxes()
packagedays = None
packagedays_string = None
trans_form_package = None
trans = Transaction()
#request.method = 'GET'
if request.method == 'POST':
trans_form_package = CreatePackageTransaction(request.POST)
if trans_form_package.is_valid():
title = trans_form_package.cleaned_data['title']
payment_option = trans_form_package.cleaned_data['payment_option']
note_to_host = trans_form_package.cleaned_data['note_to_host']
paypal_quantity = 1
if payment_option=="bundle10":
price=host.price_package_bundle10
youselected="Bundle of 10 Packages"
balance_created = 9 #10 minus the 1 they just bought
elif payment_option=="bundle20":
price=host.price_package_bundle20
youselected="Bundle of 20 Packages"
balance_created = 19 #20 minus the 1 they just bought
elif payment_option=="annual":
price=host.price_package_annual
youselected="Annual"
balance_created = 1000 #Notional - this option is not in place currently
else:
price=host.price_package_per
youselected="Per Package"
balance_created = None
#Next, add the data to the transaction table
trans.balance_created_packages = balance_created
trans.payment_option = payment_option
trans.title = title
trans.favortype = favortype
trans.note_to_host = note_to_host
trans.price = price
trans.youselected = youselected
trans.paypal_quantity = paypal_quantity
trans.host = host
trans.enduser = enduser
trans.invoice = invoice
#Account balance/ create amount_due
if enduser.account_balance_packages:
if enduser.account_balance_packages > 0:
trans.amount_due = 0
trans.payment_needed = False
else:
trans.amount_due = price
trans.payment_needed = True
else:
trans.amount_due = price
trans.payment_needed = True
arrivalwindow_days_count = trans_form_package.cleaned_data['packagedays_count']
trans.arrivalwindow_days_count = arrivalwindow_days_count
day1 = trans_form_package.cleaned_data['arrivalwindow_day1']
day1string = trans_form_package.cleaned_data['arrivalwindow_day1string']
if day1:
trans.arrivalwindow_day1 = day1
day2 = trans_form_package.cleaned_data['arrivalwindow_day2']
day2string = trans_form_package.cleaned_data['arrivalwindow_day2string']
if day2:
trans.arrivalwindow_day2 = day2
day3 = trans_form_package.cleaned_data['arrivalwindow_day3']
day3string = trans_form_package.cleaned_data['arrivalwindow_day3string']
if day3:
trans.arrivalwindow_day3 = day3
day4 = trans_form_package.cleaned_data['arrivalwindow_day4']
day4string = trans_form_package.cleaned_data['arrivalwindow_day4string']
if day4:
trans.arrivalwindow_day4 = day4
day5 = trans_form_package.cleaned_data['arrivalwindow_day5']
day5string = trans_form_package.cleaned_data['arrivalwindow_day5string']
if day5:
trans.arrivalwindow_day5 = day5
day6 = trans_form_package.cleaned_data['arrivalwindow_day6']
day6string = trans_form_package.cleaned_data['arrivalwindow_day6string']
if day6:
trans.arrivalwindow_day6 = day6
day7 = trans_form_package.cleaned_data['arrivalwindow_day7']
day7string = trans_form_package.cleaned_data['arrivalwindow_day7string']
if day7:
trans.arrivalwindow_day7 = day7
if arrivalwindow_days_count == 1:
trans.arrivalwindow_string = str(day1string)
trans.arrivalwindow_lastday = day1
if arrivalwindow_days_count == 2:
trans.arrivalwindow_string = str(day1string) + " or " + str(day2string)
trans.arrivalwindow_lastday = day2
if arrivalwindow_days_count == 3:
trans.arrivalwindow_string = str(day1string) + ", " + str(day2string) + ", or " + str(day3string)
trans.arrivalwindow_lastday = day3
if arrivalwindow_days_count == 4:
trans.arrivalwindow_string = str(day1string) + ", " + str(day2string) + ", " + str(day3string) + ", or " + str(day4string)
trans.arrivalwindow_lastday = day4
if arrivalwindow_days_count == 5:
trans.arrivalwindow_string = str(day1string) + ", " + str(day2string) + ", " + str(day3string) + ", " + str(day4string) + ", or " + str(day5string)
trans.arrivalwindow_lastday = day5
if arrivalwindow_days_count == 6:
trans.arrivalwindow_string = str(day1string) + ", " + str(day2string) + ", " + str(day3string) + ", " + str(day4string) + ", " + str(day5string) + ", or " + str(day6string)
trans.arrivalwindow_lastday = day6
if arrivalwindow_days_count == 7:
trans.arrivalwindow_lastday = day7
trans.arrivalwindow_string = str(day1string) + ", " + str(day2string) + ", " + str(day3string) + ", " + str(day4string) + ", " + str(day5string) + ", " + str(day6string) + ", or " + str(day7string)
trans.save()
transaction_form_submitted = True
else:
print trans_form_package.errors
transaction_form_submitted = False
errors_on_trans_form = 'There are errors on the transaction form'
else:
trans_form_package = CreatePackageTransaction()
transaction_form_submitted = False
errors_on_trans_form = 'Method is not POST'
#if cal_form_submitted is false
else:
transaction_form_submitted = False
errors_on_trans_form = 'Cal_form was not submitted'
trans_form_package = None
transaction_form_submitted = False
packagedays = []
packagedays_string = []
#do the cal_form submission stuff
if request.method == 'POST':
cal_form = CalendarCheckBoxes(data=request.POST)
if cal_form.is_valid():
for daynumber in range(1,32): #starts at zero otherwise so this will stop at 31
daycheckedmonth1 = cal_form.cleaned_data['month1day'+str(daynumber)]
if daycheckedmonth1:
#checked day needs to be in YYYY-MM-DD format
checked_day = str(thisyear) + "-" + str(thismonth_num) + "-" + str(daynumber)
checked_day_string = str(thismonth) + " " + str(daynumber)
packagedays.append(checked_day)
packagedays_string.append(checked_day_string)
days_package_may_come_thismonth.append(daynumber)
for daynumber in range(1,32):
daycheckedmonth2 = cal_form.cleaned_data['month2day'+str(daynumber)]
if daycheckedmonth2:
checked_day = str(nextmonth_calendar_year) + "-" + str(nextmonth_num) + "-" + str(daynumber)
checked_day_string = str(nextmonth) + " " + str(daynumber)
packagedays.append(checked_day)
packagedays_string.append(checked_day_string)
days_package_may_come_nextmonth.append(daynumber)
month1days_count = len(days_package_may_come_thismonth)
month2days_count = len(days_package_may_come_nextmonth)
cal_form_submitted = True
else:
print cal_form.errors
else:
cal_form = CalendarCheckBoxes()
packagedays_count = len(packagedays)
#if the transaction form has been submitted redirect to new page
if transaction_form_submitted == True:
cal_form = None
if payment_needed:
return HttpResponseRedirect("/transactions/payment/host" + str(host.id) + "/invoice" + str(invoice) + "/favortype" + str(favortype) + "/")
else:
return HttpResponseRedirect("/transactions/shippackage/host" + str(host.id) + "/account_balance/invoice" + str(invoice) + "/")
#if the transaction form has not been submitted
else:
return render(request, 'blocbox/startashipment.html', {
'enduser':enduser, 'host': host, 'connections_all': connections_all,
#'cal_relations_host_count': cal_relations_host_count, 'cal_relations_host': cal_relations_host, 'cal_list_host': cal_list_host,
'here': quote(request.get_full_path()),
#Python calendar variables (independent of conflict app)
'local_timezone': local_timezone, 'date_today': date_today, 'datetime_now': datetime_now,
'thisyear': thisyear, 'nextyear': nextyear, 'thisyeaer_isleap': thisyear_isleap, 'nextyear_isleap': nextyear_isleap,
'thismonth': thismonth, 'nextmonth': nextmonth, 'thismonth_calendar': thismonth_calendar, 'nextmonth_calendar': nextmonth_calendar,
'monthrange_thismonth': monthrange_thismonth, 'monthrange_nextmonth': monthrange_nextmonth, 'days_in_thismonth': days_in_thismonth, 'days_in_nextmonth': days_in_nextmonth,
'today_dayofmonth_num': today_dayofmonth_num, 'nextmonth_calendar_year': nextmonth_calendar_year,
#conflict app variables (if host)
'conflicts': conflicts, 'conflicts_startthismonth': conflicts_startthismonth, 'conflicts_startnextmonth': conflicts_startnextmonth,
'conflicts_startandend_thismonth': conflicts_startandend_thismonth, 'conflicts_startandend_nextmonth': conflicts_startandend_nextmonth,
'days_withconflicts_thismonth': days_withconflicts_thismonth, 'days_withconflicts_nextmonth': days_withconflicts_nextmonth,
#days package may come
'days_package_may_come_thismonth': days_package_may_come_thismonth, 'days_package_may_come_nextmonth': days_package_may_come_nextmonth,
'host_package_conflict': host_package_conflict,
#Calendar check boxes form
'cal_form': cal_form, 'packagedays': packagedays, 'packagedays_string': packagedays_string, 'packagedays_count': packagedays_count,
'cal_form_submitted': cal_form_submitted, 'calendar_submit_button_text': calendar_submit_button_text,
#payment stuff once the calendar checkboxes are checked
'trans_form_package': trans_form_package, 'invoice': invoice, 'favortype': favortype, 'errors_on_trans_form': errors_on_trans_form,
'transaction_form_submitted': transaction_form_submitted, 'random3digits': random3digits,
'payment_needed': payment_needed, 'amount_due': amount_due, 'remaining_balance': remaining_balance, 'request': request,
})
def count(value, card, d_plan, transaction):
try:
parameters = json.loads(d_plan.parameters)
except:
return None
if type(parameters) is not dict:
return None
value = float(value)
if 'bonus_mechanism' in parameters:
bonus_mechanism = parameters['bonus_mechanism']
else:
return None
if bonus_mechanism == 'bonus_cost':
if 'bonus_cost' in parameters:
bonus_cost = float(parameters['bonus_cost'])
else:
return None
if bonus_mechanism == 'bonus_percent':
if 'bonus_percent' in parameters:
bonus_percent = float(parameters['bonus_percent'])
else:
return None
if 'min_transaction' in parameters:
min_transaction = float(parameters['min_transaction'])
else:
return None
if 'bonus_lifetime' in parameters:
bonus_lifetime = float(parameters['bonus_lifetime'])
else:
return None
if 'round' in parameters:
rounding = parameters['round']
else:
return None
if abs(value) < min_transaction:
return card
bonus = Bonus()
bonus.date = transaction.date
bonus.active_from = datetime.now() + relativedelta(days=d_plan.time_delay)
bonus.card = card
if bonus_mechanism == 'bonus_cost':
bonus.value = custom_round((value / bonus_cost), rounding)
elif bonus_mechanism == 'bonus_percent':
bonus.value = custom_round((value * bonus_percent / 100), rounding)
bonus.active_to = bonus.active_from + relativedelta(
months=int(bonus_lifetime))
bonus.enabled = False
bonus.transaction_id = transaction.pk
trans = Transaction(org=card.org,
card=card,
date=datetime.now(),
bonus_before=card.get_total_bonus(),
doc_number=transaction.doc_number,
session=transaction.session,
sum=transaction.sum,
shop=transaction.shop,
workplace=transaction.workplace)
if value < 0:
trans.type = Operations.bonus_refund
refund_bonus(card, transaction.base_doc_date, -bonus.value)
trans.bonus_add = bonus.value
trans.save()
return card
else:
trans.type = Operations.bonus_add
trans.bonus_add = bonus.value
trans.save()
task = Task(queue_date=datetime.now(),
execution_date=datetime.now().date() +
relativedelta(days=d_plan.time_delay),
data=transaction.sum,
card=card,
operation="bonus",
d_plan=d_plan,
transaction=trans,
org=card.org)
task.save()
bonus.task_id = task.pk
bonus.save()
return card
def aggregate_results(self, user):
t = Transaction()
print('Start aggregating results')
year_of_death = 2080
current_pf_value = t.get_pf_value(timezone.now().date(), user)
median_income, median_expense = self.calc_average(user)
total_wealth = current_pf_value + self.get_current_wealth(user)
timespan = 3*365
from_date = (timezone.now() - datetime.timedelta(days=timespan)).date()
to_date = timezone.now().date()
# import pdb;pdb.set_trace()
# print(from_date, to_date, timespan)
# print(t.get_roi('All', from_date, to_date, user))
current_interest_rate = math.pow(t.get_roi(from_date, to_date, user) + 1,
Decimal(365/timespan))-1
# Regression to mean
# confidence for current_interest_rate as a predictor for future success
confidence = 0.2
# Average interest rate as more accurate predictor. Here Dow Jones performance between 1975 and 2013
average_interest_rate = 0.088
expected_interest_rate = (current_interest_rate - average_interest_rate) * confidence + average_interest_rate
# Recalibrate expected interest rate for retirement time with new assumptions
confidence = 0.1
# Average interest rate as more accurate predictor. Here Dow Jones performance between 1975 and 2013
average_interest_rate_retirement = 0.03
expected_interest_rate_retirement = (current_interest_rate - average_interest_rate_retirement) * confidence + average_interest_rate_retirement
delta_2015 = self.month_delta('2015-12-31')
# print(delta_2015)
wealth_in_2015, development = self.calc_wealth_next_month(self.get_current_wealth(user),
current_pf_value,
delta_2015,
median_income,
median_expense,
expected_interest_rate, [])
result_development = {}
result_development['incomeexpense'] = median_income-median_expense
result_development['interest'] = expected_interest_rate*100
result_development['interest_retirement'] = expected_interest_rate_retirement*100
for year_of_retirement in [2020, 2025, 2030]:
# print(year_of_retirement)
delta = self.month_delta(str(year_of_retirement)+'-12-31')
wealth, development = self.calc_wealth_next_month(self.get_current_wealth(user),
current_pf_value,
delta,
median_income,
median_expense,
expected_interest_rate, [])
# print('Wealth ok')
# print(wealth, year_of_retirement)
monthly_pension, development = self.mp(wealth,
year_of_retirement,
year_of_death,
expected_interest_rate_retirement, development)
# print('Pension ok', monthly_pension)
short_development = []
for num, item in enumerate(development):
if num % (12*5) == 0:
short_development.append(item)
result_development[year_of_retirement] = short_development
result_development['wealth' + str(year_of_retirement)] = wealth
result_development['pension' + str(year_of_retirement)] = monthly_pension
#result.append({'text': 'Estimated wealth '+str(year_of_retirement), 'value': wealth})
#result.append({'text': 'Retirement starting in '+str(year_of_retirement)+
# ', monthly payments, when using the money until '+str(year_of_death)+
# ', monthly payments:',
# 'value': monthly_pension})
return result_development
if __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "discountServer.settings")
try:
import django
except ImportError:
# The above import may fail for some other reason. Ensure that the
# issue is really that Django is missing to avoid masking other
# exceptions on Python 2.
raise
django.setup()
from queues.models import Task
from cards.models import Card
from core.models import DiscountPlan
from transactions.models import Transaction
from datetime import datetime
cards = Card.objects.filter(org_id__exact=3)
d_plan = DiscountPlan.objects.get(org_id__exact=3)
for card in cards:
print(card.code)
_handler = __import__('core.lib.%s' % d_plan.algorithm, globals(), locals(),
['count'], 0)
card = _handler.count(0, card, d_plan, Transaction())
card.save()
print('New discount = %s.' % card.discount)
def test_opt_in(self):
main_account = Account.get_main_account()
txids = Transaction.opt_in(self.user_account, main_account)
for txid in txids:
self.assertTrue(utils.wait_for_confirmation(txid))
def compute_quota(self, obj):
return Transaction.user_quota_remains_today(obj)
def createOrderId(em,plan,amount):
t = Transaction(customer_email = em,customer_name=em.first_name+" "+em.last_name,customer_phone_number=em.phone_number,plan = plan,amount = amount,eligibility = json.dumps(cust_set.plan[plan]["details"]))
t.save()
print("saving")
return str(t.order_id)
def processBtcTransactions(FreezedCurrency):
r = {
"processed_addresses": 0,
"created_transactions": [],
"errors_transactions": [],
"errors_addresses": []
}
allWallets = Wallet.objects.filter()
for wallet in allWallets:
for btcAddress in wallet.getWalletToCcAddresses(currency='BTC'):
r['processed_addresses'] += 1
atm = AtmBtc(btcAddress.address.address)
btcAddress.address.address = atm.clean(btcAddress.address.address)
try:
addressRemoteTransactions = atm.getTransactions()
except Exception, ex:
addressRemoteTransactions = []
r['errors_addresses'].append("%s" % (traceback.format_exc()))
if len(addressRemoteTransactions) > 0:
for art in addressRemoteTransactions:
if art.get("error"):
r['errors_addresses'].append(
"failed get data for address: %s" %
(btcAddress.address.address))
else:
if art['positive'] and art['confirmations'] > 0:
try:
new = False
try:
transaction = Transaction.objects.get(
hash=art['hash'],
currency="BTC",
address=btcAddress.address)
except Transaction.DoesNotExist:
previousCredit = wallet.credit
transaction = Transaction()
transaction.hash = art['hash']
transaction.date = art['date']
transaction.type = 'deposit'
transaction.currency = 'BTC'
transaction.freezedUsd = FreezedCurrency.usd
transaction.freezedEur = FreezedCurrency.eur
transaction.amount = art['value']
transaction.wallet = wallet
transaction.address = btcAddress.address
transaction.save()
# update wallet credit
feePercentage = Configuration(
).getConfiguration(
"btc_deposit_percentage")
wallet.depositIn(
FreezedCurrency, transaction,
art['value'],
'by AtmBtc found new tx: %s with positive amount: %s (BTC)'
% (art['hash'], art['value']),
feePercentage)
new = True
#all good
# create transactions info btc
transactionInfo = TransactionInfo()
transactionInfo.transaction = transaction
transactionInfo.description = 'Currency Rate Date: %s' % strftime(
FreezedCurrency.dateUpdated,
'%Y-%m-%d %H:%M:%S')
transactionInfo.save()
transactionInfo = TransactionInfo()
transactionInfo.transaction = transaction
transactionInfo.description = 'BTC -> USD'
transactionInfo.cost = FreezedCurrency.usd
transactionInfo.save()
transactionInfo = TransactionInfo()
transactionInfo.transaction = transaction
transactionInfo.description = 'BTC -> EUR'
transactionInfo.cost = FreezedCurrency.eur
transactionInfo.save()
transactionInfo = TransactionInfo()
transactionInfo.transaction = transaction
transactionInfo.description = 'Previous Credit'
transactionInfo.cost = previousCredit
transactionInfo.save()
transactionInfo = TransactionInfo()
wallet = Wallet.objects.get(id=wallet.id)
transactionInfo.transaction = transaction
transactionInfo.description = 'Current Credit'
transactionInfo.cost = wallet.credit
transactionInfo.save()
except Exception, ex:
transaction = None
r['errors_transactions'].append(
"failed insert for transaction: %s" %
(art['hash']))
if new:
if transaction:
if not any(x.hash == art['hash'] for x in
r['created_transactions']):
r['created_transactions'].append(
transaction)
# Admin Notification
adminNotification = Notification()
adminNotification.email = True
adminNotification.user = User.objects.get(
username="******")
adminNotification.setEmailData(
"New BTC deposit transaction confirmed",
"notifications/email/admin_email_new_deposit_transaction_confirmed.html",
{
'transaction': transaction,
})
def createTransaction(instance, methodType, exchangeCoin, valueInvested, pricePerToken):
transaction = Transaction()
transaction.transaction_method = methodType
transaction.exchange_coin = exchangeCoin
transaction.user = User.objects.get(username='******')
transaction.n_tokens = valueInvested
transaction.price_per_token = pricePerToken
transaction.fees = 0
transaction.date = timezone.now()
transaction.synced_transaction = None
transaction.save()
return transaction
def opt_in(self, chain=[]):
main_account = Account.get_main_account()
logger.debug("Opt-In transaction for %s account.", self.address)
return Transaction.opt_in(self, main_account, chain)
def prepare_transaction(self, transactions: list):
for transaction_data in transactions:
transaction_data["user_id"] = self.user_id
yield Transaction(**transaction_data)
def count(value, card, d_plan, transaction):
# try:
# parameters = json.loads(d_plan.parameters)
# except:
# return None
# if type(parameters) is not dict:
# return None
try:
rules = json.loads(d_plan.rules)
except:
return None
if type(rules) is not list:
return None
value = float(value)
rules = DiscountParameters().load(rules)
next_discount = None
if value >= 0:
while rules.current <= rules.last:
if rules.get_current()[0] == card.discount:
next_discount = rules.next()
if next_discount is None:
return card
if next_discount[1] <= card.accumulation:
card.discount = next_discount[0]
trans = Transaction(org=card.org,
card=card,
date=datetime.now(),
type=Operations.discount_recount,
bonus_add=card.discount,
doc_number=transaction.doc_number,
session=transaction.session,
sum=transaction.sum,
shop=transaction.shop,
workplace=transaction.workplace)
trans.save()
else:
return card
else:
rules.next()
if value < 0:
rules.current = rules.last
while rules.current >= rules.first:
if rules.get_current()[0] == card.discount:
next_discount = rules.get_previous()
if next_discount is None:
return card
if rules.get_current()[1] > card.accumulation:
card.discount = next_discount[0]
trans = Transaction(org=card.org,
card=card,
date=datetime.now(),
type=Operations.discount_recount,
bonus_add=card.discount,
doc_number=transaction.doc_number,
session=transaction.session,
sum=transaction.sum,
shop=transaction.shop,
workplace=transaction.workplace)
trans.save()
else:
return card
else:
rules.previous()
return card
def import_transactions_core(file, account, actually_import):
transaction_id_col = 'TransactionId'
reader = csv.DictReader(file)
#for row in reader:
# print("row: " + row)
duplicates = Transaction.objects.none()
duplicates_so_far = list(Transaction.objects.none())
labels = TransactionLabel.objects.all()
account = BankAccount.objects.get(pk=account) if account != '' else None
now = datetime.now()
problems = []
existing_count = 0
count = 0
for row in reader:
count += 1
transaction = Transaction()
existing_transaction = False
if transaction_id_col in row and row[transaction_id_col] != "":
id_ = int(row[transaction_id_col])
transaction = Transaction.objects.get(pk=id_)
new_temp = Transaction()
populate_bank_transaction_info(new_temp, row,
get_reimport_account_template())
if transaction.bank_account.id != int(row['AccountId']):
problems.append(
str(id_) + ": Account id changed " +
str(transaction.bank_account.id) + " != " +
row['AccountId'])
for problem in check_bank_transaction_info_consistency(
transaction, new_temp):
problems.append(str(id_) + ": " + problem)
existing_transaction = True
existing_count += 1
else:
transaction.bank_account = account
transaction.date_imported = now
if account == None:
problems.append(
"Could not parse transaction: Please select an account")
else:
try:
populate_bank_transaction_info(
transaction, row, account.bank_account_template)
except Exception as e:
problems.append("Could not parse transaction: '" + str(e) +
"'")
populate_meta_transaction_info(transaction, row, labels)
if actually_import:
if len(problems) > 0:
file = "\n".join(["- " + x for x in problems])
raise Exception("Cannot save if there are problems:\n" + file)
transaction.save()
else:
if not existing_transaction:
duplicates = duplicates | Transaction.objects.all().filter(
date=transaction.date,
description=transaction.description,
amount=transaction.amount,
current_balance=transaction.current_balance,
custom_date_1=transaction.custom_date_1,
custom_text_1=transaction.custom_text_1,
)
if count % 50 == 0:
duplicates_so_far = duplicates_so_far + list(duplicates)
duplicates = Transaction.objects.none()
duplicates_so_far = duplicates_so_far + list(duplicates)
return count, list(duplicates_so_far), existing_count, problems
def apiRemCardBonus(request, card_code, salt):
t_type = Operations.bonus_reduce
if request.method == 'POST':
data = request.POST
if ('key' in data) and ('session_key' in data):
box = check_license(data['key'], data['session_key'])
if box:
try:
org = box.co_unit.org
except:
return HttpResponse(status=403)
org = None
else:
return HttpResponse(status=403)
if org is not None:
if org.is_active:
try:
if 'value' in data:
trans = Transaction().create(data)
trans.date = datetime.now()
card = Card.objects.get(code=card_code, org=org.pk)
trans.bonus_before = card.get_total_bonus()
# пишем статистику
trans.org = org
trans.card = card
trans.sum = 0
trans.bonus_reduce = float(data['value'])
trans.type = t_type
trans.save()
value = float(data['value'])
rem_bonus(card, value)
return HttpResponse(data['value'])
else:
return HttpResponse(status='404')
except ObjectDoesNotExist as e:
return HttpResponse(status='404')
else:
return HttpResponse(status='503')
else:
return HttpResponse(status='503')
else:
return HttpResponse(status='503')
def update_pdfs(self, path):
# import pdb; pdb.set_trace()
t = Transaction()
result = t.import_sources(path)
return result
def create_series(request):
current_user = request.user
if request.method == "POST":
form = CreateSeriesForm(current_user.id, data=request.POST)
if form.is_valid():
series = form.save()
series.start_datetime = timezone.make_aware(
datetime.combine(form.cleaned_data["start_date"],
form.cleaned_data["start_time"]))
series.teacher = current_user
series.save()
students = form.cleaned_data["students"]
if series.repeat == Series.RepeatChoices.NEVER:
delta = None
elif series.repeat == Series.RepeatChoices.DAILY:
delta = timedelta(days=1)
elif series.repeat == Series.RepeatChoices.WEEKLY:
delta = timedelta(days=7)
# only RepeatChoice left is monthly
else:
delta = relativedelta(months=1)
lesson_datetime = series.start_datetime
# do-while loop implementation
while True:
lesson = Lesson(
series=series,
teacher=current_user,
datetime=lesson_datetime,
length=series.length,
)
lesson.save()
lesson.students.set(students)
for student in students:
student_status = StudentStatus(student=student,
lesson=lesson)
student_status.save()
lesson_datetime += delta
if lesson_datetime.date(
) > form.cleaned_data["end_date"] or not delta:
break
if (amount := form.cleaned_data["amount"]):
for student in students:
transaction_record = get_create_transaction_record(
current_user, student)
transaction = Transaction(
sender=current_user,
receiver=student,
last_sent_by=current_user,
transaction_record=transaction_record,
amount=amount,
note="fee for " + form.cleaned_data["name"],
series=series,
)
transaction.save()
return HttpResponseRedirect(reverse("lesson_planner:index"))
def setUp(self):
self.username = "******"
self.email = "*****@*****.**"
self.password = "******"
self.testuser = User.objects.create_user(
self.username, self.email, is_superuser=False, is_staff=False)
self.testuser.set_password(self.password)
self.testuser.save()
self.client.force_authenticate(user=User.objects.first())
self.topic = Topic.objects.create(
title='Test topic 1',
owner=self.testuser,
)
self.topic_url = reverse('topic-detail', kwargs={'pk': self.topic.pk})
self.comment = Comment(
topic=self.topic,
# 1. time spent inside "{...}" brackets
# 2. estimates of future time needed inside "{?...}"
# 3. declared work result - the content of comment
text="""
- {1.5},{?0.5} for coming up with basic class structure,
- {?2.5} for implementation,
- {?13.5} for testing.
Here is the result so far:
https://github.com/wefindx/infty2.0/commit/9f096dc54f94c31eed9558eb32ef0858f51b1aec
""",
owner=self.testuser,
)
self.comment.save()
self.comment_url = reverse(
'comment-detail', kwargs={
'pk': self.comment.pk
})
self.snapshot = self.comment.create_snapshot()
self.usd = Currency(label='usd')
self.usd.save()
self.hprice = HourPriceSnapshot(
name='FRED',
base=self.usd,
data=json.loads("""
{"realtime_start":"2017-07-28","realtime_end":"2017-07-28","observation_start":"1600-01-01","observation_end":"9999-12-31","units":"lin","output_type":1,"file_type":"json","order_by":"observation_date","sort_order":"desc","count":136,"offset":0,"limit":1,"observations":[{"realtime_start":"2017-07-28","realtime_end":"2017-07-28","date":"2017-06-01","value":"26.25"}]}"""
),
endpoint=
'https://api.stlouisfed.org/fred/series/observations?series_id=CES0500000003&api_key=0a90ca7b5204b2ed6e998d9f6877187e&limit=1&sort_order=desc&file_type=json',
)
self.hprice.save()
self.cprice = CurrencyPriceSnapshot(
name='FIXER',
base=self.usd,
data=json.loads("""
{"base":"EUR","date":"2017-07-28","rates":{"AUD":1.4732,"BGN":1.9558,"BRL":3.7015,"CAD":1.4712,"CHF":1.1357,"CNY":7.9087,"CZK":26.048,"DKK":7.4364,"GBP":0.89568,"HKD":9.1613,"HRK":7.412,"HUF":304.93,"IDR":15639.0,"ILS":4.1765,"INR":75.256,"JPY":130.37,"KRW":1317.6,"MXN":20.809,"MYR":5.0229,"NOK":9.3195,"NZD":1.5694,"PHP":59.207,"PLN":4.2493,"RON":4.558,"RUB":69.832,"SEK":9.5355,"SGD":1.5947,"THB":39.146,"TRY":4.1462,"USD":1.1729,"ZAR":15.281}}"""
),
endpoint='https://api.fixer.io/latest?base=eur',
)
self.cprice.save()
self.transaction = Transaction(
comment=self.comment,
snapshot=self.snapshot,
hour_price=self.hprice,
currency_price=self.cprice,
payment_amount=Decimal(10),
payment_currency=self.usd,
payment_recipient=self.testuser,
payment_sender=self.testuser,
hour_unit_cost=(1))
self.transaction.save()
