File: //home/arjun/projects/buyercall_forms/buyercall/buyercall/blueprints/admin/views.py
import logging as log
import traceback
from flask import (
Blueprint,
current_app,
redirect,
request,
flash,
url_for,
jsonify,
render_template)
from flask_login import login_required, current_user
from flask_babel import gettext as _
from sqlalchemy import and_
from sqlalchemy.sql import text
from stripe.error import InvalidRequestError
from buyercall.blueprints.activity.models import ActivityType, ActivityName, ActivityLogs
from buyercall.blueprints.admin.templates.admin.utils.add_user import CreateUserUtils
from buyercall.blueprints.filters import format_phone_number
from buyercall.lib.util_crypto import AESCipher
from buyercall.blueprints.admin.models import Dashboard
from buyercall.blueprints.user.decorators import role_required
from buyercall.blueprints.agents.models import Agent
from buyercall.blueprints.user.models import User, UserExternalApiAutoPostTie
from buyercall.blueprints.issue.models import Issue
from buyercall.blueprints.partnership.models import Partnership
from buyercall.blueprints.billing.decorators import handle_stripe_exceptions
from buyercall.blueprints.billing.models.coupon import Coupon
from buyercall.blueprints.billing.models.subscription import Subscription
from buyercall.blueprints.partnership.models import PartnershipAccountCreditTie, \
PartnershipAccount, ExternalApiServiceProvidersPartnershipAccountTie, ExternalApiServiceProviders
from buyercall.blueprints.admin.forms import SearchForm, BulkDeleteForm, \
UserForm, UserCancelSubscriptionForm, IssueForm, IssueContactForm, \
CouponForm, SevenHundredCreditForm, SevenHundredPrequalifyForm, FinservPrequalifyForm, \
AMSEvolutionForm, NeoVerifyForm, AmsAnalyticsForm, AmsPrequalifyForm, AddUserForm
from buyercall.blueprints.reports.models import Report, ReportUserTie
from buyercall.extensions import db
from buyercall.extensions import csrf
from datatables import DataTables, ColumnDT
admin = Blueprint('admin', __name__,
template_folder='templates', url_prefix='/admin')
@admin.before_request
@login_required
@role_required('admin', 'partner', 'sysadmin', 'limitsysadmin')
def before_request():
""" We are protecting all of our admin endpoints. """
pass
# Dashboard -------------------------------------------------------------------
@admin.route('')
def dashboard():
filter_exp = text('1 = 1')
partnership_account_id = current_user.partnership_account_id
partnership_account_group_viewing = current_user.is_viewing_partnership
# Check if being viewed by super partner
if partnership_account_group_viewing:
partnership_account_id = current_user.get_user_viewing_partnership_account_id
if current_user.role == 'partner':
filter_exp = User.partnership_id == partnership_account_id
if current_user.role == 'admin':
filter_exp = and_(User.partnership_account_id == partnership_account_id,
User.role.notin_(['sysadmin', 'limitsysadmin', 'partner']))
group_and_count_plans = Dashboard.group_and_count_plans(current_user) \
if current_user.role in ['sysadmin', 'limitsysadmin', 'partner'] else {'query': list(), 'total': 0}
group_and_count_coupons = Dashboard.group_and_count_coupons() if current_user.role == 'sysadmin' else 0
group_and_count_users = Dashboard.group_and_count(User, User.role, filter_exp)
group_and_count_issues = Dashboard.group_and_count_issues(current_user)
# if current_user.role == 'partner':
# partner_minutes = Lead.query(func.sum(Lead.duration).label("pr_total_minutes").filter(User.partnership)
return render_template('admin/page/dashboard.jinja2',
group_and_count_plans=group_and_count_plans,
group_and_count_coupons=group_and_count_coupons,
group_and_count_users=group_and_count_users,
group_and_count_issues=group_and_count_issues)
# Users -----------------------------------------------------------------------
@admin.route('/users', defaults={'page': 1})
@admin.route('/users/page/<int:page>')
@role_required('admin')
def users(page):
search_form = SearchForm()
bulk_form = BulkDeleteForm()
partnership_account_id = current_user.partnership_account_id
partnership_account_group_viewing = current_user.is_viewing_partnership
# Check if being viewed by super partner
if partnership_account_group_viewing:
partnership_account_id = current_user.get_user_viewing_partnership_account_id
sort_by = User.sort_by(request.args.get('sort', 'name'),
request.args.get('direction', 'asc'))
order_values = '{0} {1}'.format(sort_by[0], sort_by[1])
paginated_users = User.query \
.filter(User.partnership_account_id == partnership_account_id, User.partnership_id != None) \
.filter(User.is_deactivated.is_(False)) \
.filter(User.search(request.args.get('q', ''))) \
.order_by(User.role.desc(), text(order_values)) \
.paginate(page, 20, True)
return render_template('admin/user/index.jinja2',
form=search_form, bulk_form=bulk_form,
users=paginated_users)
# return user data into jquery datatables
@admin.route('/user-data')
@csrf.exempt
@login_required
@role_required('admin')
def data():
partnership_account_id = current_user.partnership_account_id
partnership_account_group_viewing = current_user.is_viewing_partnership
# Check if being viewed by super partner
if partnership_account_group_viewing:
partnership_account_id = current_user.get_user_viewing_partnership_account_id
"""Return server side data."""
# defining columns
columns = [
ColumnDT(User.id),
ColumnDT(User.firstname),
ColumnDT(User.lastname),
ColumnDT(User.email),
ColumnDT(User.phonenumber),
ColumnDT(User.last_sign_in_on),
ColumnDT(User.sign_in_count)
]
if partnership_account_group_viewing:
filter_by = and_(User.partnership_account_id == partnership_account_id, current_user.role == 'admin')
else:
filter_by = (current_user.id == User.id) | and_(User.partnership_account_id == partnership_account_id,
current_user.role == 'admin')
# defining the initial query depending on your purpose
query = db.session.query().select_from(User).filter(filter_by).filter(User.is_deactivated.is_(False))
# instantiating a DataTable for the query and table needed
row_table = DataTables(request.args, query, columns)
# returns what is needed by DataTable
return jsonify(row_table.output_result())
@admin.route('/users/edit/<int:id>', methods=['GET', 'POST'])
@role_required('admin', 'sysadmin', 'limitsysadmin')
def users_edit(id):
user = User.query.get(id)
form = UserForm(obj=user)
form.reports_list.choices = []
reports = [(report.id, report.name) for report in Report.query.all()]
for r in reports:
if r != (3, 'Partner Channel Account Report'):
form.reports_list.choices.append(r)
partnership_account_id = current_user.partnership_account_id
if current_user.role == 'admin':
form.role.choices = [('admin', 'Admin'), ('agent', 'Agent')]
from ..partnership.models import ExternalApiServiceProvidersPartnershipAccountTie
ams_2000_account_tie = False
partnership_account_ams_2000_ties = ExternalApiServiceProvidersPartnershipAccountTie.exists_for_service_provider(
partnership_account_id, 'AMS 2000')
if partnership_account_ams_2000_ties:
ams_2000_account_tie = True
ams_2000_exists = UserExternalApiAutoPostTie.get_service_provider_access_state(
id, partnership_account_id, 'AMS 2000'
)
if ams_2000_exists and ams_2000_exists.is_allowed:
form.ams_2000.data = True
else:
form.ams_2000.data = False
ams_evo_account_tie = False
partnership_account_ams_evo_ties = ExternalApiServiceProvidersPartnershipAccountTie.exists_for_service_provider(
partnership_account_id, 'AMS Evolution')
if partnership_account_ams_evo_ties:
ams_evo_account_tie = True
ams_evolution_user_tie_exists = UserExternalApiAutoPostTie.get_service_provider_access_state(
id, partnership_account_id, 'AMS Evolution'
)
if ams_evolution_user_tie_exists and ams_evolution_user_tie_exists.is_allowed:
form.ams_evolution.data = True
else:
form.ams_evolution.data = False
neo_verify_account_tie = False
partnership_account_neo_verify_ties = ExternalApiServiceProvidersPartnershipAccountTie.exists_for_service_provider(
partnership_account_id, 'NEO Verify')
if partnership_account_neo_verify_ties:
neo_verify_account_tie = True
neo_verify_user_tie_exists = UserExternalApiAutoPostTie.get_service_provider_access_state(
id, partnership_account_id, 'NEO Verify'
)
if neo_verify_user_tie_exists and neo_verify_user_tie_exists.is_allowed:
form.neo_verify.data = True
else:
form.neo_verify.data = False
ams_analytics_account_tie = False
partnership_account_ams_analytics_ties = ExternalApiServiceProvidersPartnershipAccountTie.exists_for_service_provider(
partnership_account_id, 'AMS Analytics')
if partnership_account_ams_analytics_ties:
ams_analytics_account_tie = True
ams_analytics_user_tie_exists = UserExternalApiAutoPostTie.get_service_provider_access_state(
id, partnership_account_id, 'AMS Analytics'
)
if ams_analytics_user_tie_exists and ams_analytics_user_tie_exists.is_allowed:
form.ams_analytics.data = True
else:
form.ams_analytics.data = False
ams_prequalify_account_tie = False
partnership_account_ams_prequalify_ties = ExternalApiServiceProvidersPartnershipAccountTie.exists_for_service_provider(
partnership_account_id, 'AMS PreQualify')
if partnership_account_ams_prequalify_ties:
ams_prequalify_account_tie = True
ams_prequalify_user_tie_exists = UserExternalApiAutoPostTie.get_service_provider_access_state(
id, partnership_account_id, 'AMS PreQualify'
)
if ams_prequalify_user_tie_exists and ams_prequalify_user_tie_exists.is_allowed:
form.ams_prequalify.data = True
else:
form.ams_prequalify.data = False
if form.validate_on_submit():
if User.is_last_admin(user,
request.form.get('role'),
request.form.get('active')):
flash(_('You are the last admin, you cannot do that.'),
'danger')
return redirect(url_for('admin.users'))
form.populate_obj(user)
if user.username == '':
user.username = None
user.save()
ams_2000 = request.form.get('ams_2000')
ams_2000_result = False
if ams_2000 and ams_2000 == 'y':
ams_2000_result = True
UserExternalApiAutoPostTie.set_service_provider_access_state(id, partnership_account_id, 'AMS 2000', ams_2000_result)
ams_evolution = request.form.get('ams_evolution')
ams_evolution_result = False
if ams_evolution and ams_evolution == 'y':
ams_evolution_result = True
UserExternalApiAutoPostTie.set_service_provider_access_state(id, partnership_account_id, 'AMS Evolution', ams_evolution_result)
neo_verify = request.form.get('neo_verify')
neo_verify_result = False
if neo_verify and neo_verify == 'y':
neo_verify_result = True
UserExternalApiAutoPostTie.set_service_provider_access_state(id, partnership_account_id, 'NEO Verify', neo_verify_result)
ams_analytics = request.form.get('ams_analytics')
ams_analytics_result = False
if ams_analytics and ams_analytics == 'y':
ams_analytics_result = True
UserExternalApiAutoPostTie.set_service_provider_access_state(id, partnership_account_id, 'AMS Analytics', ams_analytics_result)
ams_prequalify = request.form.get('ams_prequalify')
ams_prequalify_result = False
if ams_prequalify and ams_prequalify == 'y':
ams_prequalify_result = True
UserExternalApiAutoPostTie.set_service_provider_access_state(id, partnership_account_id, 'AMS PreQualify', ams_prequalify_result)
user.reports = list()
# re-adding reports
for id in form.reports_list.data:
link = ReportUserTie()
link.report_id = id
link.user_id = user.id
link.partnership_accounts_id = user.partnership_account_id
db.session.add(link)
db.session.commit()
# activity log for user edit
ActivityLogs.add_log(current_user.id, ActivityType.PAGE, ActivityName.EDIT, request, id)
flash(_('User has been saved successfully.'), 'success')
return redirect(url_for('admin.users'))
else:
# activity log for user page view
ActivityLogs.add_log(current_user.id, ActivityType.PAGE, ActivityName.VIEW, request, id)
form.reports_list.process_data([link.report.id for link in user.reports])
return render_template('admin/user/edit.jinja2',
form=form,
user=user,
ams_2000_provider_exists=ams_2000_account_tie,
ams_evo_provider_exists=ams_evo_account_tie,
neo_verify_provider_exists=neo_verify_account_tie,
ams_analytics_provider_exists=ams_analytics_account_tie,
ams_prequalify_provider_exists=ams_prequalify_account_tie
)
@admin.route('/users/delete/<int:id>', methods=['DELETE'])
@login_required
@role_required('admin')
def user_delete(id):
result = User.deactivate_user(id)
return jsonify(success=result)
@admin.route('/users/cancel_subscription', methods=['POST'])
@role_required('admin')
def users_cancel_subscription():
form = UserCancelSubscriptionForm()
if form.validate_on_submit():
user = User.query.get(request.form.get('id'))
if user:
subscription = user.subscription
if subscription.cancel(user):
flash(_('Subscription has been cancelled for %(user)s.',
user=user.name), 'success')
else:
flash(_('No subscription was cancelled, something went wrong.'),
'danger')
return redirect(url_for('admin.users'))
# Issues ----------------------------------------------------------------------
@admin.route('/issues', defaults={'page': 1})
def issues(page):
return render_template('admin/issue/index.jinja2')
# return issues data into jquery datatables
@admin.route('/issues-data')
def issues_data():
"""Return server side data."""
partnership_account_id = current_user.partnership_account_id
partnership_account_group_viewing = current_user.is_viewing_partnership
# Check if being viewed by super partner
if partnership_account_group_viewing:
partnership_account_id = current_user.get_user_viewing_partnership_account_id
# defining columns
columns = [ColumnDT(Issue.id),
ColumnDT(Partnership.name),
ColumnDT(PartnershipAccount.name),
ColumnDT(Issue.status),
ColumnDT(Issue.label),
ColumnDT(Issue.created_on),
ColumnDT(Issue.email),
]
filter_by = (partnership_account_id == Issue.partnership_id) & \
(partnership_account_id == Issue.partnership_account_id)
if current_user.is_admin_user_with_groups and partnership_account_group_viewing:
filter_by = (partnership_account_id == Issue.partnership_account_id)
elif current_user.role == 'admin' and current_user.is_admin_user_with_groups and not\
partnership_account_group_viewing:
from buyercall.blueprints.partnership.models import PartnershipAccountGroupTie
groups = db.session.query(
PartnershipAccountGroupTie.partnership_account_id
).filter(
PartnershipAccountGroupTie.partnership_account_group_id == current_user.partnership_account_group_id
).all()
if groups is not None and len(groups) > 0:
filter_by = (Issue.partnership_account_id.in_(groups))
else:
filter_by = (partnership_account_id == Issue.partnership_account_id)
elif current_user.role == 'partner':
filter_by = (current_user.partnership_id == Issue.partnership_id)
elif current_user.role in ['sysadmin', 'limitsysadmin']:
filter_by = text('1 = 1')
log.error('every: {}'.format(filter_by))
# defining the initial query depending on your purpose
query = db.session.query().select_from(Issue, Partnership, PartnershipAccount).filter(filter_by)
# instantiating a DataTable for the query and table needed
row_table = DataTables(request.args, query, columns)
# returns what is needed by DataTable
return jsonify(row_table.output_result())
@admin.route('/issues/edit/<int:id>', methods=['GET', 'POST'])
def issues_edit(id):
issue = Issue.query.get(id)
if request.method == 'GET' and issue and issue.status == 'unread':
issue = Issue.unread_to_open(issue)
form = IssueForm(obj=issue)
subject = _('[BuyerCall issue] Re: %(issue_type)s',
issue_type=issue.LABEL[issue.label])
# Shenanigans to comply with PEP-8's formatting style.
body_string = '\n\nYou opened an issue regarding:'
issue_string = '\n\n---\n{0}\n---\n\n'.format(issue.question)
message = _('Hello,%(body)s:%(issue)s\n\nThanks,\nSupport team',
body=body_string, issue=issue_string)
contact_form = IssueContactForm(email=issue.email,
subject=subject, message=message)
if form.validate_on_submit():
form.populate_obj(issue)
issue.save()
flash(_('Issue has been saved successfully.'), 'success')
return redirect(url_for('admin.issues'))
return render_template('admin/issue/edit.jinja2', form=form,
contact_form=contact_form, issue=issue)
@admin.route('/issues/contact/<int:id>', methods=['POST'])
def issues_contact(id):
issue = Issue.query.get(id)
if issue:
from buyercall.blueprints.admin.tasks import deliver_support_email
deliver_support_email.delay(id,
request.form.get('subject'),
request.form.get('message'))
Issue.set_as_contacted(issue)
flash(_('The person who sent the issue has been contacted.'),
'success')
else:
flash(_('Issue no longer exists, no e-mail was sent.'), 'danger')
return redirect(url_for('admin.issues'))
# Coupons ---------------------------------------------------------------------
@admin.route('/coupons', defaults={'page': 1})
@role_required('sysadmin')
def coupons(page):
return render_template('admin/coupon/index.jinja2')
# return coupons data into jquery datatables
@admin.route('/coupons-data')
@role_required('sysadmin')
def coupons_data():
"""Return server side data."""
# defining columns
columns = [ColumnDT(Coupon.id, search_method='none'),
ColumnDT(Coupon.created_on, search_method='none'),
ColumnDT(Coupon.code),
ColumnDT(Coupon.duration, search_method='none'),
ColumnDT(Coupon.redeem_by, search_method='none'),
ColumnDT(Coupon.times_redeemed, search_method='none'),
ColumnDT(Coupon.amount_off, search_method='none'),
ColumnDT(Coupon.percent_off, search_method='none'),
ColumnDT(Coupon.duration_in_months, search_method='none'),
ColumnDT(Coupon.max_redemptions, search_method='none'),
]
# defining the initial query depending on your purpose
query = db.session.query().select_from(Coupon)
# instantiating a DataTable for the query and table needed
row_table = DataTables(request.args, query, columns)
# returns what is needed by DataTable
return jsonify(row_table.output_result())
@admin.route('/coupons/new', methods=['GET', 'POST'])
@handle_stripe_exceptions
@role_required('sysadmin')
def coupons_new():
coupon = Coupon()
form = CouponForm(obj=coupon)
if form.validate_on_submit():
form.populate_obj(coupon)
params = {
'code': coupon.code,
'duration': coupon.duration,
'percent_off': coupon.percent_off,
'amount_off': coupon.amount_off,
'currency': coupon.currency,
'redeem_by': coupon.redeem_by,
'max_redemptions': coupon.max_redemptions,
'duration_in_months': coupon.duration_in_months,
}
try:
if Coupon.create(params):
flash(_('Coupon has been created successfully.'), 'success')
return redirect(url_for('admin.coupons'))
except InvalidRequestError as e:
flash(_(e._message), 'error')
return render_template('admin/coupon/new.jinja2', form=form, coupon=coupon)
@admin.route('/coupons/delete/<int:id>', methods=['POST', 'DELETE'])
@handle_stripe_exceptions
@role_required('sysadmin')
def coupons_delete(id):
coupon = Coupon.query.get(id)
coupon.delete()
return redirect(url_for('admin.coupons'))
@admin.route('/integrations')
@role_required('admin', 'partner')
def integrations():
if current_user.role == 'agent':
return redirect(url_for('user.settings'))
else:
return render_template('admin/integrations/integrations.jinja2')
@admin.route('/compliance_dashboard')
@role_required('admin', 'partner')
def compliance_dashboard():
if current_user.role == 'agent' or current_user.business_type != "automotive":
return redirect(url_for('user.settings'))
user_id = current_user.id
credit_credentials = None
partner_account = current_user.partnership_account_id
credit_credentials = PartnershipAccountCreditTie.partner_account_seven_hundred_credit_info(partner_account, 'credit')
from buyercall.lib.util_credit_reports import seven_hundred_credit_client
if credit_credentials:
client = seven_hundred_credit_client(current_user.partnership_account_id, 'credit')
url = client.credit_report.get_compliance_dashboard()
else:
url = ''
return render_template('admin/integrations/compliance_dashboard.jinja2',
user_id=user_id,
credit_credentials=credit_credentials,
url=url)
@admin.route('/integrations/<int:paid>/seven hundred_full_credit', methods=['POST', 'GET'])
@role_required('admin', 'partner')
def seven_hundred_full_credit(paid):
credit_object = PartnershipAccountCreditTie()
form = SevenHundredCreditForm(obj=credit_object)
partner_account_id = paid
provider = '700Credit'
product = 'credit'
credit_profile = PartnershipAccountCreditTie.query\
.filter(and_(PartnershipAccountCreditTie.service_provider ==
provider, PartnershipAccountCreditTie.product_type == product,
PartnershipAccountCreditTie.partnership_account_id == partner_account_id)).first()
if credit_profile is not None and credit_profile.product_type == 'credit':
encrypt_key = current_app.config['CRYPTO_SECRET_KEY']
cipher = AESCipher(encrypt_key)
# Decrypt the credentials before pushing it through to the form
if credit_profile.api_username is not None and credit_profile.api_username is not '':
decrypted_username = cipher.decrypt(credit_profile.api_username)
else:
decrypted_username = ''
if credit_profile.api_account is not None and credit_profile.api_account is not '':
decrypted_account = cipher.decrypt(credit_profile.api_account)
else:
decrypted_account = ''
if credit_profile.api_password is not None and credit_profile.api_password is not '':
decrypted_password = cipher.decrypt(credit_profile.api_password)
else:
decrypted_password = ''
# Pass the descrypted and other credit values to the form
form = SevenHundredCreditForm(active=credit_profile.active,
api_account=decrypted_account,
api_username=decrypted_username,
api_password=decrypted_password,
experian_enabled=credit_profile.experian_enabled,
transunion_enabled=credit_profile.transunion_enabled,
equifax_enabled=credit_profile.equifax_enabled
)
if form.validate_on_submit():
cipher = AESCipher(encrypt_key)
try:
# On gathering the data from the form encrypt the Bandwidth credentials
credit_profile.active = form.active.data
if form.api_account.data is not None and form.api_account.data is not '':
credit_profile.api_account = cipher.encrypt(form.api_account.data)
if form.api_username.data is not None and form.api_username.data is not '':
credit_profile.api_username = cipher.encrypt(form.api_username.data)
if form.api_password.data is not None and form.api_password.data is not '':
credit_profile.api_password = cipher.encrypt(form.api_password.data)
credit_profile.experian_enabled = form.experian_enabled.data
credit_profile.transunion_enabled = form.transunion_enabled.data
credit_profile.equifax_enabled = form.equifax_enabled.data
credit_profile.save()
db.session.commit()
flash(_('The 700 Credit API Credentials have been updated successfully.'), 'success')
return redirect(url_for('admin.integrations'))
except:
log.error(traceback.format_exc())
db.session.rollback()
flash(_("An error occurred while saving the 700 Credit API Credentials. Please contact support "
"for assistance."), 'danger')
else:
new_credit_credentials_set(credit_object, provider, product, partner_account_id)
return render_template('admin/integrations/seven_hundred_credit/seven_hundred_full_credit.jinja2',
form=form)
@admin.route('/integrations/<int:paid>/seven hundred_prequalify_credit', methods=['POST', 'GET'])
@role_required('admin', 'partner')
def seven_hundred_prequalify_credit(paid):
credit_object = PartnershipAccountCreditTie()
form = SevenHundredPrequalifyForm(obj=credit_object)
partner_account_id = paid
provider = '700Credit'
product = 'prequalify'
credit_profile = PartnershipAccountCreditTie.query\
.filter(and_(PartnershipAccountCreditTie.service_provider ==
provider, PartnershipAccountCreditTie.product_type == product,
PartnershipAccountCreditTie.partnership_account_id == partner_account_id)).first()
if credit_profile is not None and credit_profile.product_type == 'prequalify':
encrypt_key = current_app.config['CRYPTO_SECRET_KEY']
cipher = AESCipher(encrypt_key)
# Decrypt the credentials before pushing it through to the form
if credit_profile.api_username is not None and credit_profile.api_username is not '':
decrypted_username = cipher.decrypt(credit_profile.api_username)
else:
decrypted_username = ''
if credit_profile.api_account is not None and credit_profile.api_account is not '':
decrypted_account = cipher.decrypt(credit_profile.api_account)
else:
decrypted_account = ''
if credit_profile.api_password is not None and credit_profile.api_password is not '':
decrypted_password = cipher.decrypt(credit_profile.api_password)
else:
decrypted_password = ''
# Pass the decrypted and other credit values to the form
form = SevenHundredPrequalifyForm(active=credit_profile.active,
api_account=decrypted_account,
api_username=decrypted_username,
api_password=decrypted_password,
experian_enabled=credit_profile.experian_enabled,
transunion_enabled=credit_profile.transunion_enabled,
equifax_enabled=credit_profile.equifax_enabled
)
if form.validate_on_submit():
cipher = AESCipher(encrypt_key)
try:
# On gathering the data from the form encrypt the Bandwidth credentials
credit_profile.active = form.active.data
if form.api_account.data is not None and form.api_account.data is not '':
credit_profile.api_account = cipher.encrypt(form.api_account.data)
if form.api_username.data is not None and form.api_username.data is not '':
credit_profile.api_username = cipher.encrypt(form.api_username.data)
if form.api_password.data is not None and form.api_password.data is not '':
credit_profile.api_password = cipher.encrypt(form.api_password.data)
credit_profile.experian_enabled = form.experian_enabled.data
credit_profile.transunion_enabled = form.transunion_enabled.data
credit_profile.equifax_enabled = form.equifax_enabled.data
credit_profile.save()
db.session.commit()
flash(_('The 700 Credit API Credentials have been updated successfully.'), 'success')
return redirect(url_for('admin.integrations'))
except Exception:
log.error(traceback.format_exc())
db.session.rollback()
flash(_("An error occurred while saving the 700 Credit API Credentials. Please contact support "
"for assistance."), 'danger')
else:
new_credit_credentials_set(credit_object, provider, product, partner_account_id)
return render_template('admin/integrations/seven_hundred_credit/seven_hundred_prequalify_credit.jinja2',
form=form)
@admin.route('/integrations/<int:paid>/finserv_prequalify_credit', methods=['POST', 'GET'])
@role_required('admin', 'partner')
def finserv_prequalify_credit(paid):
credit_object = PartnershipAccountCreditTie()
form = FinservPrequalifyForm(obj=credit_object)
partner_account_id = paid
provider = 'Finserv'
product = 'prequalify'
credit_profile = PartnershipAccountCreditTie.query\
.filter(and_(PartnershipAccountCreditTie.service_provider ==
provider, PartnershipAccountCreditTie.product_type == product,
PartnershipAccountCreditTie.partnership_account_id == partner_account_id)).first()
if credit_profile is not None and credit_profile.product_type == 'prequalify':
encrypt_key = current_app.config['CRYPTO_SECRET_KEY']
cipher = AESCipher(encrypt_key)
# Decrypt the credentials before pushing it through to the form
if credit_profile.api_username is not None and credit_profile.api_username is not '':
decrypted_username = cipher.decrypt(credit_profile.api_username)
else:
decrypted_username = ''
if credit_profile.api_password is not None and credit_profile.api_password is not '':
decrypted_password = cipher.decrypt(credit_profile.api_password)
else:
decrypted_password = ''
if credit_profile.api_account is not None and credit_profile.api_account is not '':
decrypted_account = cipher.decrypt(credit_profile.api_account)
else:
decrypted_account = ''
# Pass the decrypted and other credit values to the form
form = FinservPrequalifyForm(active=credit_profile.active,
api_username=decrypted_username,
api_password=decrypted_password,
api_account=decrypted_account
)
if form.validate_on_submit():
cipher = AESCipher(encrypt_key)
try:
# On gathering the data from the form encrypt the Bandwidth credentials
credit_profile.active = form.active.data
if form.api_username.data is not None and form.api_username.data is not '':
credit_profile.api_username = cipher.encrypt(form.api_username.data)
if form.api_password.data is not None and form.api_password.data is not '':
credit_profile.api_password = cipher.encrypt(form.api_password.data)
if form.api_account.data is not None and form.api_account.data is not '':
credit_profile.api_account = cipher.encrypt(form.api_account.data)
credit_profile.experian_enabled = True
credit_profile.save()
db.session.commit()
flash(_('The Finserv API Credentials have been updated successfully.'), 'success')
return redirect(url_for('admin.integrations'))
except:
log.error(traceback.format_exc())
db.session.rollback()
flash(_("An error occurred while saving the Finserv API Credentials. Please contact support "
"for assistance."), 'danger')
else:
new_credit_credentials_set(credit_object, provider, product, partner_account_id)
return render_template('admin/integrations/finserv/finserv_prequalify_credit.jinja2',
form=form)
@admin.route('/integrations/adf_email_import', methods=['GET', 'POST'])
@csrf.exempt
@role_required('admin', 'partner')
def adf_email_import():
adf_email = ''
partnership_account_id = current_user.partnership_account_id
partnership_account_group_viewing = current_user.is_viewing_partnership
# Check if being viewed by super partner
if partnership_account_group_viewing:
partnership_account_id = current_user.get_user_viewing_partnership_account_id
# Get Partner account name
partner_account = PartnershipAccount\
.query\
.filter(PartnershipAccount.id == partnership_account_id)\
.first()
if partner_account:
if partner_account.adf_assigned_email is not None:
adf_email = partner_account.adf_assigned_email
if request.method == 'POST':
if partner_account.adf_assigned_email is None:
# Create partnership/partnership account key pid + paid + uid +
name_before_format = partner_account.name.replace(" ", ".").replace("_", "").replace("-", "")
name_after_format = ''.join(e for e in name_before_format if e.isalnum())
adf_email = "{}{}@inbound.buyercall.com".format(name_after_format, "." + str(partner_account.id)).lower()
partner_account.adf_assigned_email = adf_email
db.session.commit()
flash(_('ADF import email address generated.'), 'success')
return render_template('admin/integrations/adf_email_import/adf_email_import.jinja2',
adf_assigned_email=adf_email)
@admin.route('/integrations/<int:paid>/ams_evolution_dms', methods=['POST', 'GET'])
@role_required('admin', 'partner')
def ams_evolution_dms(paid):
encrypt_key = current_app.config['CRYPTO_SECRET_KEY']
cipher = AESCipher(encrypt_key)
dms_object = ExternalApiServiceProvidersPartnershipAccountTie()
form = AMSEvolutionForm(obj=dms_object)
partner_account_id = paid
provider = 'AMS Evolution'
service_provider = ExternalApiServiceProviders \
.query \
.filter(ExternalApiServiceProviders.name == provider) \
.first()
if service_provider:
partner_service_provider = ExternalApiServiceProvidersPartnershipAccountTie.query\
.filter(ExternalApiServiceProvidersPartnershipAccountTie.external_api_service_provider_id == service_provider.id,
ExternalApiServiceProvidersPartnershipAccountTie.partnership_account_id == partner_account_id)\
.first()
if partner_service_provider is not None:
# Decrypt the credentials before pushing it through to the form
if partner_service_provider.username is not None and partner_service_provider.username != '':
decrypted_username = cipher.decrypt(partner_service_provider.username)
else:
decrypted_username = ''
if partner_service_provider.password is not None and partner_service_provider.password != '':
decrypted_password = cipher.decrypt(partner_service_provider.password)
else:
decrypted_password = ''
if partner_service_provider.client_id is not None and partner_service_provider.client_id != '':
decrypted_account = cipher.decrypt(partner_service_provider.client_id)
else:
decrypted_account = ''
if partner_service_provider.url is not None and partner_service_provider.url != '':
url = partner_service_provider.url
else:
url = ''
if partner_service_provider.secret is not None and partner_service_provider.secret != '':
decrypted_secret = cipher.decrypt(partner_service_provider.secret)
else:
decrypted_secret = ''
# Pass the decrypted and other credit values to the form
form = AMSEvolutionForm(active=partner_service_provider.active,
api_account=decrypted_account,
api_username=decrypted_username,
api_password=decrypted_password,
api_url=url,
api_secret=decrypted_secret)
if form.validate_on_submit():
try:
# On gathering the data from the form encrypt the Bandwidth credentials
partner_service_provider.active = form.active.data
if form.api_account.data is not None and form.api_account.data is not '':
partner_service_provider.client_id = cipher.encrypt(form.api_account.data)
if form.api_username.data is not None and form.api_username.data is not '':
partner_service_provider.username = cipher.encrypt(form.api_username.data)
if form.api_password.data is not None and form.api_password.data is not '':
partner_service_provider.password = cipher.encrypt(form.api_password.data)
if form.api_secret.data is not None and form.api_secret.data is not '':
partner_service_provider.secret = cipher.encrypt(form.api_secret.data)
if form.api_url.data is not None and form.api_url.data is not '':
partner_service_provider.url = form.api_url.data
partner_service_provider.save()
db.session.commit()
flash(_('The AMS Evolution API Credentials have been updated successfully.'), 'success')
return redirect(url_for('admin.integrations'))
except:
log.error(traceback.format_exc())
db.session.rollback()
flash(_("An error occurred while saving the AMS Evolution Credentials. Please contact support "
"for assistance."), 'danger')
else:
try:
if form.validate_on_submit():
if service_provider:
dms_object.active = form.active.data
dms_object.partnership_account_id = paid
dms_object.external_api_service_provider_id = service_provider.id
if form.api_account.data is not None and form.api_account.data is not '':
dms_object.client_id = cipher.encrypt(form.api_account.data)
if form.api_username.data is not None and form.api_username.data is not '':
dms_object.username = cipher.encrypt(form.api_username.data)
if form.api_password.data is not None and form.api_password.data is not '':
dms_object.password = cipher.encrypt(form.api_password.data)
if form.api_secret.data is not None and form.api_secret.data is not '':
dms_object.secret = cipher.encrypt(form.api_secret.data)
if form.api_url.data is not None and form.api_url.data is not '':
dms_object.url = form.api_url.data
dms_object.save()
db.session.commit()
flash(_('The AMS Evolution API Credentials have been updated successfully.'), 'success')
return redirect(url_for('admin.integrations'))
except Exception as e:
log.error(traceback.format_exc())
log.error(e)
db.session.rollback()
flash(_("An error occurred while saving the AMS Evolution Credentials. Please contact support"
"for assistance."), 'danger')
return render_template('admin/integrations/ams/ams_evolution_dms.jinja2',
form=form)
else:
flash(_('A service provider was not found. Please contact support for assistance.'), 'success')
return redirect(url_for('admin.integrations'))
@admin.route('/integrations/<int:paid>/neo_verify_cms', methods=['POST', 'GET'])
@role_required('admin', 'partner')
def neo_verify_cms(paid):
encrypt_key = current_app.config['CRYPTO_SECRET_KEY']
cipher = AESCipher(encrypt_key)
dms_object = ExternalApiServiceProvidersPartnershipAccountTie()
form = NeoVerifyForm(obj=dms_object)
partner_account_id = paid
provider = 'NEO Verify'
service_provider = ExternalApiServiceProviders \
.query \
.filter(ExternalApiServiceProviders.name == provider) \
.first()
if service_provider:
partner_service_provider = ExternalApiServiceProvidersPartnershipAccountTie.query\
.filter(ExternalApiServiceProvidersPartnershipAccountTie.external_api_service_provider_id == service_provider.id,
ExternalApiServiceProvidersPartnershipAccountTie.partnership_account_id == partner_account_id)\
.first()
if partner_service_provider is not None:
# Decrypt the credentials before pushing it through to the form
if partner_service_provider.url is not None and partner_service_provider.url != '':
url = partner_service_provider.url
else:
url = ''
if partner_service_provider.secret is not None and partner_service_provider.secret != '':
decrypted_secret = cipher.decrypt(partner_service_provider.secret)
else:
decrypted_secret = ''
# Pass the decrypted and other credit values to the form
form = AMSEvolutionForm(active=partner_service_provider.active,
api_url=url,
api_secret=decrypted_secret)
if form.validate_on_submit():
try:
# On gathering the data from the form encrypt the Bandwidth credentials
partner_service_provider.active = form.active.data
if form.api_secret.data is not None and form.api_secret.data is not '':
partner_service_provider.secret = cipher.encrypt(form.api_secret.data)
if form.api_url.data is not None and form.api_url.data is not '':
partner_service_provider.url = form.api_url.data
partner_service_provider.save()
db.session.commit()
flash(_('The NEO Verify API Credentials have been updated successfully.'), 'success')
return redirect(url_for('admin.integrations'))
except:
log.error(traceback.format_exc())
db.session.rollback()
flash(_("An error occurred while saving the NEO Verify Credentials. Please contact support "
"for assistance."), 'danger')
else:
try:
if form.validate_on_submit():
if service_provider:
dms_object.active = form.active.data
dms_object.partnership_account_id = paid
dms_object.external_api_service_provider_id = service_provider.id
if form.api_secret.data is not None and form.api_secret.data is not '':
dms_object.secret = cipher.encrypt(form.api_secret.data)
if form.api_url.data is not None and form.api_url.data is not '':
dms_object.url = form.api_url.data
dms_object.save()
db.session.commit()
flash(_('The NEO Verify API Credentials have been updated successfully.'), 'success')
return redirect(url_for('admin.integrations'))
except Exception as e:
log.error(traceback.format_exc())
log.error(e)
db.session.rollback()
flash(_("An error occurred while saving the NEO Verify Credentials. Please contact support"
"for assistance."), 'danger')
return render_template('admin/integrations/neo/neo_verify_cms.jinja2',
form=form)
else:
flash(_('A service provider was not found. Please contact support for assistance.'), 'success')
return redirect(url_for('admin.integrations'))
@admin.route('/integrations/<int:paid>/ams_analytics_cms', methods=['POST', 'GET'])
@role_required('admin', 'partner')
def ams_analytics_cms(paid):
encrypt_key = current_app.config['CRYPTO_SECRET_KEY']
cipher = AESCipher(encrypt_key)
dms_object = ExternalApiServiceProvidersPartnershipAccountTie()
form = AmsAnalyticsForm(obj=dms_object)
partner_account_id = paid
provider = 'AMS Analytics'
service_provider = ExternalApiServiceProviders \
.query \
.filter(ExternalApiServiceProviders.name == provider) \
.first()
if service_provider:
partner_service_provider = ExternalApiServiceProvidersPartnershipAccountTie.query\
.filter(ExternalApiServiceProvidersPartnershipAccountTie.external_api_service_provider_id == service_provider.id,
ExternalApiServiceProvidersPartnershipAccountTie.partnership_account_id == partner_account_id)\
.first()
if partner_service_provider is not None:
# Decrypt the credentials before pushing it through to the form
if partner_service_provider.url is not None and partner_service_provider.url != '':
url = partner_service_provider.url
else:
url = ''
if partner_service_provider.client_id is not None and partner_service_provider.client_id != '':
# decrypted_secret = cipher.decrypt(partner_service_provider.secret)
decrypted_secret = partner_service_provider.client_id
else:
decrypted_secret = ''
# Pass the decrypted and other credit values to the form
form = AmsAnalyticsForm(active=partner_service_provider.active,
api_url=url,
api_client_id=decrypted_secret)
if form.validate_on_submit():
try:
# On gathering the data from the form encrypt the Bandwidth credentials
partner_service_provider.active = form.active.data
if form.api_client_id.data is not None and form.api_client_id.data is not '':
# partner_service_provider.client_id = cipher.encrypt(form.api_secret.data)
partner_service_provider.client_id = form.api_client_id.data
if form.api_url.data is not None and form.api_url.data is not '':
partner_service_provider.url = form.api_url.data
partner_service_provider.save()
db.session.commit()
flash(_('The AMS Analytics API Credentials have been updated successfully.'), 'success')
return redirect(url_for('admin.integrations'))
except:
log.error(traceback.format_exc())
db.session.rollback()
flash(_("An error occurred while saving the AMS Analytics Credentials. Please contact support "
"for assistance."), 'danger')
else:
try:
if form.validate_on_submit():
if service_provider:
dms_object.active = form.active.data
dms_object.partnership_account_id = paid
dms_object.external_api_service_provider_id = service_provider.id
if form.api_client_id.data is not None and form.api_client_id.data is not '':
# dms_object.secret = cipher.encrypt(form.api_secret.data)
dms_object.client_id = form.api_client_id.data
if form.api_url.data is not None and form.api_url.data is not '':
dms_object.url = form.api_url.data
dms_object.save()
db.session.commit()
flash(_('The AMS Analytics API Credentials have been updated successfully.'), 'success')
return redirect(url_for('admin.integrations'))
except Exception as e:
log.error(traceback.format_exc())
log.error(e)
db.session.rollback()
flash(_("An error occurred while saving the AMS Analytics Credentials. Please contact support"
"for assistance."), 'danger')
return render_template('admin/integrations/ams/ams_analytics.jinja2',
form=form)
else:
flash(_('A service provider was not found. Please contact support for assistance.'), 'success')
return redirect(url_for('admin.integrations'))
@admin.route('/integrations/<int:paid>/ams_prequalify_cms', methods=['POST', 'GET'])
@role_required('admin', 'partner')
def ams_prequalify_cms(paid):
encrypt_key = current_app.config['CRYPTO_SECRET_KEY']
cipher = AESCipher(encrypt_key)
dms_object = ExternalApiServiceProvidersPartnershipAccountTie()
form = AmsPrequalifyForm(obj=dms_object)
partner_account_id = paid
provider = 'AMS PreQualify'
service_provider = ExternalApiServiceProviders \
.query \
.filter(ExternalApiServiceProviders.name == provider) \
.first()
if service_provider:
partner_service_provider = ExternalApiServiceProvidersPartnershipAccountTie.query\
.filter(ExternalApiServiceProvidersPartnershipAccountTie.external_api_service_provider_id == service_provider.id,
ExternalApiServiceProvidersPartnershipAccountTie.partnership_account_id == partner_account_id)\
.first()
if partner_service_provider is not None:
# Decrypt the credentials before pushing it through to the form
if partner_service_provider.url is not None and partner_service_provider.url != '':
url = partner_service_provider.url
else:
url = ''
if partner_service_provider.client_id is not None and partner_service_provider.client_id != '':
# decrypted_secret = cipher.decrypt(partner_service_provider.secret)
decrypted_secret = partner_service_provider.client_id
else:
decrypted_secret = ''
# Pass the decrypted and other credit values to the form
form = AmsPrequalifyForm(active=partner_service_provider.active,
api_url=url,
api_client_id=decrypted_secret)
if form.validate_on_submit():
try:
# On gathering the data from the form encrypt the Bandwidth credentials
partner_service_provider.active = form.active.data
if form.api_client_id.data is not None and form.api_client_id.data is not '':
# partner_service_provider.client_id = cipher.encrypt(form.api_secret.data)
partner_service_provider.client_id = form.api_client_id.data
if form.api_url.data is not None and form.api_url.data is not '':
partner_service_provider.url = form.api_url.data
partner_service_provider.save()
db.session.commit()
flash(_('The AMS Prequalify API Credentials have been updated successfully.'), 'success')
return redirect(url_for('admin.integrations'))
except:
log.error(traceback.format_exc())
db.session.rollback()
flash(_("An error occurred while saving the AMS Prequalify Credentials. Please contact support "
"for assistance."), 'danger')
else:
try:
if form.validate_on_submit():
if service_provider:
dms_object.active = form.active.data
dms_object.partnership_account_id = paid
dms_object.external_api_service_provider_id = service_provider.id
if form.api_client_id.data is not None and form.api_client_id.data is not '':
# dms_object.secret = cipher.encrypt(form.api_secret.data)
dms_object.client_id = form.api_client_id.data
if form.api_url.data is not None and form.api_url.data is not '':
dms_object.url = form.api_url.data
dms_object.save()
db.session.commit()
flash(_('The AMS Prequalify API Credentials have been updated successfully.'), 'success')
return redirect(url_for('admin.integrations'))
except Exception as e:
log.error(traceback.format_exc())
log.error(e)
db.session.rollback()
flash(_("An error occurred while saving the AMS Prequalify Credentials. Please contact support"
"for assistance."), 'danger')
return render_template('admin/integrations/ams/ams_prequalify.jinja2',
form=form)
else:
flash(_('A service provider was not found. Please contact support for assistance.'), 'success')
return redirect(url_for('admin.integrations'))
def new_credit_credentials_set(credit_object, provider, product_type, paid):
encrypt_key = current_app.config['CRYPTO_SECRET_KEY']
if product_type.lower() == 'credit' and provider == '700Credit':
form = SevenHundredCreditForm(obj=credit_object)
elif product_type.lower() == 'prequalify' and provider == '700Credit':
form = SevenHundredPrequalifyForm(obj=credit_object)
elif product_type.lower() == 'prequalify' and provider == 'Finserv':
form = FinservPrequalifyForm(obj=credit_object)
else:
flash(_('The product type and credit provider mapping is not available.'), 'danger')
return redirect(url_for('admin.integrations'))
if provider == '700Credit':
try:
if form.validate_on_submit():
cipher = AESCipher(encrypt_key)
credit_object.service_provider = provider
credit_object.active = form.active.data
credit_object.partnership_account_id = paid
credit_object.product_type = product_type
if form.api_account.data is not None and form.api_account.data is not '':
credit_object.api_account = cipher.encrypt(form.api_account.data)
if form.api_username.data is not None and form.api_username.data is not '':
credit_object.api_username = cipher.encrypt(form.api_username.data)
if form.api_password.data is not None and form.api_password.data is not '':
credit_object.api_password = cipher.encrypt(form.api_password.data)
credit_object.experian_enabled = form.experian_enabled.data
credit_object.transunion_enabled = form.transunion_enabled.data
credit_object.equifax_enabled = form.equifax_enabled.data
credit_object.save()
db.session.commit()
flash(_('The 700 Credit API Credentials have been updated successfully.'), 'success')
return redirect(url_for('admin.integrations'))
except Exception as e:
log.error(traceback.format_exc())
log.error(e)
db.session.rollback()
flash(_("An error occurred while saving the 700 Credit Credentials. Please contact support"
"for assistance."), 'danger')
elif provider == 'Finserv':
try:
if form.validate_on_submit():
cipher = AESCipher(encrypt_key)
credit_object.service_provider = provider
credit_object.active = form.active.data
credit_object.partnership_account_id = paid
credit_object.product_type = product_type
if form.api_username.data is not None and form.api_username.data is not '':
credit_object.api_username = cipher.encrypt(form.api_username.data)
if form.api_password.data is not None and form.api_password.data is not '':
credit_object.api_password = cipher.encrypt(form.api_password.data)
if form.api_account.data is not None and form.api_account.data is not '':
credit_object.api_account = cipher.encrypt(form.api_account.data)
credit_object.experian_enabled = True
credit_object.save()
db.session.commit()
flash(_('The Finserv API Credentials have been updated successfully.'), 'success')
return redirect(url_for('admin.integrations'))
except Exception as e:
log.error(traceback.format_exc())
log.error(e)
db.session.rollback()
flash(_("An error occurred while saving the Finserv Credentials. Please contact support"
"for assistance."), 'danger')
else:
flash(_('A service provider was not found. Please contact support for assistance.'), 'success')
return redirect(url_for('admin.integrations'))
@admin.route('/users/add', methods=['GET', 'POST'])
@role_required('admin', 'sysadmin', 'limitsysadmin')
def user_add():
form = AddUserForm()
form.reports_list.choices = []
reports = [(report.id, report.name) for report in Report.query.all()]
for r in reports:
if r != (3, 'Partner Channel Account Report'):
form.reports_list.choices.append(r)
# setting conditions
partnership_account_id = current_user.partnership_account_id
current_user_id = current_user.id
if current_user.role == 'admin':
form.role.choices = [('admin', 'Admin'), ('agent', 'Agent')]
from ..partnership.models import ExternalApiServiceProvidersPartnershipAccountTie
ams_2000_account_tie = False
partnership_account_ams_2000_ties = ExternalApiServiceProvidersPartnershipAccountTie.exists_for_service_provider(
partnership_account_id, 'AMS 2000')
if partnership_account_ams_2000_ties:
ams_2000_account_tie = True
ams_2000_exists = UserExternalApiAutoPostTie.get_service_provider_access_state(
current_user_id, partnership_account_id, 'AMS 2000'
)
if ams_2000_exists and ams_2000_exists.is_allowed:
form.ams_2000.data = True
else:
form.ams_2000.data = False
ams_evo_account_tie = False
partnership_account_ams_evo_ties = ExternalApiServiceProvidersPartnershipAccountTie.exists_for_service_provider(
partnership_account_id, 'AMS Evolution')
if partnership_account_ams_evo_ties:
ams_evo_account_tie = True
ams_evolution_user_tie_exists = UserExternalApiAutoPostTie.get_service_provider_access_state(
current_user_id, partnership_account_id, 'AMS Evolution'
)
if ams_evolution_user_tie_exists and ams_evolution_user_tie_exists.is_allowed:
form.ams_evolution.data = True
else:
form.ams_evolution.data = False
neo_verify_account_tie = False
partnership_account_neo_verify_ties = ExternalApiServiceProvidersPartnershipAccountTie.exists_for_service_provider(
partnership_account_id, 'NEO Verify')
if partnership_account_neo_verify_ties:
neo_verify_account_tie = True
neo_verify_user_tie_exists = UserExternalApiAutoPostTie.get_service_provider_access_state(
current_user_id, partnership_account_id, 'NEO Verify'
)
if neo_verify_user_tie_exists and neo_verify_user_tie_exists.is_allowed:
form.neo_verify.data = True
else:
form.neo_verify.data = False
if form.validate_on_submit():
print("inside form submit")
partnership_account_id = current_user.partnership_account_id
is_admin_in_group = current_user.is_admin_user_with_groups
viewing_partnership_account = current_user.is_viewing_partnership
# Check if being viewed by super partner
if is_admin_in_group and viewing_partnership_account:
partnership_account_id = current_user.get_user_viewing_partnership_account_id
from buyercall.blueprints.user.models import User
try:
params = {
'role': 'agent',
'firstname': form.firstname.data,
'lastname': form.lastname.data,
'email': form.email.data,
'company': current_user.company,
'title': form.title.data or '',
'department': form.department.data or '',
'phonenumber': format_phone_number(form.phonenumber.data),
'partnership_id': current_user.partnership_id,
'partnership_account_id': partnership_account_id,
# Set an agent terms of service as true based on BuyerCall TOS
'tos_agreement': True
}
user = User(**params)
user.save()
# Set service provide access
CreateUserUtils().set_service_provider_access(request, partnership_account_id, user.id)
# create reports
CreateUserUtils().add_reports(form, user, db)
# create agent here
CreateUserUtils().add_agent(form, user)
# send welcome and reset password email
reset_token = user.serialize_token()
from buyercall.blueprints.user.tasks import send_agent_invitation_email
send_agent_invitation_email.delay(user.id, reset_token, user.partnership.name,
user.partnership.logo, user.partnership.partner_url)
flash(_('An email has been sent to %(email)s.',
email=user.email), 'success')
return redirect(url_for('admin.users'))
except Exception as e:
print(f"The exception in user_add is {e}")
log.error(traceback.format_exc())
db.session.rollback()
flash(_("Could not create user or agent"), 'danger')
return render_template('admin/user/add_user.jinja2', form=form,
ams_2000_provider_exists=ams_2000_account_tie,
ams_evo_provider_exists=ams_evo_account_tie,
neo_verify_provider_exists=neo_verify_account_tie)