def set_alarm(request):
"""
Shows every available asset and gives a POST method to set
an alarm on the asset.
:rtype: HttpResponse
"""
if request.method == 'POST':
try:
float(request.POST['threshold'])
except ValueError:
return HttpResponse(status=400, reason="Incorrect threshold value")
if float(request.POST['threshold']) < 0:
return HttpResponse(status=400, reason="Incorrect threshold value")
elif not request.POST.getlist('asset'):
return HttpResponse(status=400,
reason="You need to select at least one asset")
else:
wallet = Wallet.objects.get(user=request.user)
return JsonResponse(Alarm.safe_save(wallet=wallet,
price=request.POST[
'price'],
aname=request.POST['asset'],
threshold=request.POST[
'threshold'],
atype=request.POST['type']))
else:
asset_comunication = ACommunication(settings.API_URL)
asset_list = [a.to_dict() for a in
asset_comunication.get_assets_with_average()]
context = {'assets': asset_list}
return render(request, 'Game/set_alarm.html', context)
def safe_save(wallet, aname, threshold, atype, price):
"""
Saves a new alarm and returns a dictionary with information.
:rtype: Dict
"""
from Game.models import Asset
acom = ACommunication(settings.API_URL)
asset = Asset.create_if_not_exists(aname)
if not asset:
return {'error': True, 'message': 'Non existing asset'}
asset = acom.get_asset_quote(asset)
if Alarm.safe_get(wallet, asset, price, atype):
return {
'error': True,
'message': 'You already have an alarm on this asset'
}
Alarm.objects.create(wallet=wallet,
asset=asset,
price=price,
old_price=asset.__getattribute__(price),
threshold=threshold,
type=atype).save()
return {
'error': False,
'message': 'Your alarm has been set successfully!'
}
def ajax_quote(request, name):
"""
returns the quote for an asset given the name
:rtype: JsonResponse or HttpResponse
"""
asset_comunication = ACommunication(settings.API_URL)
asset = asset_comunication.get_asset_quote(Asset(name=name))
if asset.buy != -1 and asset.sell != -1:
return JsonResponse(asset.to_dict())
else:
return HttpResponse(status=403, reason="No asset quote")
def create_if_not_exists(name):
"""
Look for an asset buy name, if asset doesn't exists, it creates it.
:rtype: Asset
"""
asset = Asset.safe_get(name)
if not asset:
asset_comms = ACommunication(settings.API_URL)
type = asset_comms.get_asset_type(name)
if not type:
return None
asset = Asset.objects.create(name=name, type=type)
asset.save()
return asset
def history(request, name):
"""
Shows the historic value for an asset in a range of dates
:rtype: HttpResponse
"""
if request.method == 'POST':
start = request.POST['start']
end = request.POST['end']
asset_comunication = ACommunication(settings.API_URL)
prices = asset_comunication.get_asset_history(name, start, end)
prices['name'] = name
return render(request, 'Game/history.html', prices)
else:
return render(request, 'Game/select_dates.html')
def setUp(self):
self.asset_communication = AComunication(
'http://localhost:8000/simulations/')
user = User.objects.create(username='******')
Wallet.objects.create(user=user)
user2 = User.objects.create(username='******')
Wallet.objects.create(user=user2)
def assets(request):
"""
Shows every available asset
:rtype: HttpResponse
"""
asset_comunication = ACommunication(settings.API_URL)
asset_list = [a.to_dict() for a in asset_comunication.get_assets()]
context = {'assets': asset_list}
# user info
wallet = Wallet.get_info(request.user)
context['value_wallet'] = wallet['value_wallet']
context['liquid'] = wallet['liquid']
if request.is_ajax():
return JsonResponse(context)
else:
return render(request, 'Game/assets.html', context)
class InterfaceControlTest(TestCase):
def setUp(self):
self.asset_communication = AComunication(
'http://localhost:8000/simulations/')
user = User.objects.create(username='******')
Wallet.objects.create(user=user)
user2 = User.objects.create(username='******')
Wallet.objects.create(user=user2)
def test_asset_communication_sanity(self):
# search for the names
assets_name = self.asset_communication.get_asset_names()
self.assertNotEqual(assets_name, [])
# search for all info
asset_info = [
self.asset_communication.get_asset_quote(a) for a in assets_name
if self.asset_communication.has_quote(
self.asset_communication.get_asset_quote(a))
]
self.assertNotEqual(asset_info, [])
# dedasset_communicationated full method
assets_complete = self.asset_communication.get_assets()
self.assertNotEqual(assets_complete, [])
def test_asset_communication_border(self):
# ask for a quote of unexistent asset
asset = Asset(name="NONE", type="NONE")
quote = self.asset_communication.get_asset_quote(asset)
self.assertEqual(quote.buy, -1)
self.assertEqual(quote.sell, -1)
# ask for a quote of existent asset
asset = Asset(name="MARSHALL", type="currency")
quote = self.asset_communication.get_asset_quote(asset)
self.assertNotEqual(quote.buy, -1)
self.assertNotEqual(quote.sell, -1)
def test_wallet_sanity(self):
# get user
user = User.objects.get(username='******')
wallet = Wallet.objects.get(user=user)
# create and save assets
assets = self.asset_communication.get_asset_names()
asset_a = assets[0]
asset_a = Asset.objects.create(name=asset_a.name, type=asset_a.type)
asset_c = assets[3]
asset_c = Asset.objects.create(name=asset_c.name, type=asset_c.type)
# create and save transactions
Ownership.objects.create(asset=asset_a, quantity=3, wallet=wallet)
Ownership.objects.create(asset=asset_c, quantity=5, wallet=wallet)
# check algorithm response
response = Wallet.get_info(user)
self.assertFalse(response['error'])
expected_assets = [
self.asset_communication.get_asset_quote(asset_a),
self.asset_communication.get_asset_quote(asset_c)
]
result_assets = response['assets']
self.assertEqual(len(result_assets), len(expected_assets))
for e, r in zip(expected_assets, result_assets):
self.assertEqual(e.name, r.name)
def test_wallet_buy(self):
# get user
user = User.objects.get(username='******')
wallet = Wallet.objects.get(user=user)
# create and save assets
assets = self.asset_communication.get_assets()
asset_a = assets[0]
asset_a.quantity = 2.3
asset_c = assets[3]
asset_c.quantity = 1.4
# expected results
expected_money_result = 7680.0
expected_ownership_result = [
Ownership.objects.create(asset=asset_a,
wallet=wallet,
quantity=2.3),
Ownership.objects.create(asset=asset_c,
wallet=wallet,
quantity=1.4)
]
# buy assets
wallet.buy_asset(asset_a)
wallet.buy_asset(asset_c)
# check algorithm response
self.assertEqual(expected_money_result, wallet.liquid)
self.assertEqual(expected_ownership_result,
list(Ownership.objects.all()))
def test_wallet_buy_border_quantity(self):
# get user
user = User.objects.get(username='******')
wallet = Wallet.objects.get(user=user)
# create and save assets
assets = self.asset_communication.get_assets()
asset_a = assets[0]
asset_a.quantity = 200000
# expected results
expected_money_result = 10000
expected_ownership_result = []
# buy assets
wallet.buy_asset(asset_a)
# check algorithm response
self.assertEqual(expected_money_result, wallet.liquid)
self.assertEqual(expected_ownership_result,
list(Ownership.objects.all()))
def test_wallet_buy_border_nil_quantity(self):
# get user
user = User.objects.get(username='******')
wallet = Wallet.objects.get(user=user)
# create and save assets
assets = self.asset_communication.get_assets()
asset_a = assets[0]
asset_a.quantity = 0
# expected results
expected_money_result = 10000
expected_ownership_result = []
# buy assets
wallet.buy_asset(asset_a)
# check algorithm response
self.assertEqual(expected_ownership_result,
list(Ownership.objects.all()))
self.assertEqual(expected_money_result, wallet.liquid)
def test_wallet_sell_asset_part(self):
# get user
user = User.objects.get(username='******')
wallet = Wallet.objects.get(user=user)
# create and save assets
assets = self.asset_communication.get_assets()
asset_a = assets[0]
asset_c = assets[3]
# create and save transactions
own1 = Ownership.objects.create(asset=asset_a,
quantity=3,
wallet=wallet)
own2 = Ownership.objects.create(asset=asset_c,
quantity=5,
wallet=wallet)
asset_a.quantity = 2.3
asset_c.quantity = 1.4
# expected results
expected_money_result = 11152.8
expected_asset_a_quantity = 0.7
expected_asset_c_quantity = 3.6
expected_ownership_result = [own1, own2]
# sell assets
wallet.sell_asset(asset_a)
wallet.sell_asset(asset_c)
# check algorithm response
self.assertEqual(expected_money_result, wallet.liquid)
self.assertEqual(expected_asset_a_quantity,
Ownership.objects.all()[0].quantity)
self.assertEqual(expected_asset_c_quantity,
Ownership.objects.all()[1].quantity)
self.assertEqual(expected_ownership_result,
list(Ownership.objects.all()))
def test_wallet_sell_asset_full(self):
# get user
user = User.objects.get(username='******')
wallet = Wallet.objects.get(user=user)
# create and save assets
assets = self.asset_communication.get_assets()
asset_a = assets[0]
asset_a.quantity = 3
asset_c = assets[3]
asset_c.quantity = 5
# create and save transactions
Ownership.objects.create(asset=asset_a, quantity=3, wallet=wallet)
Ownership.objects.create(asset=asset_c, quantity=5, wallet=wallet)
# expected results
expected_money_result = 11510.0
expected_ownership_result = []
# sell assets
wallet.sell_asset(asset_a)
wallet.sell_asset(asset_c)
# check algorithm response
self.assertEqual(expected_money_result, wallet.liquid)
self.assertEqual(expected_ownership_result,
list(Ownership.objects.all()))
def test_wallet_sell_border_quantity(self):
# get user
user = User.objects.get(username='******')
wallet = Wallet.objects.get(user=user)
# create and save assets
assets = self.asset_communication.get_assets()
asset_a = assets[0]
asset_a.quantity = 20000000
# create and save transactions
own = Ownership.objects.create(asset=asset_a,
quantity=3,
wallet=wallet)
# expected results
expected_money_result = 10000
expected_ownership_result = [own]
# sell assets
wallet.sell_asset(asset_a)
# check algorithm response
self.assertEqual(expected_money_result, wallet.liquid)
self.assertEqual(expected_ownership_result,
list(Ownership.objects.all()))
def test_wallet_sell_border_nil_quantity(self):
# get user
user = User.objects.get(username='******')
wallet = Wallet.objects.get(user=user)
# create and save assets
assets = self.asset_communication.get_assets()
asset_a = assets[0]
asset_a.quantity = 0
# create and save transactions
own = Ownership.objects.create(asset=asset_a,
quantity=3,
wallet=wallet)
# expected results
expected_money_result = 10000
expected_ownership_result = [own]
# sell assets
wallet.sell_asset(asset_a)
# check algorithm response
self.assertEqual(expected_money_result, wallet.liquid)
self.assertEqual(expected_ownership_result,
list(Ownership.objects.all()))
def test_wallet_sell_border_ownership(self):
# get user
user = User.objects.get(username='******')
wallet = Wallet.objects.get(user=user)
# create and save assets
assets = self.asset_communication.get_assets()
asset_a = assets[0]
asset_a.quantity = 2
# expected results
expected_money_result = 10000
expected_ownership_result = []
# sell assets
wallet.sell_asset(asset_a)
# check algorithm response
self.assertEqual(expected_money_result, wallet.liquid)
self.assertEqual(expected_ownership_result,
list(Ownership.objects.all()))
def test_wallet_buy_then_sell(self):
# get user
user = User.objects.get(username='******')
wallet = Wallet.objects.get(user=user)
# create and save assets
assets = self.asset_communication.get_assets()
asset_a = assets[0]
asset_a.quantity = 2
# expected results
expected_money_result = 10200
expected_ownership_result = []
wallet.buy_asset(asset_a)
wallet.sell_asset(asset_a)
# check algorithm response
self.assertEqual(expected_money_result, wallet.liquid)
self.assertEqual(expected_ownership_result,
list(Ownership.objects.all()))
def test_alarm_not_exist_asset(self):
#get user
user = User.objects.get(username='******')
wallet = Wallet.objects.get(user=user)
#create alarm
res = Alarm.safe_save(wallet=wallet,
aname=None,
threshold=200,
atype='type',
price=100)
self.assertEqual(res, {'error': True, 'message': 'Non existing asset'})
def test_delete_alarm(self):
# get user
user = User.objects.get(username='******')
wallet = Wallet.objects.get(user=user)
#take asset
assets = self.asset_communication.get_assets()
asset = assets[0]
asset.save()
# create alarm
Alarm.safe_save(wallet=wallet,
aname=asset.name,
threshold=200,
atype='down',
price="buy")
# delete alarm
Alarm.safe_delete(wallet=wallet,
name=asset.name,
atype="down",
price="buy")
self.assertEqual(
None,
Alarm.safe_get(wallet=wallet,
asset=asset,
price="buy",
type="down"))
def test_offerloan_regular_values(self):
# get user
user = User.objects.get(username='******')
wallet = Wallet.objects.get(user=user)
# create and save a loan offer
loanoffer = LoanOffer(lender=wallet,
offered=1000,
interest_rate=2.0,
days=10)
# check object saves correctly.
self.assertEqual(loanoffer.offered, 1000)
self.assertEqual(loanoffer.lender, wallet)
self.assertEqual(loanoffer.interest_rate, 2.0)
self.assertEqual(loanoffer.days, 10)
def test_offerloan_then_modify(self):
# get user
user = User.objects.get(username='******')
wallet = Wallet.objects.get(user=user)
# create and save a loan offer
loanoffer = LoanOffer(lender=wallet,
offered=1000,
interest_rate=2.0,
days=10)
loanoffer.save()
# record previous money amount
oldliq = wallet.liquid
# modify loan
res = LoanOffer.safe_modification(lender=wallet,
id=str(loanoffer.id),
new_offer=500)
loanoffer = LoanOffer.objects.get(id=loanoffer.id)
# check modification.
self.assertEqual(res['error'], False)
self.assertEqual(loanoffer.offered, 500)
self.assertEqual(loanoffer.lender, wallet)
self.assertEqual(loanoffer.interest_rate, 2.0)
self.assertEqual(loanoffer.days, 10)
# check user has its money back.
self.assertEqual(wallet.liquid_with_loans, oldliq - 500)
def test_make_loan_and_someone_takesit(self):
# get users
user1 = User.objects.get(username='******')
user2 = User.objects.get(username='******')
wallet1 = Wallet.objects.get(user=user1)
wallet2 = Wallet.objects.get(user=user2)
# create and save an offer
loanoffer = LoanOffer(lender=wallet1,
offered=500,
interest_rate=2.0,
days=10)
loanoffer.save()
# record previous amount of money
oldliq = wallet1.liquid
oldliq2 = wallet2.liquid
loanoffer = LoanOffer.objects.get(id=loanoffer.id)
# take loan
loaned = loanoffer.offered
Loan.safe_save(borrower=wallet2, loaned=loaned, offer=loanoffer)
self.assertEqual(oldliq2 + 500, wallet2.liquid_with_loans)
self.assertEqual(oldliq - 500, wallet1.liquid_with_loans)
def test_offer_loan_but_not_eough_money(self):
# get users
user1 = User.objects.get(username='******')
wallet1 = Wallet.objects.get(user=user1)
# create and save an offer
res = LoanOffer.safe_save(wallet=wallet1,
offered=10001,
interest=2.0,
days=10)
self.assertEqual(
res, {
'error': True,
'message': 'You have not enough liquid money available'
})
def test_offer_loan_but_negative_money(self):
# get users
user1 = User.objects.get(username='******')
wallet1 = Wallet.objects.get(user=user1)
# create and save an offer
res = LoanOffer.safe_save(wallet=wallet1,
offered=-1000,
interest=2.0,
days=10)
self.assertEqual(
res, {
'error': True,
'message': 'You have not enough liquid money available'
})
def test_offer_loan_but_invalid_interest(self):
# get users
user1 = User.objects.get(username='******')
wallet1 = Wallet.objects.get(user=user1)
# create and save an offer
res = LoanOffer.safe_save(wallet=wallet1,
offered=1000,
interest=101,
days=10)
self.assertEqual(
res, {
'error': True,
'message': 'The interest rate is not a valid percentage'
})
def test_offer_loan_but_invalid_daysdue(self):
# get users
user1 = User.objects.get(username='******')
wallet1 = Wallet.objects.get(user=user1)
# create and save an offer
res = LoanOffer.safe_save(wallet=wallet1,
offered=1000,
interest=2.0,
days=0)
self.assertEqual(res, {
'error': True,
'message': 'The days amount cannot be negative'
})
def test_set_alarm_of_asset(self):
# get user
user = User.objects.get(username='******')
wallet = Wallet.objects.get(user=user)
# create asset
assets = self.asset_communication.get_assets()
asset_a_alarm = assets[0]
asset_a_alarm.save()
# create and save alarm
Alarm.objects.create(wallet=wallet,
asset=asset_a_alarm,
price='buy',
old_price=asset_a_alarm.__getattribute__('buy'),
threshold=200,
type='down').save()
# check object saves correctly.
alarm = Alarm.objects.all()[0]
self.assertEqual(alarm.wallet, wallet)
self.assertEqual(alarm.asset, asset_a_alarm)
self.assertEqual(alarm.price, 'buy')
self.assertEqual(alarm.threshold, 200)
self.assertEqual(alarm.type, 'down')