def allocation(request, portfolio, is_sample, read_only):
refresh_positions(portfolio)
positions = latest_positions(portfolio)
_decorate_positions_for_display(positions, False)
context = {
'positions': positions,
'current_tab' : 'allocation',
}
return render_page('allocation.html', request, portfolio = portfolio, extra_dictionary = context)
def income(request, portfolio, is_sample, read_only):
transactions = Transaction.objects.filter(portfolio__id__exact = portfolio.id).order_by('-as_of_date', '-id')
refresh_positions(portfolio, transactions)
positions = latest_positions(portfolio)
_decorate_positions_for_display(positions, request.GET.get("showClosedPositions", False))
summary_map = {}
for position in positions:
summary_map[position.symbol] = IncomeSummary(position.symbol, position.market_value, position.cost_basis, position.pl, position.pl_percent, position.realized_pl, position.show)
total_summary = IncomeSummary('*TOTAL*', 0.0, 0.0, 0.0, 0.0, 0.0, True)
for transaction in transactions:
if transaction.type != 'ADJUST':
continue
symbol = transaction.linked_symbol
if symbol == None or symbol == '':
symbol = transaction.symbol
summary = summary_map.get(symbol)
summary.add_income(transaction.as_of_date, transaction.total)
if summary.show:
total_summary.add_income(transaction.as_of_date, transaction.total)
summaries = sorted(summary_map.values(), key = (lambda summary: summary.symbol))
for summary in summaries:
total_summary.market_value = total_summary.market_value + summary.market_value
total_summary.cost_basis = total_summary.cost_basis + summary.cost_basis
total_summary.unrealized_pl = total_summary.unrealized_pl + summary.unrealized_pl
total_summary.realized_pl = total_summary.realized_pl + summary.realized_pl
total_summary.unrealized_pl_percent = ((total_summary.market_value / total_summary.cost_basis) - 1) * 100
context = {
'read_only' : read_only,
'summaries': summaries,
'total_summary' : total_summary,
'current_tab' : 'income',
}
return render_page('income.html', request, portfolio = portfolio, extra_dictionary = context)
def transactions(request, portfolio, is_sample, read_only):
transactions = Transaction.objects.filter(portfolio__id__exact = portfolio.id).order_by('-as_of_date', '-id')
symbols = set([t.symbol for t in transactions])
symbol_filter = request.GET.get('filter')
if symbol_filter != None and symbol_filter != '':
transactions = transactions.filter(symbol = symbol_filter)
for transaction in transactions:
transaction.fees = abs(transaction.total - (transaction.price * transaction.quantity))
context = {
'symbols' : symbols.difference([CASH_SYMBOL]),
'transaction_sets' : [ transactions[0:TRANSACTIONS_BEFORE_SEE_ALL], transactions[TRANSACTIONS_BEFORE_SEE_ALL:transactions.count()] ],
'current_tab' : 'transactions',
'symbol_filter' : symbol_filter,
}
return render_page('transactions.html', request, portfolio = portfolio, extra_dictionary = context)
def positions(request, portfolio, is_sample, read_only):
transactions = Transaction.objects.filter(portfolio__id__exact = portfolio.id).order_by('-as_of_date', '-id')
refresh_positions(portfolio, transactions)
positions = latest_positions(portfolio)
_decorate_positions_for_display(positions, request.GET.get("showClosedPositions", False))
_decorate_positions_with_lots(positions)
summary = _get_summary(positions, transactions)
performance_history = _get_performance_history(portfolio, DAYS_IN_PERFORMANCE_HISTORY)
context = {
'read_only' : read_only,
'is_sample' : is_sample,
'positions': positions,
'summary' : summary,
'current_tab' : 'positions',
'performance_history' : performance_history,
'benchmark_symbol' : PERFORMANCE_BENCHMARK_SYMBOL,
}
return render_page('positions.html', request, portfolio = portfolio, extra_dictionary = context)
def import_form(request, portfolio, is_sample, read_only):
transactions = None
auto_detect_error = False
if request.method == 'POST':
form = ImportForm(request.POST, request.FILES)
if form.is_valid():
type = request.POST.get('type')
if type == 'AUTO':
type = detect_transaction_file_type(request.FILES['file'])
auto_detect_error = (True if type == None else False);
if not auto_detect_error:
transactions = parse_transactions(type, request.FILES['file'])
existing_transactions = Transaction.objects.filter(portfolio__id__exact = portfolio.id)
by_date_map = dict([ (as_of_date, []) for as_of_date in set([ transaction.as_of_date for transaction in existing_transactions]) ])
for transaction in existing_transactions:
by_date_map.get(transaction.as_of_date).append(transaction)
for transaction in transactions:
if len(transaction.symbol) < 1 or len(transaction.symbol) > 10:
raise Exception("Invalid symbol: %s" % transaction.symbol)
is_duplicate = False
possibles = by_date_map.get(transaction.as_of_date)
if possibles != None:
for possible in possibles:
if possible.type == transaction.type and possible.symbol == transaction.symbol and abs(possible.quantity - transaction.quantity) < 0.01 and abs(possible.price - transaction.price) < 0.01:
is_duplicate = True
transaction.is_duplicate = is_duplicate
context = {
'transactions' : transactions,
'current_tab' : 'transactions',
'auto_detect_error' : auto_detect_error
}
return render_page('importTransactions.html', request, portfolio = portfolio, extra_dictionary = context)
def account(request, user):
return render_page('account.html', request)
