def test_model_liability(self):
"Test liability model"
contact_type = ContactType(name='test')
contact_type.save()
contact = Contact(name='test', contact_type=contact_type)
contact.save()
currency = Currency(code="GBP",
name="Pounds",
symbol="L",
is_default=True)
currency.save()
account = Account(name='test',
owner=contact,
balance_currency=currency)
account.save()
obj = Liability(name='test',
source=contact,
target=contact,
account=account,
value=10,
value_currency=currency)
obj.save()
self.assertEquals('test', obj.name)
self.assertNotEquals(obj.id, None)
obj.delete()
def generate_email_subject_and_body( session, order, trade ):
from json import dumps
from pyblinktrade.json_encoder import JsonEncoder
from models import Currency
qty_currency = order.symbol[:3]
formatted_qty = Currency.format_number( session, qty_currency, trade.size / 1.e8 )
price_currency = order.symbol[3:]
formatted_price = Currency.format_number( session, price_currency, trade.price / 1.e8 )
formatted_total_price = Currency.format_number( session, price_currency, trade.size/1.e8 * trade.price/1.e8 )
email_subject = 'E'
email_template = "order-execution"
email_params = {
'username': order.user.username,
'order_id': order.id,
'trade_id': trade.id,
'side': order.side,
'executed_when': trade.created,
'qty': formatted_qty,
'price': formatted_price,
'total': formatted_total_price
}
return email_subject, email_template, dumps(email_params, cls=JsonEncoder)
def test_model_liability(self):
"Test liability model"
contact_type = ContactType(name='test')
contact_type.save()
contact = Contact(name='test', contact_type=contact_type)
contact.save()
currency = Currency(code="GBP",
name="Pounds",
symbol="L",
is_default=True)
currency.save()
account = Account(
name='test', owner=contact, balance_currency=currency)
account.save()
obj = Liability(name='test',
source=contact,
target=contact,
account=account,
value=10,
value_currency=currency)
obj.save()
self.assertEquals('test', obj.name)
self.assertNotEquals(obj.id, None)
obj.delete()
def generate_email_subject_and_body( session, order, trade ):
from json import dumps
from pyblinktrade.json_encoder import JsonEncoder
from models import Currency
qty_currency = order.symbol[:3]
formatted_qty = Currency.format_number( session, qty_currency, trade.size / 1.e8 )
price_currency = order.symbol[3:]
formatted_price = Currency.format_number( session, price_currency, trade.price / 1.e8 )
formatted_total_price = Currency.format_number( session, price_currency, trade.size/1.e8 * trade.price/1.e8 )
email_subject = 'E'
email_template = "order-execution"
email_params = {
'username': order.user.username,
'order_id': order.id,
'trade_id': trade.id,
'side': order.side,
'executed_when': trade.created,
'qty': formatted_qty,
'price': formatted_price,
'total': formatted_total_price
}
return email_subject, email_template, dumps(email_params, cls=JsonEncoder)
def dbinit(self):
# Currencies
currencies = {}
currencies["BTC"] = Currency(key_name="BTC",
name="Bitcoin",
symbol="BTC")
currencies["USD"] = Currency(key_name="USD",
name="US Dollar",
symbol=u"$")
currencies["EUR"] = Currency(key_name="EUR", name="Euro", symbol=u"€")
currencies["SEK"] = Currency(key_name="SEK",
name="Swedish Kronor",
symbol="kr")
for currency in currencies:
currencies[currency].put()
# Markets
markets = {}
markets["KapitonSEK"] = Market(key_name="KapitonSEK",
name="Kapiton",
url="http://kapiton.se/",
currency=currencies["SEK"],
fee=0.0135)
markets["MtGoxEUR"] = Market(key_name="MtGoxEUR",
name="MtGox",
url="http://mtgox.com/",
currency=currencies["EUR"],
fee=0.006)
markets["MtGoxUSD"] = Market(key_name="MtGoxUSD",
name="MtGox",
url="http://mtgox.com/",
currency=currencies["USD"],
fee=0.006)
for market in markets:
markets[market].put()
def db_init():
"""
Fills the DB with available currencies and theirs notes values
"""
for curr in VALID_VALUES:
row = Currency(name=curr,
notes={str(x): 0
for x in VALID_VALUES[curr]})
row.save()
def store_available_atm_currency_notes(curr: str, notes: dict):
"""
Store certain currency available notes in DB
:param curr:
:param notes:
"""
prepared_notes = {str(x): notes[x]
for x in notes
} # once Mongo doesn't support int as dict keys
Currency.objects(name=curr).update_one(notes=prepared_notes)
def setUp(self):
self.group, created = Group.objects.get_or_create(name='test')
self.user, created = DjangoUser.objects.get_or_create(username=self.username)
self.user.set_password(self.password)
self.user.save()
perspective, created = Perspective.objects.get_or_create(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.category = Category(name='test')
self.category.set_default_user()
self.category.save()
self.equity = Equity(
issue_price=10, sell_price=10, issuer=self.contact, owner=self.contact)
self.equity.set_default_user()
self.equity.save()
self.asset = Asset(name='test', owner=self.contact)
self.asset.set_default_user()
self.asset.save()
self.tax = Tax(name='test', rate=10)
self.tax.set_default_user()
self.tax.save()
self.currency = Currency(code="GBP",
name="Pounds",
symbol="L",
is_default=True)
self.currency.set_default_user()
self.currency.save()
self.account = Account(
name='test', owner=self.contact, balance_currency=self.currency)
self.account.set_default_user()
self.account.save()
self.liability = Liability(name='test',
source=self.contact,
target=self.contact,
account=self.account,
value=10,
value_currency=self.currency)
self.liability.set_default_user()
self.liability.save()
self.transaction = Transaction(name='test', account=self.account, source=self.contact,
target=self.contact, value=10, value_currency=self.currency)
self.transaction.set_default_user()
self.transaction.save()
def test_currency_commits(self):
currency = Currency('US Dollar', 'USD', "USA", "NMS", 1)
db.session.add(currency)
db.session.commit()
# assert currency is in db
self.assertIn(currency, db.session)
def get(self):
user = User.select().where(User.id == int(self.current_user)).get()
names = self.currency_names()
# get user's portfolio based off of slug in url
userMarkets = UserCurrency.select().where(
UserCurrency.user_id == user.id)
bitcoin = Currency.select().where(
Currency.coin_pair == "USDT-BTC").get()
# set bitcoin as variable in order to render the price on the index page.
if not userMarkets:
market = Market.select().join(Currency).where(
Currency.coin_pair == "USDT-BTC").get()
return self.render_template("dashboard.html", {
"user": user,
"market": market,
"bitcoin": bitcoin,
'names': names
})
return self.render_template(
"dashboard.html", {
"user": user,
"bitcoin": bitcoin,
"userMarkets": userMarkets,
'names': names
})
def get(self):
user = False
if self.current_user:
user = int(self.current_user)
bitcoin = Currency.select().where(Currency.coin_pair == "USDT-BTC").get()
# set bitcoin as variable in order to render the price on the index page.
markets = Market.select().join(Currency).where(Currency.id == Market.currency_id).order_by(Currency.volume.desc()).limit(6)
return self.render_template("index.html", {'markets': markets, "bitcoin": bitcoin, "user": user})
def test_currency_returns(self):
currency = Currency('US Dollar', 'USD', "USA", "NMS", 1)
db.session.add(currency)
db.session.commit()
# assert it retuns correct data
self.assertEqual(
'<Currency \'US Dollar\'>', str(currency.query.first()))
def add_data():
with open('data.csv', 'r') as f:
next(f)
reader = csv.reader(f)
for row in reader:
new_entry = Currency(row[0], row[1], dateutil.parser.parse(row[2]))
db.session.add(new_entry)
db.session.commit()
def validate_currency(data):
try:
code = data.get('code')
if code == 'null' or code == None or code == '(none)':
return False
return Currency(code=code, name=data.get('name'))
except:
return False
async def call_exchange(app) -> dict:
async with ClientSession() as session:
async with session.get(
'https://api.exchangeratesapi.io/latest') as resp:
json_response = await resp.json()
date = json_response['date']
rates = json_response['rates']
app.currency_state = Currency(date=date, rates=rates)
def test_model_account(self):
"Test account model"
contact_type = ContactType(name='test')
contact_type.save()
contact = Contact(name='test', contact_type=contact_type)
contact.save()
currency = Currency(code="GBP",
name="Pounds",
symbol="L",
is_default=True)
currency.save()
obj = Account(name='test', owner=contact, balance_currency=currency)
obj.save()
self.assertEquals('test', obj.name)
self.assertNotEquals(obj.id, None)
obj.delete()
def start(self):
print('----TRADER STARTED----')
currencies = Currency.select().group_by(Currency.currency)
for currency in currencies:
scan_results = self.scan(currency.currency)
print(scan_results)
simple_safe_strategy = SimpleSafeStrategy(scan_results)
self.decide(currency.currency, simple_safe_strategy)
def scan(self, currency):
prices = Currency.select().where(
Currency.currency == currency).order_by(-Currency.date).limit(30)
up_count = 0
down_count = 0
up_streak = 0
down_streak = 0
print('------------------')
for i in reversed(range(len(prices))):
prev = prices[i - 1]
curr = prices[i]
if prev.price == curr.price:
continue
diff = round(prev.price - curr.price, 6)
diff_pct = round((diff / prev.price) * 100, 6)
if prev.price > curr.price:
state = '+++'
up_count += 1
up_streak += 1
down_streak = 0
else:
state = '---'
down_count += 1
up_streak = 0
down_streak += 1
date = datetime.strptime(curr.date.replace(':00Z', ''),
'%Y-%m-%dT%H:%M')
# print('{} ~ {}: ${} {} {}% \tdiff={}$'.format(
# currency, date, curr.price, state, diff_pct, diff))
start_price = prices[-1].price
curr_price = prices[0].price
price_30m_change = curr_price - start_price
price_30m_change_pct = (price_30m_change / start_price * 100) / 100
return dict((
('up_streak', up_streak),
('down_streak', down_streak),
('up_count', up_count),
('down_count', down_count),
('going_up', up_count > down_count),
('up_down_diff', up_count - down_count),
('price_30m_change', price_30m_change),
('price_30m_change_pct', price_30m_change_pct),
('price_1h_change', prices[-1].price_1h_change),
('price_1h_change_pct', prices[-1].price_1h_change_pct),
('price_1d_change', prices[-1].price_1d_change),
('price_1d_change_pct', prices[-1].price_1d_change_pct),
))
def update_currencies():
"""
Downloads all available currencies and prepares the database.
"""
response = get("http://apilayer.net/api/live?access_key=%s" %
(Config.APILAYER_KEY)).json()
for currency_code in response["quotes"].keys():
currency = get_currency(short_code=currency_code[3:]).first()
if not currency:
currency = Currency(short_code=currency_code[3:])
session.add(currency)
session.commit()
currency.value = response["quotes"][
currency_code] / Config.CURRENCY_DIVIDER
currency.last_update = get_current_date()
session.commit()
def fill_currencies(engine: Engine):
""" Fill currencies table with CurrencyEnum values """
conn = engine.connect()
trans = conn.begin()
for c in CurrencyEnum:
query = sa.select((1, )).where(Currency.c.name == c.value)
already_exists = conn.execute(query).scalar()
if not already_exists:
query = Currency.insert().values(name=c.value)
conn.execute(query)
trans.commit()
def test_model_account(self):
"Test account model"
contact_type = ContactType(name='test')
contact_type.save()
contact = Contact(name='test', contact_type=contact_type)
contact.save()
currency = Currency(code="GBP",
name="Pounds",
symbol="L",
is_default=True)
currency.save()
obj = Account(name='test', owner=contact,
balance_currency=currency)
obj.save()
self.assertEquals('test', obj.name)
self.assertNotEquals(obj.id, None)
obj.delete()
def index():
if request.method == 'POST':
new_currency = request.form['currency_name']
funcstart = get_content(ready_url(main_url, new_currency))
print(funcstart)
new_value = round(float(funcstart), 3)
print(new_value)
try:
currency_note = Currency(currency_name = new_currency, currency_value = new_value)
db.session.add(currency_note)
db.session.commit()
except:
print('something went wrong')
return redirect(url_for('dashbord.index'))
else:
form = CurrencyForm()
graph_usd_to_ils = Currency.query.filter(Currency.currency_name == '/USD/ILS/').order_by(db.desc(Currency.currency_date)).limit(7)
graph_ils_to_rub = Currency.query.filter(Currency.currency_name == '/ILS/RUB/').order_by(db.desc(Currency.currency_date)).limit(7)
mass_dates_rev_u_i, mass_currency_rev_u_i = reverce_val(graph_usd_to_ils)
mass_dates_rev_i_r, mass_currency_rev_i_r = reverce_val(graph_ils_to_rub)
return render_template('dashbord/index.html',
form = form,
currency_usd_to_ils = graph_usd_to_ils,
currency_ils_to_rub = graph_ils_to_rub,
mass_dates = mass_dates_rev_u_i,
mass_currency = mass_currency_rev_u_i,
mass_dates_2 = mass_dates_rev_i_r,
mass_currency_2 = mass_currency_rev_i_r,
)
def start(self):
print('----SCRAPER STARTED----')
api = NomicsApi()
currencies = api.currencies()
for currency in currencies:
message = "{} ({}): ${} on {}".format(currency['name'],
currency['currency'],
currency['price'],
currency['price_timestamp'])
print(message)
Currency.create(
currency=currency['currency'],
name=currency['name'],
price=currency['price'],
date=currency['price_timestamp'],
price_1h_change=currency['1h']['price_change'],
price_1h_change_pct=currency['1h']['price_change_pct'],
price_1d_change=currency['1d']['price_change'],
price_1d_change_pct=currency['1d']['price_change_pct'],
price_30d_change=currency['30d']['price_change'],
price_30d_change_pct=currency['30d']['price_change_pct'])
def test_currency_relations(self):
currency = Currency('US Dollar', 'USD', "USA", "NMS", 1)
exchange = Exchange(
'National Market System', 'NMS', 'USD', 'USA', '19,223 billion')
location = location = Location(
'USA', 'US', 'Washington DC', '16.77 trillion USD', 'USD', 'National Market System')
db.session.add(currency)
db.session.add(exchange)
db.session.add(location)
db.session.commit()
# assert currency is on other models
self.assertEqual('NMS', str(currency.query.first().exchanges))
self.assertEqual('USA', str(currency.query.first().locations))
def test_exchange_relations(self):
currency = Currency('US Dollar', 'USD', "USA", "NMS", 1)
location = Location('USA', 'US', 'Washington DC',
'16.77 trillion USD', 'USD', 'National Market System')
exchange = Exchange(
'NMS', 'National Market System', 'USD', 'USA', '19,223 billion')
db.session.add(exchange)
db.session.add(currency)
db.session.add(location)
db.session.commit()
# assert it retuns correct data
self.assertEqual('USD', str(exchange.query.first().currency))
self.assertEqual('USA', str(exchange.query.first().location))
def post(self):
action = self.request.get('action', 'list')
if action == 'list':
self.sendTransactionList()
elif action == 'update':
# add a new or update a transaction
tkey = self.request.get('transaction', 'None')
if tkey == 'None':
transaction = Transaction()
transaction.project = self.project
else:
transaction = Transaction.get(tkey)
if transaction.project.key() != self.project.key():
raise Exception("Project/Transaction mismatch")
# update / set fields
transaction.date = datetime.strptime(self.request.get('date', transaction.date.isoformat()), "%Y-%m-%d")
transaction.source = Account.get(self.request.get('source', transaction.source and transaction.source.key()))
transaction.dest = Account.get(self.request.get('dest', transaction.dest and transaction.dest.key()))
transaction.ammount = float(self.request.get('ammount', str(transaction.ammount)).replace(',', '.'))
transaction.check = self.request.get('check', 'False') == 'True'
transaction.text = self.request.get('text', transaction.text)
transaction.user = self.user
# a None currency means we use the base currency!
c = self.request.get('currency', transaction.currency and transaction.currency.key())
transaction.currency = Currency.get(c) if c != "None" else None
# exchange source and dest, if the amount is negative
if transaction.ammount < 0:
tmp_src = transaction.source
transaction.source = transaction.dest
transaction.dest = tmp_src
transaction.ammount = -transaction.ammount
# put back into data store
transaction.put()
# retransmit all transactions
self.sendTransactionList()
elif action == 'delete':
# add a new or update a transaction
transaction = Transaction.get(self.request.get('transaction', 'None'))
if transaction.project.key() != self.project.key():
raise Exception("Project/Transaction mismatch")
transaction.delete()
# retransmit all transactions
self.sendTransactionList()
else:
raise Exception("Unknown action '%(action)s'!" % {'action':action})
def currency_update():
while True:
currency_response = requests.request("GET",
currency_url).json()['result']
for item in currency_response:
coin_pair = item['MarketName']
day_high = item['High']
day_low = item['Low']
volume = item['Volume']
last_price = item['Last']
base_volume = item['BaseVolume']
bid_price = item['Bid']
ask_price = item['Ask']
open_buy = item['OpenBuyOrders']
open_sell = item['OpenSellOrders']
prev_day = item['PrevDay']
currency = Currency.select().where(Currency.coin_pair == coin_pair)
if not currency:
Currency.create(coin_pair=coin_pair,
day_high=day_high,
day_low=day_low,
volume=volume,
last_price=last_price,
base_volume=base_volume,
bid_price=bid_price,
ask_price=ask_price,
open_buy=open_buy,
open_sell=open_sell,
prev_day=prev_day).save()
currency = Currency.select().where(
Currency.coin_pair == coin_pair).get()
market_update(currency)
elif currency:
Currency.update(day_high=day_high,
day_low=day_low,
volume=volume,
last_price=last_price,
base_volume=base_volume,
bid_price=bid_price,
ask_price=ask_price,
open_buy=open_buy,
open_sell=open_sell,
prev_day=prev_day).where(
Currency.coin_pair == coin_pair).execute()
print("Paused for 900 seconds")
time.sleep(900)
def run(parameter, debug=None):
if parameter == 'c':
#Get Currencies and register in table
response = requests.get("http://apilayer.net/api/list?access_key=" +
ACCESS_KEY + "&format=1")
objs = response.json()
print objs
for currency in objs["currencies"]:
stopGetValue = datetime.utcnow() if currency not in [
"BRL", "USD", "EUR", "ARS", "BTC"
] else None
auxCurrency = Currency(code=currency,
name=objs["currencies"][currency],
stopGetValue=stopGetValue)
if session.query(Currency).filter_by(
code=auxCurrency.code).first() == None:
session.add(auxCurrency)
if debug == None:
session.commit()
elif parameter == 'h':
#Get Historical Currency Values, 7 days.
end_date = datetime.today()
start_date = end_date - timedelta(days=7)
delta = end_date - start_date
for i in range(delta.days):
date = (start_date + timedelta(days=i)).strftime("%Y-%m-%d")
url = 'http://apilayer.net/api/historical?access_key=' + ACCESS_KEY + '&source=USD&format=1&date=' + date
addNewCurrencyValue(url, debug=debug)
elif parameter == 'k':
#Get Historical Currency Values, 180 days.
end_date = datetime.today()
start_date = end_date - timedelta(days=180)
delta = end_date - start_date
for i in range(delta.days):
date = (start_date + timedelta(days=i)).strftime("%Y-%m-%d")
url = 'http://apilayer.net/api/historical?access_key=' + ACCESS_KEY + '&source=USD&format=1&date=' + date
addNewCurrencyValue(url, debug=debug)
else:
url = 'http://apilayer.net/api/live?access_key=' + ACCESS_KEY + '&source=USD&format=1'
addNewCurrencyValue(url, debug=debug)
def test_company_relations(self):
currency = Currency('US Dollar', 'USD', "USA", "NMS", 1)
location = Location('USA', 'US', 'Washington DC',
'16.77 trillion USD', 'USD', 'National Market System')
exchange = Exchange(
'NMS', 'National Market System', 'USD', 'USA', '19,223 billion')
company = Company(
'CASS', 'Cass Information Systems, Inc', 'NMS', 'USD', 'USA', '51,29', '50.82',
'+2.42%', '59.09', '52.06', '2.07', '0.00', '51.20-52.22', '+4,24%', '+3.80%',
'22222', '27743', '585.15M')
db.session.add(exchange)
db.session.add(currency)
db.session.add(location)
db.session.add(company)
db.session.commit()
# assert it retuns correct data
self.assertEqual('USA', str(company.query.first().location))
self.assertEqual('NMS', str(company.query.first().exchange))
self.assertEqual('USD', str(company.query.first().currency))
from aiogram.types import ReplyKeyboardMarkup, KeyboardButton
from models import Stock, Currency
stocks_dict = {'Moscow Exchange': 'ME',
'NASDAQ': 'NSDQ'}
curr_dict = {'Рубль': 'RUB',
'Доллар': 'USD',
'Евро': 'EUR'}
stocks = [Stock(name, sym) for name, sym in stocks_dict.items()]
currencies = [Currency(curr, sym) for curr, sym in curr_dict.items()]
cancel_button = KeyboardButton('Cancel')
stock_kb = ReplyKeyboardMarkup([[stock.kb for stock in stocks], [cancel_button]], resize_keyboard=True)
currency_kb = ReplyKeyboardMarkup([[curr.kb for curr in currencies]], resize_keyboard=True)
paper_kb = ReplyKeyboardMarkup([['Add shares', 'Sell shares'], ['Sell all', 'Delete position']],
resize_keyboard=True)
cancel_kb = ReplyKeyboardMarkup([[cancel_button]], resize_keyboard=True)
def loans(*args, **kwargs):
if request.method == 'GET':
loans = Loan. \
where('closed', False). \
join(table=Currency.__table__,
one='{}.id'.format(Currency.__table__),
operator='=',
two='{}.currency'.format(Loan.__table__),
type='left outer'). \
group_by('{}.id'.format(Loan.__table__),
'{}.name'.format(Currency.__table__)). \
order_by_raw('created_at DESC NULLS LAST'). \
get(
[
'{}.*'.format(Loan.__table__),
'{}.name as currency_name'.format(Currency.__table__)
]
). \
serialize()
loans_sum = 0.0
for loan in loans:
value = loan['value']
if loan['currency_name'] != 'rub':
value = replace_value_with_rate(
value=value,
current_currency=loan['currency_name'],
target_currency='rub')
loans_sum += value
return app_response(data={'items': loans, 'sum': loans_sum})
elif request.method == 'POST':
body = request.json
value = body.get('value', 0.0)
value = float(value)
name = body.get('name', '')
currency = request.args.get('currency', None)
if currency is None:
currency = Currency.where('name', 'rub').first().id
user = kwargs.get('user_info')
description = body.get('description', None)
loan = Loan.create(name=name, value=value, currency=currency)
purchase = Purchase.create(name=name,
value=value,
currency=currency,
complete=True,
creator=user.id,
description=description,
loan=loan.id)
purchase = purchase.serialize()
purchase['currency_name'] = Currency.where('id', currency).first().name
purchase['loan_closed'] = False
replace_balance(value=float(value) * (-1), currency=currency)
if purchase['currency_name'] != 'rub':
value = replace_value_with_rate(
value=float(value),
current_currency=purchase['currency_name'],
target_currency='rub')
return app_response(data={'item': purchase, 'rub_value': value})
elif request.method == 'PUT':
body = request.json
loan_id = body.get('id', None)
value = body.get('value', 0.0)
value = float(value)
currency = request.args.get('currency', None)
if currency is None:
currency = Currency.where('name', 'rub').first().id
user = kwargs.get('user_info')
description = body.get('description', None)
closed = body.get('closed', False)
loan = Loan.where('id', loan_id).where('closed', False).first()
if loan:
purchase = False
if closed:
loan_pay_value = loan.value
loan.value = 0
loan.closed = True
else:
if currency is not None and loan.currency != currency:
body_currency = Currency.where('id', currency).first()
value = replace_value_with_rate(
value=float(value),
current_currency=body_currency.name,
target_currency=currency.name)
if value <= 0:
loan_pay_value = loan.value
loan.value = 0
loan.closed = True
elif value > loan.value:
loan_pay_value = value - loan.value
loan.value = value
purchase = True
else:
loan_pay_value = loan.value - value
loan.value = value
loan.save()
if purchase:
coming = Purchase.create(name=loan.name,
value=loan_pay_value,
currency=currency,
complete=True,
creator=user.id,
description=description,
loan=loan.id)
else:
coming = ComingIns.create(name=loan.name,
value=loan_pay_value,
currency=currency,
creator=user.id,
description=description)
coming = coming.serialize()
coming['currency_name'] = Currency.where('id',
currency).first().name
coming['loan_closed'] = loan.closed
if purchase:
replace_balance(value=float(loan_pay_value) * (-1),
currency=currency)
else:
replace_balance(value=float(loan_pay_value), currency=currency)
if coming['currency_name'] != 'rub':
loan_pay_value = replace_value_with_rate(
value=float(loan_pay_value),
current_currency=coming['currency_name'],
target_currency='rub')
return app_response(data={
'item': coming,
'rub_value': loan_pay_value
})
return app_response(data={})
def coming_ins(*args, **kwargs):
if request.method == 'GET':
return app_response(data={'items': ComingIns. \
join(table=Loan.__table__,
one='{}.id'.format(Loan.__table__),
operator='=',
two='{}.loan'.format(ComingIns.__table__),
type='left outer'). \
join(table=Currency.__table__,
one='{}.id'.format(Currency.__table__),
operator='=',
two='{}.currency'.format(ComingIns.__table__),
type='left outer'). \
group_by(
'{}.id'.format(ComingIns.__table__),
'{}.name'.format(Currency.__table__),
'{}.closed'.format(Loan.__table__),
). \
order_by_raw('{}.created_at DESC NULLS LAST'.format(ComingIns.__table__)). \
get([
'{}.*'.format(ComingIns.__table__),
'{}.name as currency_name'.format(Currency.__table__),
'{}.closed as loan_closed'.format(Loan.__table__),
]). \
serialize()})
elif request.method == 'POST':
body = request.json
value = body.get('value', 0.0)
value = float(value)
currency = body.get('currency', None)
if currency is None:
currency = Currency.where('name', 'rub').first().id
name = body.get('name', '')
description = body.get('description', None)
user = kwargs.get('user_info')
coming = ComingIns.create(name=name,
value=value,
currency=currency,
creator=user.id,
description=description)
coming = coming.serialize()
coming['currency_name'] = Currency.where('id', currency).first().name
coming['loan_closed'] = None
replace_balance(value=float(value), currency=currency)
return app_response(data={'item': coming})
elif request.method == 'PUT':
body = request.json
coming_id = body.get('id', None)
value = body.get('value', None)
if value is not None:
value = float(value)
currency = body.get('currency', None)
name = body.get('name', None)
description = body.get('description', None)
user = kwargs.get('user_info')
if coming_id:
coming = ComingIns.where('id', coming_id).first()
if coming:
balance_value = None
if value is not None:
balance_value = coming.value - value
coming.value = value
coming.currency = currency if currency is not None else coming.currency
coming.name = name if name is not None else coming.name
coming.description = description if description is not None else coming.description
coming.save()
coming = ComingIns. \
where('id', coming_id). \
join(table=Loan.__table__,
one='{}.id'.format(Loan.__table__),
operator='=',
two='{}.loan'.format(ComingIns.__table__),
type='left outer'). \
join(table=Currency.__table__,
one='{}.id'.format(Currency.__table__),
operator='=',
two='{}.currency'.format(Purchase.__table__),
type='left outer'). \
group_by(
'{}.id'.format(Purchase.__table__),
'{}.name'.format(Currency.__table__),
'{}.closed'.format(Loan.__table__),
). \
first([
'{}.*'.format(Purchase.__table__),
'{}.name as currency_name'.format(Currency.__table__),
'{}.closed as loan_closed'.format(Loan.__table__),
]). \
serialize()
if balance_value:
replace_balance(value=float(value) * (-1),
currency=currency)
return app_response(data={'item': coming})
return app_response(data={})
def create_currency(self, name, sign):
c = Currency()
c.name = name
c.sign = sign
c.save()
if __name__ == "__main__":
print('Updating database...')
config = config_load()
app = create_app()
with app.app_context():
# Get the current rate feed for USD
r = requests.get(url='http://www.floatrates.com/daily/usd.json')
data = r.json()
# Add USD to the database if it isn't there yet
currency = Currency.query.filter_by(code='USD').first()
if not currency:
new_currency = Currency(code='USD', usd_value=1)
db.session.add(new_currency)
db.session.commit()
for val in data.values():
code = val['code']
usd_value = float(val['inverseRate'])
# If the currency does not exist yet, create it
currency = Currency.query.filter_by(code=code).first()
if not currency:
new_currency = Currency(code=code, usd_value=usd_value)
db.session.add(new_currency)
# Otherwise, update its value
else:
class FinanceViewsTest(TestCase):
username = "******"
password = "******"
def setUp(self):
self.group, created = Group.objects.get_or_create(name='test')
self.user, created = DjangoUser.objects.get_or_create(username=self.username)
self.user.set_password(self.password)
self.user.save()
perspective, created = Perspective.objects.get_or_create(name='default')
perspective.set_default_user()
perspective.save()
ModuleSetting.set('default_perspective', perspective.id)
self.contact_type = ContactType(name='test')
self.contact_type.set_default_user()
self.contact_type.save()
self.contact = Contact(name='test', contact_type=self.contact_type)
self.contact.set_default_user()
self.contact.save()
self.category = Category(name='test')
self.category.set_default_user()
self.category.save()
self.equity = Equity(
issue_price=10, sell_price=10, issuer=self.contact, owner=self.contact)
self.equity.set_default_user()
self.equity.save()
self.asset = Asset(name='test', owner=self.contact)
self.asset.set_default_user()
self.asset.save()
self.tax = Tax(name='test', rate=10)
self.tax.set_default_user()
self.tax.save()
self.currency = Currency(code="GBP",
name="Pounds",
symbol="L",
is_default=True)
self.currency.set_default_user()
self.currency.save()
self.account = Account(
name='test', owner=self.contact, balance_currency=self.currency)
self.account.set_default_user()
self.account.save()
self.liability = Liability(name='test',
source=self.contact,
target=self.contact,
account=self.account,
value=10,
value_currency=self.currency)
self.liability.set_default_user()
self.liability.save()
self.transaction = Transaction(name='test', account=self.account, source=self.contact,
target=self.contact, value=10, value_currency=self.currency)
self.transaction.set_default_user()
self.transaction.save()
######################################
# Testing views when user is logged in
######################################
def test_finance_login(self):
"""Test index page with login at /finance/"""
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance'))
self.assertEquals(response.status_code, 200)
def test_finance_index_login(self):
"Test index page with login at /finance/index/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_index_transactions'))
self.assertEquals(response.status_code, 200)
def test_finance_income(self):
"Test index page with login at /finance/income/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_income_view'))
self.assertEquals(response.status_code, 200)
def test_finance_balance(self):
"Test index page with login at /finance/balance/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_balance_sheet'))
self.assertEquals(response.status_code, 200)
# Account
def test_finance_accounts_index(self):
"Test index page with login at /finance/accounts/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_index_accounts'))
self.assertEquals(response.status_code, 200)
def test_finance_account_add(self):
"Test index page with login at /finance/account/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_account_add'))
self.assertEquals(response.status_code, 200)
def test_finance_account_edit(self):
"Test index page with login at /finance/account/edit/<account_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_account_edit', args=[self.account.id]))
self.assertEquals(response.status_code, 200)
def test_finance_account_view(self):
"Test index page with login at /finance/account/view/<account_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_account_view', args=[self.account.id]))
self.assertEquals(response.status_code, 200)
def test_finance_account_delete(self):
"Test index page with login at /finance/account/delete/<account_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_account_delete', args=[self.account.id]))
self.assertEquals(response.status_code, 200)
# Asset
def test_finance_assets_index(self):
"Test index page with login at /finance/assets/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_index_assets'))
self.assertEquals(response.status_code, 200)
def test_finance_asset_add(self):
"Test index page with login at /finance/asset/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_asset_add'))
self.assertEquals(response.status_code, 200)
def test_finance_asset_edit(self):
"Test index page with login at /finance/asset/edit/<asset_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_asset_edit', args=[self.asset.id]))
self.assertEquals(response.status_code, 200)
def test_finance_asset_view(self):
"Test index page with login at /finance/asset/view/<asset_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_asset_view', args=[self.asset.id]))
self.assertEquals(response.status_code, 200)
def test_finance_asset_delete(self):
"Test index page with login at /finance/asset/delete/<asset_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_asset_delete', args=[self.asset.id]))
self.assertEquals(response.status_code, 200)
# Equity
def test_finance_equity_index(self):
"Test index page with login at /finance/equity/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_index_equities'))
self.assertEquals(response.status_code, 200)
def test_finance_equity_add(self):
"Test index page with login at /finance/equity/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_equity_add'))
self.assertEquals(response.status_code, 200)
def test_finance_equity_edit(self):
"Test index page with login at /finance/equity/edit/<equity_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_equity_edit', args=[self.equity.id]))
self.assertEquals(response.status_code, 200)
def test_finance_equity_view(self):
"Test index page with login at /finance/equity/view/<equity_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_equity_view', args=[self.equity.id]))
self.assertEquals(response.status_code, 200)
def test_finance_equity_delete(self):
"Test index page with login at /finance/equity/delete/<equity_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_equity_delete', args=[self.equity.id]))
self.assertEquals(response.status_code, 200)
# Transaction
def test_finance_transactions_index(self):
"Test index page with login at /finance/transaction/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_index_transactions'))
self.assertEquals(response.status_code, 200)
def test_finance_transaction_add(self):
"Test index page with login at /finance/transaction/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_transaction_add'))
self.assertEquals(response.status_code, 200)
def test_finance_transaction_add_liability(self):
"Test index page with login at /finance/transaction/add/liability/(?P<liability_id>\d+)"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_transaction_add', args=[self.liability.id]))
self.assertEquals(response.status_code, 200)
def test_finance_transaction_edit(self):
"Test index page with login at /finance/transaction/edit/<transaction_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_transaction_edit', args=[self.transaction.id]))
self.assertEquals(response.status_code, 200)
def test_finance_transaction_view(self):
"Test index page with login at /finance/transaction/view/<transaction_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_transaction_view', args=[self.transaction.id]))
self.assertEquals(response.status_code, 200)
def test_finance_transaction_delete(self):
"Test index page with login at /finance/transaction/delete/<transaction_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_transaction_delete', args=[self.transaction.id]))
self.assertEquals(response.status_code, 200)
# Liability
def test_finance_liability_index(self):
"Test index page with login at /finance/liability/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_index_liabilities'))
self.assertEquals(response.status_code, 200)
def test_finance_liability_add(self):
"Test index page with login at /finance/liability/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_liability_add'))
self.assertEquals(response.status_code, 200)
def test_finance_liability_edit(self):
"Test index page with login at /finance/liability/edit/<liability_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_liability_edit', args=[self.liability.id]))
self.assertEquals(response.status_code, 200)
def test_finance_liability_view(self):
"Test index page with login at /finance/liability/view/<liability_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_liability_view', args=[self.liability.id]))
self.assertEquals(response.status_code, 200)
def test_finance_liability_delete(self):
"Test index page with login at /finance/liability/delete/<liability_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_liability_delete', args=[self.liability.id]))
self.assertEquals(response.status_code, 200)
# Receivables
def test_finance_receivables_index(self):
"Test index page with login at /finance/receivables/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_index_receivables'))
self.assertEquals(response.status_code, 200)
def test_finance_receivable_add(self):
"Test index page with login at /finance/receivable/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_receivable_add'))
self.assertEquals(response.status_code, 200)
def test_finance_receivable_edit(self):
"Test index page with login at /finance/receivable/edit/<receivable_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_receivable_edit', args=[self.liability.id]))
self.assertEquals(response.status_code, 200)
def test_finance_receivable_view(self):
"Test index page with login at /finance/receivable/view/<receivable_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_receivable_view', args=[self.liability.id]))
self.assertEquals(response.status_code, 200)
def test_finance_receivable_delete(self):
"Test index page with login at /finance/liability/delete/<receivable_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_receivable_delete', args=[self.liability.id]))
self.assertEquals(response.status_code, 200)
# Category
def test_finance_category_add(self):
"Test index page with login at /finance/category/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_category_add'))
self.assertEquals(response.status_code, 200)
def test_finance_category_edit(self):
"Test index page with login at /finance/category/edit/<category_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_category_edit', args=[self.category.id]))
self.assertEquals(response.status_code, 200)
def test_finance_category_view(self):
"Test index page with login at /finance/category/view/<category_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_category_view', args=[self.category.id]))
self.assertEquals(response.status_code, 200)
def test_finance_category_delete(self):
"Test index page with login at /finance/category/delete/<category_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_category_delete', args=[self.category.id]))
self.assertEquals(response.status_code, 200)
# Currency
def test_finance_currency_add(self):
"Test index page with login at /finance/currency/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_currency_add'))
self.assertEquals(response.status_code, 200)
def test_finance_currency_edit(self):
"Test index page with login at /finance/currency/edit/<currency_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_currency_edit', args=[self.currency.id]))
self.assertEquals(response.status_code, 200)
def test_finance_currency_view(self):
"Test index page with login at /finance/currency/view/<currency_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_currency_view', args=[self.currency.id]))
self.assertEquals(response.status_code, 200)
def test_finance_currency_delete(self):
"Test index page with login at /finance/currency/delete/<currency_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_currency_delete', args=[self.currency.id]))
self.assertEquals(response.status_code, 200)
# Taxes
def test_finance_tax_add(self):
"Test index page with login at /finance/tax/add/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_tax_add'))
self.assertEquals(response.status_code, 200)
def test_finance_tax_edit(self):
"Test index page with login at /finance/tax/edit/<tax_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_tax_edit', args=[self.tax.id]))
self.assertEquals(response.status_code, 200)
def test_finance_tax_view(self):
"Test index page with login at /finance/tax/view/<tax_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_tax_view', args=[self.tax.id]))
self.assertEquals(response.status_code, 200)
def test_finance_tax_delete(self):
"Test index page with login at /finance/tax/delete/<tax_id>"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(
reverse('finance_tax_delete', args=[self.tax.id]))
self.assertEquals(response.status_code, 200)
# Settings
def test_finance_settings_view(self):
"Test index page with login at /finance/settings/view/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_settings_view'))
self.assertEquals(response.status_code, 200)
def test_finance_settings_edit(self):
"Test index page with login at /finance/settings/edit/"
response = self.client.post('/accounts/login',
{'username': self.username, 'password': self.password})
self.assertRedirects(response, '/')
response = self.client.get(reverse('finance_settings_edit'))
self.assertEquals(response.status_code, 200)
######################################
# Testing views when user is not logged in
######################################
def test_index(self):
"Test index page at /finance/"
response = self.client.get('/finance/')
# Redirects as unauthenticated
self.assertRedirects(response, reverse('user_login'))
def test_finance_index_out(self):
"Testing /finance/index/"
response = self.client.get(reverse('finance_index_transactions'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_income_out(self):
"Testing /finance/income/"
response = self.client.get(reverse('finance_income_view'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_balance_out(self):
"Testing /finance/balance/"
response = self.client.get(reverse('finance_balance_sheet'))
self.assertRedirects(response, reverse('user_login'))
# Account
def test_finance_accounts_index_out(self):
"Testing /finance/accounts/"
response = self.client.get(reverse('finance_index_accounts'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_account_add_out(self):
"Testing /finance/account/add/"
response = self.client.get(reverse('finance_account_add'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_account_edit_out(self):
"Testing /finance/account/edit/<account_id>"
response = self.client.get(
reverse('finance_account_edit', args=[self.account.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_account_view_out(self):
"Testing /finance/account/view/<account_id>"
response = self.client.get(
reverse('finance_account_view', args=[self.account.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_account_delete_out(self):
"Testing /finance/account/delete/<account_id>"
response = self.client.get(
reverse('finance_account_delete', args=[self.account.id]))
self.assertRedirects(response, reverse('user_login'))
# Asset
def test_finance_assets_index_out(self):
"Testing /finance/assets/"
response = self.client.get(reverse('finance_index_assets'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_asset_add_out(self):
"Testing /finance/asset/add/"
response = self.client.get(reverse('finance_asset_add'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_asset_edit_out(self):
"Testing /finance/asset/edit/<asset_id>"
response = self.client.get(
reverse('finance_asset_edit', args=[self.asset.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_asset_view_out(self):
"Testing /finance/asset/view/<asset_id>"
response = self.client.get(
reverse('finance_asset_view', args=[self.asset.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_asset_delete_out(self):
"Testing /finance/asset/delete/<asset_id>"
response = self.client.get(
reverse('finance_asset_delete', args=[self.asset.id]))
self.assertRedirects(response, reverse('user_login'))
# Equity
def test_finance_equity_index_out(self):
"Testing /finance/equity/"
response = self.client.get(reverse('finance_index_equities'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_equity_add_out(self):
"Testing /finance/equity/add/"
response = self.client.get(reverse('finance_equity_add'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_equity_edit_out(self):
"Tesing /finance/equity/edit/<equity_id>"
response = self.client.get(
reverse('finance_equity_edit', args=[self.equity.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_equity_view_out(self):
"Testing /finance/equity/view/<equity_id>"
response = self.client.get(
reverse('finance_equity_view', args=[self.equity.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_equity_delete_out(self):
"Testing /finance/equity/delete/<equity_id>"
response = self.client.get(
reverse('finance_equity_delete', args=[self.equity.id]))
self.assertRedirects(response, reverse('user_login'))
# Transaction
def test_finance_transactions_index_out(self):
"Testing /finance/transaction/"
response = self.client.get(reverse('finance_index_transactions'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_transaction_add_out(self):
"Testing /finance/transaction/add/"
response = self.client.get(reverse('finance_transaction_add'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_transaction_add_liability_out(self):
"Testing /finance/transaction/add/liability/(?P<liability_id>\d+)"
response = self.client.get(
reverse('finance_transaction_add', args=[self.liability.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_transaction_edit_out(self):
"Testing /finance/transaction/edit/<transaction_id>"
response = self.client.get(
reverse('finance_transaction_edit', args=[self.transaction.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_transaction_view_out(self):
"Testing /finance/transaction/view/<transaction_id>"
response = self.client.get(
reverse('finance_transaction_view', args=[self.transaction.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_transaction_delete_out(self):
"Testing /finance/transaction/delete/<transaction_id>"
response = self.client.get(
reverse('finance_transaction_delete', args=[self.transaction.id]))
self.assertRedirects(response, reverse('user_login'))
# Liability
def test_finance_liability_index_out(self):
"Testing /finance/liability/"
response = self.client.get(reverse('finance_index_liabilities'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_liability_add_out(self):
"Testing /finance/liability/add/"
response = self.client.get(reverse('finance_liability_add'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_liability_edit_out(self):
"Testing /finance/liability/edit/<liability_id>"
response = self.client.get(
reverse('finance_liability_edit', args=[self.liability.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_liability_view_out(self):
"Testing /finance/liability/view/<liability_id>"
response = self.client.get(
reverse('finance_liability_view', args=[self.liability.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_liability_delete_out(self):
"Testing /finance/liability/delete/<liability_id>"
response = self.client.get(
reverse('finance_liability_delete', args=[self.liability.id]))
self.assertRedirects(response, reverse('user_login'))
# Receivables
def test_finance_receivables_index_out(self):
"Testing /finance/receivables/"
response = self.client.get(reverse('finance_index_receivables'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_receivable_add_out(self):
"Testing /finance/receivable/add/"
response = self.client.get(reverse('finance_receivable_add'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_receivable_edit_out(self):
"Testing /finance/receivable/edit/<receivable_id>"
response = self.client.get(
reverse('finance_receivable_edit', args=[self.liability.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_receivable_view_out(self):
"Testing /finance/receivable/view/<receivable_id>"
response = self.client.get(
reverse('finance_receivable_view', args=[self.liability.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_receivable_delete_out(self):
"Testing /finance/liability/delete/<receivable_id>"
response = self.client.get(
reverse('finance_receivable_delete', args=[self.liability.id]))
self.assertRedirects(response, reverse('user_login'))
# Category
def test_finance_category_add_out(self):
"Testing /finance/category/add/"
response = self.client.get(reverse('finance_category_add'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_category_edit_out(self):
"Testing /finance/category/edit/<category_id>"
response = self.client.get(
reverse('finance_category_edit', args=[self.category.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_category_view_out(self):
"Testing /finance/category/view/<category_id>"
response = self.client.get(
reverse('finance_category_view', args=[self.category.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_category_delete_out(self):
"Testing /finance/category/delete/<category_id>"
response = self.client.get(
reverse('finance_category_delete', args=[self.category.id]))
self.assertRedirects(response, reverse('user_login'))
# Currency
def test_finance_currency_add_out(self):
"Testing /finance/currency/add/"
response = self.client.get(reverse('finance_currency_add'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_currency_edit_out(self):
"Testing /finance/currency/edit/<currency_id>"
response = self.client.get(
reverse('finance_currency_edit', args=[self.currency.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_currency_view_out(self):
"Testing /finance/currency/view/<currency_id>"
response = self.client.get(
reverse('finance_currency_view', args=[self.currency.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_currency_delete_out(self):
"Testing /finance/currency/delete/<currency_id>"
response = self.client.get(
reverse('finance_currency_delete', args=[self.currency.id]))
self.assertRedirects(response, reverse('user_login'))
# Taxes
def test_finance_tax_add_out(self):
"Testing /finance/tax/add/"
response = self.client.get(reverse('finance_tax_add'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_tax_edit_out(self):
"Testing /finance/tax/edit/<tax_id>"
response = self.client.get(
reverse('finance_tax_edit', args=[self.tax.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_tax_view_out(self):
"Testing /finance/tax/view/<tax_id>"
response = self.client.get(
reverse('finance_tax_view', args=[self.tax.id]))
self.assertRedirects(response, reverse('user_login'))
def test_finance_tax_delete_out(self):
"Testing /finance/tax/delete/<tax_id>"
response = self.client.get(
reverse('finance_tax_delete', args=[self.tax.id]))
self.assertRedirects(response, reverse('user_login'))
# Settings
def test_finance_settings_view_out(self):
"Testing /finance/settings/view/"
response = self.client.get(reverse('finance_settings_view'))
self.assertRedirects(response, reverse('user_login'))
def test_finance_settings_edit_out(self):
"Testing /finance/settings/edit/"
response = self.client.get(reverse('finance_settings_edit'))
self.assertRedirects(response, reverse('user_login'))
def currency_list(*args, **kwargs):
return app_response(data={'items': Currency.get().serialize()})
