def test_balance_sub_exception2(self):
b = Balance()
b.set(100)
try:
b.sub(101)
except BalanceException as e:
self.assertEquals("Value invalid for function", e.message)
class PortfolioModel(models.Model):
user = models.CharField(max_length=256)
stocks = models.CharField(max_length=99999999, default=json.dumps({}))
balance = models.FloatField(default=0.0)
balance_obj = Balance()
def get_balance(self):
return self.balance
def set_stocks(self, stock_list):
print(stock_list)
self.stocks = json.dumps(stock_list)
def get_stocks(self):
return json.loads(self.stocks)
def get_absolute_url(self):
return reverse("portfolio", kwargs={'pk': self.pk})
def set_balance(self, balance):
self.balance = balance
def add_balance(self, amount):
self.balance_obj.add(amount)
self.balance += amount
self.save()
def sub(self, amount):
if (amount > self.balance):
raise BalanceException
if (amount < 0):
raise BalanceException
self.balance -= amount
self.save()
def buy(self, stockObj, quantity):
'''
this will handle the balance exceptions
'''
#print(float(stockObj.getPrice()) * quantity)
self.sub(float(stockObj.getPrice()) * quantity)
'''
store stock in dict as tuple of quantity and price ( price can be used for history/gain? )
'''
current_stocks = self.get_stocks()
current_stocks[stockObj.getSymbol()] = current_stocks[
stockObj.getSymbol()] + quantity if stockObj.getSymbol(
) in current_stocks.keys() else quantity
self.set_stocks(current_stocks)
self.save()
def sell(self, stock, quantity_to_sell):
key = stock.getSymbol()
current_stocks = self.get_stocks()
if current_stocks[key] < quantity_to_sell:
raise StockException
current_stocks[key] -= quantity_to_sell
self.add_balance(float(stock.getPrice()) * quantity_to_sell)
if current_stocks[key] == 0:
del current_stocks[key]
self.set_stocks(current_stocks)
self.save()
stocks = self.get_stocks()
balance = self.get_balance()
def test_balance_set(self):
b = Balance()
b.add(10.0)
b.set(9.0)
self.assertEquals(b.getBalance(), 9.0)
def test_balance_sub_exception1(self):
b = Balance()
try:
b.sub(-1.0)
except BalanceException as e:
self.assertEquals("Value invalid for function", e.message)
def test_balance_sub(self):
b = Balance()
b.add(10.0)
b.sub(5.0)
self.assertEquals(b.getBalance(), 5.0)
def test_balance_add(self):
b = Balance()
b.add(10.0)
self.assertEquals(b.getBalance(), 10.0)
def test_balance(self):
b = Balance()
self.assertEquals(b.getBalance(), 0.0)
def __init__(self, user):
self.__balance = Balance()
self.__stocks = {}
self.__user = user
class Portfolio:
def __init__(self, user):
self.__balance = Balance()
self.__stocks = {}
self.__user = user
# self.__portfolio = PortfolioModel.objects.get(user=self.__user)
def getStocks(self):
return self.__stocks
def getHistory(self):
'''
I have NO idea what we plan on doing here
'''
pass
def getTotalValue(self):
value = 0
for st in self.__stocks:
value += (self.__stocks[st][0] * st.getPrice())
return value + self.__balance.getBalance()
def getStockQuantity(self, stock):
if stock.getSymbol() not in self.__stocks:
raise StockException
return self.__stocks[stock.getSymbol()][0]
def buy(self, stock, quantity):
'''
this will handle the balance exceptions
'''
self.__balance.sub(stock.getPrice() * quantity)
'''
store stock in dict as tuple of quantity and price ( price can be used for history/gain? )
'''
self.__stocks[stock.getSymbol()] = (quantity, stock.getPrice())
def sell(self, stock, quantity):
if stock.getSymbol() not in self.__stocks:
raise StockException
if self.__stocks[stock.getSymbol()][0] < quantity:
raise StockException
self.__balance.add(stock.getPrice() * quantity)
self.__stocks[stock.getSymbol()][0] -= quantity
def getPortfolioHandler(self):
pass
'''
do we need these ?
'''
def addStock(self, stock):
pass
def removeStock(self):
pass