def showAccountsTable(client):
total = ClientAccount.getTotalScoreByClient(client=client)
context = {
'client': client,
'total': total,
'show_action_btn': True,
}
return render_to_string('client/profile_accounts_list.html', context)
def showAccountsTable(request):
# Get the user object
client = request.user
if (client is None) or (not client.hasRole('ROLE_CLIENT')):
return JsonResponse({
'status': 'error',
'message': 'Client does not exist.',
})
total = ClientAccount.getTotalScoreByClient(client=client)
print(total)
context = {
'client': client,
'total': total,
'show_action_btn': True,
}
return render(request, 'client/profile_accounts_list.html', context)
def checkAccountsSum(request):
if (not request.is_ajax()):
raise Http404()
# Get the user object
client = request.user
ria = client.profile.ria_user
riaMinAssetSize = ria.riacompanyinformation.min_asset_size
total = ClientAccount.getTotalScoreByClient(client=client)
if riaMinAssetSize > total['value']:
message = 'You must invest at least $' + '{0:.2f}'.format(
riaMinAssetSize) + ' with us.'
return JsonResponse({
'status': 'error',
'message': message,
})
return JsonResponse({
'status': 'success',
})
def account_type_text(acc_type):
return ClientAccount.get_account_type_text(acc_type)
def createAccount(request, group):
if (request.method != 'POST') or (not request.is_ajax()):
raise Http404("Page not found.")
# Get the user object
client = request.user
if (client is None) or (not client.hasRole('ROLE_CLIENT')):
return JsonResponse({
'status': 'error',
'message': 'Client does not exist.',
})
# Check account group is valid or not
allowedGroups = AccountGroup.getGroupChoices()
if (group, group) not in allowedGroups:
return HttpResponseBadRequest('Invalid group type')
groupTypeId = None
groupType = None
clientAccount = ClientAccount(value=0, is_pre_saved=False)
if (group == AccountGroup.GROUP_DEPOSIT_MONEY) or (
group == AccountGroup.GROUP_FINANCIAL_INSTITUTION):
groupType = getAccountGroupType(session=request.session)
clientAccount.groupType = groupType
# print("Checkpoint 0: groupType is")
# print(groupType)
if request.method == 'POST':
# print("Checkpoint 1a: Enter into request.method POST")
###############
# Pre-process form data before validation
###############
print("createAccount: ", request.POST)
post = request.POST.copy()
post['value'] = float(post['value'].replace(',', ''))
post['groupType'] = groupType.pk
request.POST = post
# print(request.POST.get('value'))
form = TypedClientAccountForm(request.POST,
user=client,
group=group,
groupType=groupType)
if form.is_valid():
# print("Checkpoint 2a: Successfully validate the form")
clientAccount = form.save(commit=False)
clientAccount.client = client
clientAccount.is_pre_saved = False
clientAccount.save()
removeAccountGroup(session=request.session)
removeAccountType(session=request.session)
removeAccountGroupType(session=request.session)
removeAccountOwners(session=request.session)
if group == 'employer_retirement':
responseData = processEmployerRetirementAccountForm(
clientAccount)
else:
responseData = processAccountForm(request=request)
# Check if the group type is deposit and how many accounts the client has applied
isType = (clientAccount.groupType.group.name ==
AccountGroup.GROUP_DEPOSIT_MONEY)
systemAccounts = SystemAccount.objects.filter(
client=client, type=clientAccount.system_type)
responseData['in_right_box'] = False if (
isType or (systemAccounts.count() < 1)) else True
responseData['transfer_url'] = reverse(
'rx_client_dashboard_select_system_account',
kwargs={'account_id': clientAccount.pk},
)
removeIsConsolidateAccount(session=request.session)
removeAccountStep(session=request.session)
return JsonResponse(responseData)
else:
print('Checkpoint 2b: Form is not valid')
print(form.errors)
print(form.non_field_errors)
else:
# print("Checkpoint 1b: Cannot enter into request.method POST")
form = TypedClientAccountForm(user=client,
group=group,
groupType=groupType)
message = getTitleMessageForAccountForm(session=request.session,
group=group,
groupType=groupType)
template = loader.get_template('client/profile_client_accounts_form.html')
context = {
'form': form,
'group': group,
'hide_submit_button': True,
'title_message': message,
}
content = template.render(context, request)
data = {
'status': 'error',
'content': content,
}
return JsonResponse(data)
def get_account_balance_chart(plan, has_partner):
try:
p = plan.projection
base_idx = 0
last_idx = plan.selected_life_expectancy - plan.client.age - 1
max_limit = 0
sum_value = [0] * (last_idx - base_idx + 1)
if p.list_of_account_balances is not None:
list_of_account_balances = list(
filter(lambda item: item['data'] is not None,
p.list_of_account_balances))
else:
list_of_account_balances = []
if has_partner:
part_list_of_account_balances = list(
filter(lambda item: item['data'] is not None,
p.part_list_of_account_balances))
for idx in range(base_idx, last_idx):
for acc in list_of_account_balances:
sum_value[idx] += value_at(acc['data'], idx)
if has_partner:
for acc in part_list_of_account_balances:
sum_value[idx] += value_at(acc['data'], idx)
max_limit = max(sum_value)
colors = get_random_colors(len(list_of_account_balances))
legends = list(
map(
lambda item: ClientAccount.get_account_type_text(item[
'account_type']), list_of_account_balances))
if has_partner:
partner_colors = get_random_colors(
len(part_list_of_account_balances))
partner_legends = list(
map(
lambda item: 'Partner ' + ClientAccount.
get_account_type_text(item['account_type']),
part_list_of_account_balances))
colors += partner_colors
legends += partner_legends
partner_age = int(tax_helpers.get_age(plan.partner_data['dob']))
values = []
if max_limit > 0:
y_interval_0 = max_limit / 10
y_interval = pow(10, np.floor(np.log10(y_interval_0)))
y_interval = y_interval * 5 if y_interval_0 < y_interval * 5 else y_interval * 10
max_limit = int(np.ceil(max_limit / y_interval) * y_interval)
else:
y_interval = 1
max_limit = 1
y_axis = range(0, max_limit + 1, int(y_interval))
y_axis = list(reversed(list(y_axis)))
y_height = y_interval / max_limit * 100
x_num = last_idx - base_idx
x_interval = min(40, 560 / x_num)
x_width = x_interval * x_num + 42
for idx in range(base_idx, last_idx):
y_values = []
for acc in list_of_account_balances:
y_values.append(value_at(acc['data'], idx) / max_limit * 100)
x_label = str(plan.client.age + 1 + idx)
if has_partner:
for acc in part_list_of_account_balances:
y_values.append(
value_at(acc['data'], idx) / max_limit * 100)
x_label += ' / ' + str(partner_age + 1 + idx)
values += [{
'x_label': x_label,
'y_values': y_values,
'y_offset': 100 - sum(y_values)
}]
return {
'values': values,
'colors': colors,
'legends': legends,
'y_axis': list(y_axis),
'y_height': y_height,
'x_interval': x_interval,
'x_width': x_width
}
except ObjectDoesNotExist:
return None
def index(request):
print("-----http-----",request.__dict__)
clientPortfolioManager = ClientPortfolioManager()
# Get the user object
email = Email.objects.last().email
client = get_object_or_404(User, email=email)
ria = client.profile.ria_user
# Get client's portfolio
clientPortfolio = clientPortfolioManager.getCurrentPortfolio(client=client)
if clientPortfolio is None:
clientPortfolio = clientPortfolioManager.getActivePortfolio(client=client)
if clientPortfolio is None:
raise Http404()
companyInformation = ria.riacompanyinformation
portfolio = clientPortfolio.portfolio
isQualified = manageQualified(
session=request.session,
companyInformation=companyInformation,
isQualified=request.GET.get('is_qualified')
)
isFinal = False
# If client has final portfolio
if clientPortfolio.isAdvisorApproved():
isFinal = True
if client.profile.registration_step < 4:
profile = client.profile
profile.registration_step = 4
profile.save()
elif clientPortfolio.isProposed():
existWorkflow = None # Skip implementing workflow at this moment
portfolioInformationManager = PortfolioInformationManager()
clientAccounts = ClientAccount.objects.filter(client=client)
retirementAccounts = ClientAccount.objects.filter(client=client, groupType__group__name=AccountGroup.GROUP_EMPLOYER_RETIREMENT)
form = PortfolioForm()
# Skip document at this moment
documents = {
'ria_investment_management_agreement': '#',
}
portfolio_information = portfolioInformationManager.getPortfolioInformation(user=client, model=portfolio, isQualified=isQualified)
client.appointedBillingSpec.calcFeeTier()
data = {
'is_final': isFinal,
'client': client,
'client_accounts': clientAccounts,
'total': ClientAccount.getTotalScoreByClient(client=client),
'ria_company_information': companyInformation,
'has_retirement_account': True if retirementAccounts.exists() else False,
'portfolio_information': portfolio_information,
'show_sas_cash': containsSasCash(clientAccounts),
'is_use_qualified_models': companyInformation.is_use_qualified_models,
'form': form,
'signing_date': datetime.now(),
'documents': documents,
'action': 'client_portfolio',
}
return render(request, 'client/portfolio_index.html', data)
def suggestedPortfolio(request, client_id, client_view=0):
clientPortfolioManager = ClientPortfolioManager()
# Get the ria and client objects
ria = request.user
client = get_object_or_404(User, pk=client_id)
clientPortfolio = clientPortfolioManager.getActivePortfolio(client=client)
if clientPortfolio is None:
raise Http404("This client does not have suggested portfolio.")
# Skip implementing mailer at this moment
portfolio = clientPortfolio.portfolio
if request.method == 'POST':
settingsForm = SuggestedPortfolioForm(request.POST,
instance=client.profile,
clientPortfolio=clientPortfolio)
if settingsForm.is_valid():
portfolio = settingsForm.save(commit=False)
else:
settingsForm = SuggestedPortfolioForm(instance=client.profile,
clientPortfolio=clientPortfolio)
companyInformation = ria.riacompanyinformation
isUseQualified = companyInformation.isUseQualifiedModels()
isQualified = False
if isUseQualified:
# Skip implementing isQualified setting logic at this moment
pass
form = RiaClientAccountForm(client=client)
clientAccounts = ClientAccount.findConsolidatedAccountsByClient(
client=client)
portfolioInformationManager = PortfolioInformationManager()
portfolio_information = portfolioInformationManager.getPortfolioInformation(
user=client, model=portfolio, isQualified=isQualified)
client.appointedBillingSpec.calcFeeTier()
if bool(client_view):
parent_template = 'ria/clear_layout.html'
else:
parent_template = 'ria/dashboard_index.html'
context = {
'is_client_view': bool(client_view),
'user': ria,
'form': form,
'total': ClientAccount.getTotalScoreByClient(client=client),
'client': client,
'client_accounts': clientAccounts,
'settings_form': settingsForm,
'client_answers':
ClientQuestionnaireAnswer.objects.filter(client=client),
'has_retirement_account':
ClientAccount.hasRetirementAccount(client=client),
'ria_company_information': ria.riacompanyinformation,
'client_has_final_portfolio': clientPortfolio.isAdvisorApproved(),
'portfolio_information': portfolio_information,
'is_use_qualified_models': isUseQualified,
'action': 'ria_suggested_portfolio',
'billing_spec': client.appointedBillingSpec,
'parent_template': parent_template,
}
return render(request, 'ria/prospects_suggested_portfolio.html', context)