def referral(referral_id):
referral = Referral.query.get_or_404(referral_id)
to_decrypt = Referral.query.filter_by(id=referral_id).with_entities(
Referral.medicare, Referral.secondary).first()
d_medicare = Referral.decrypt_data(to_decrypt.medicare)
d_secondary = Referral.decrypt_data(to_decrypt.secondary)
submitter = User.query.get(referral.user_id)
user = User.query.get(current_user.id)
if referral.source_id == current_user.source_id:
return render_template(
'referrals/referral.html',
title=f"{referral.firstname} {referral.lastname}",
referral=referral,
user=user,
submitter=submitter,
d_medicare=d_medicare,
d_secondary=d_secondary)
elif current_user.role == 'admin':
return render_template(
'referrals/referral.html',
title=f"{referral.firstname} {referral.lastname}",
referral=referral,
user=user,
submitter=submitter,
d_medicare=d_medicare,
d_secondary=d_secondary)
else:
abort(403)
def issue_referral_code_for_user(user):
r = Referral.find_referral_by_uid(user.id)
if r is None:
code = generate_referral_code(user.id)
r = Referral(code=code, user_id=user.id)
db.session.add(r)
db.session.flush()
return r.code
def is_user_can_join_referral_program(user):
r = Referral.find_referral_by_uid(user.id)
# we remove is_valid_email(user.email) temporary
if r is None:
return True
return False
def reward_user_redeem_code(user_id, code):
u = User.find_user_with_id(user_id)
if u is not None and is_valid_email(u.email):
r = Referral.find_referral_by_uid(u.id)
if r is not None:
send_reward_redeem.delay(
u.email, code,
'{}prediction?refer={}'.format(g.BASE_URL, r.code))
def get_referral() -> Optional[Referral]:
"""Get the eventual referral stored in cookie"""
# whether user arrives via a referral
referral = None
if request.cookies:
ref_code = request.cookies.get(_REFERRAL_COOKIE)
referral = Referral.get_by(code=ref_code)
if not referral:
if "slref" in session:
ref_code = session["slref"]
referral = Referral.get_by(code=ref_code)
if referral:
LOG.d("referral found %s", referral)
return referral
def get_referral() -> Optional[Referral]:
"""Get the eventual referral stored in cookie"""
# whether user arrives via a referral
referral = None
if request.cookies:
ref_code = request.cookies.get(_REFERRAL_COOKIE)
referral = Referral.get_by(code=ref_code)
return referral
def user_subscribe():
"""
" 3 use cases:
" Popup subscribe email will appear after user plays on match_id.
" Popup subscribe email will appear at the first time.
" Popup subscribe email will apear when user click on referral link.
"""
try:
data = request.json
if data is None:
return response_error(MESSAGE.INVALID_DATA, CODE.INVALID_DATA)
if 'email' not in data or is_valid_email(data["email"]) is False:
return response_error(MESSAGE.USER_INVALID_EMAIL,
CODE.USER_INVALID_EMAIL)
if user_bl.is_email_subscribed(data['email']):
return response_error(MESSAGE.EMAIL_ALREADY_SUBSCRIBED,
CODE.EMAIL_ALREADY_SUBSCRIBED)
match = Match.find_match_by_id(data.get('match_id', -1))
email = data["email"]
uid = int(request.headers["Uid"])
referral_code = data.get('referral_code', None)
user = User.find_user_with_id(uid)
user.email = email
user.is_user_disable_popup = 0
user.is_subscribe = 1
if referral_code is not None:
r = Referral.find_referral_by_code(referral_code)
if r is not None and r.user_id != uid:
user.invited_by_user = r.user_id
db.session.flush()
# issue referral code for user if any
referral_bl.issue_referral_code_for_user(user)
db.session.commit()
# send email
result, code_1, code_2 = user_bl.claim_redeem_code_for_user(user)
if result:
subscribe_email_to_claim_redeem_code.delay(
email, code_1, code_2, request.headers["Fcm-Token"],
request.headers["Payload"], uid)
elif match is not None:
subscribe_email.delay(email, match.id,
request.headers["Fcm-Token"],
request.headers["Payload"], uid)
return response_ok(user.to_json())
except Exception, ex:
db.session.rollback()
return response_error(ex.message)
def referral_route():
if request.method == "POST":
if request.form.get("form-name") == "create":
code = request.form.get("code")
if re.fullmatch(_REFERRAL_PATTERN, code) is None:
flash(
"At least 3 characters. Only lowercase letters, "
"numbers, dashes (-) and underscores (_) are currently supported.",
"error",
)
return redirect(url_for("dashboard.referral_route"))
if Referral.get_by(code=code):
flash("Code already used", "error")
return redirect(url_for("dashboard.referral_route"))
name = request.form.get("name")
referral = Referral.create(user_id=current_user.id,
code=code,
name=name)
db.session.commit()
flash("A new referral code has been created", "success")
return redirect(
url_for("dashboard.referral_route", highlight_id=referral.id))
elif request.form.get("form-name") == "update":
referral_id = request.form.get("referral-id")
referral = Referral.get(referral_id)
if referral and referral.user_id == current_user.id:
referral.name = request.form.get("name")
db.session.commit()
flash("Referral name updated", "success")
return redirect(
url_for("dashboard.referral_route",
highlight_id=referral.id))
elif request.form.get("form-name") == "delete":
referral_id = request.form.get("referral-id")
referral = Referral.get(referral_id)
if referral and referral.user_id == current_user.id:
Referral.delete(referral.id)
db.session.commit()
flash("Referral deleted", "success")
return redirect(url_for("dashboard.referral_route"))
# Highlight a referral
highlight_id = request.args.get("highlight_id")
if highlight_id:
highlight_id = int(highlight_id)
referrals = Referral.query.filter_by(user_id=current_user.id).all()
# make sure the highlighted referral is the first referral
highlight_index = None
for ix, referral in enumerate(referrals):
if referral.id == highlight_id:
highlight_index = ix
break
if highlight_index:
referrals.insert(0, referrals.pop(highlight_index))
return render_template("dashboard/referral.html", **locals())
def test_user_subscribe_email_with_referral_code(self):
self.clear_data_before_test()
# claim referral code to uid 88
code = '1ABC'
r = Referral.find_referral_by_code(code)
if r is None:
r = Referral(
code=code,
user_id=88
)
db.session.add(r)
else:
r.user_id = 88
db.session.commit()
with self.client:
Uid = 66
params = {
"email": "*****@*****.**",
"referral_code": code
}
response = self.client.post(
'/subscribe',
data=json.dumps(params),
content_type='application/json',
headers={
"Uid": "{}".format(Uid),
"Fcm-Token": "{}".format(123),
"Payload": "{}".format(123),
})
data = json.loads(response.data.decode())
self.assertTrue(data['status'] == 1)
user = User.find_user_with_id(66)
self.assertEqual(user.invited_by_user, 88)
def join_referral_program():
"""
" user joins referral program
"""
try:
uid = int(request.headers['Uid'])
if referral_bl.is_user_can_join_referral_program(
User.find_user_with_id(uid)):
r = Referral(code=referral_bl.generate_referral_code(uid),
user_id=uid)
db.session.add(r)
db.session.commit()
response = r.to_json()
response['referral_link'] = '{}prediction?refer={}'.format(
g.BASE_URL, r.code)
return response_ok(response)
return response_error(MESSAGE.REFERRAL_USER_JOINED_ALREADY,
CODE.REFERRAL_USER_JOINED_ALREADY)
except Exception, ex:
db.session.rollback()
return response_error(ex.message)
def test_check_user_join_referral_program(self):
self.clear_data_before_test()
code = 'A123'
with self.client:
Uid = 88
response = self.client.get('/referral/check',
headers={
"Uid": "{}".format(Uid),
"Fcm-Token": "{}".format(123),
"Payload": "{}".format(123),
})
data = json.loads(response.data.decode())
self.assertTrue(data['status'] == 0)
# generate referral code for user id 88
r = Referral.find_referral_by_code(code)
if r is not None:
r.user_id = 88
else:
r = Referral(code=code, user_id=88)
db.session.add(r)
db.session.commit()
# call again
response = self.client.get('/referral/check',
headers={
"Uid": "{}".format(Uid),
"Fcm-Token": "{}".format(123),
"Payload": "{}".format(123),
})
data = json.loads(response.data.decode())
self.assertTrue(data['status'] == 1)
self.assertEqual(data['data']['code'], code)
def get_channel_statistics(bot, channel_id, db_session):
""" Get information about channel referral program
:param channel_id: telegram channel id
:type channel_id: int
:param db_session: DB session
:type db_session: session
:return: total count of new users, top referrals
:rtype: tuple
"""
logger.debug('Getting stats for <channel:{0}>'.format(channel_id))
new_users = set(Referral.get_new_users(bot, channel_id))
logger.debug('new users from referral program: {0}'.format(new_users))
top_users = db_session \
.query(Referral.inviter_id, Inviter.name, Inviter.first_name, Inviter.last_name) \
.join(Inviter, Referral.inviter_id == Inviter.inviter_id) \
.filter(Referral.channel_id == channel_id) \
.group_by(Referral.inviter_id, Inviter.name, Inviter.first_name, Inviter.last_name) \
.order_by(Referral.inviter_id.desc())
top_users_stats = []
for user_id, username, first_name, last_name in top_users:
invited_users = [
id for id, in db_session.query(Referral.receiver_id).filter_by(
inviter_id=user_id)
]
invited_users = len(set(invited_users) & new_users)
if invited_users:
if not username:
username = '******'.format(first_name, last_name)
top_users_stats.append((username, invited_users))
top_users_stats = sorted(top_users_stats,
key=lambda data: data[1],
reverse=True)
logger.debug('Top users: {0}'.format(top_users_stats))
return len(new_users), top_users_stats
def check_referral():
"""
" check user has joined referral program or not
"""
try:
uid = int(request.headers['Uid'])
r = Referral.find_referral_by_uid(uid)
response = {
"code": None,
"referral_link": None,
"referred_users": referral_bl.all_referred_users_by_user(uid)
}
if r is None:
return response_error(response)
response['code'] = r.code
response['referral_link'] = '{}prediction?refer={}'.format(
g.BASE_URL, r.code)
return response_ok(response)
except Exception, ex:
return response_error(ex.message)
def show_link(bot, update):
""" Callback function, that added link to the CHANNEL for inline message.
Function recieve code from update.callback_query.data and uses it for
determinate channel.
:param bot: bot
:type bot: telegram.Bot
:param update: update event
:type update: relegram.Update
"""
code = update.callback_query.data
inviter_id = db_session.query(ChannelInviter.inviter_id).filter_by(
code=code).first()[0]
# If another user pressed the button (not sender)
# open the link to the channel
if inviter_id != update.callback_query.from_user.id:
channel = db_session.query(ChannelInviter).filter_by(
code=code).first().channel
# If user not in referrals
# (not applyed the refferal link yet) add it to DB
if db_session.query(Referral).filter_by(
receiver_id=update.callback_query.from_user.id,
channel_id=channel.channel_id).count() == 0:
db_session.add(Referral(
inviter_id, channel.channel_id,
receiver_id=update.callback_query.from_user.id))
db_session.commit()
button = InlineKeyboardButton(
ButtonsLabels.GO_TO, url=Links.BASE.format(channel.username))
keyboard = create_inline_keyboard([button])
text = Messages.INLINE_LINK_APPERED.format(channel.username)
update.callback_query.edit_message_text(text=text,
parse_mode=ParseMode.HTML,
reply_markup=keyboard)
return update.callback_query.answer()
def fake_data():
LOG.d("create fake data")
# Remove db if exist
if os.path.exists("db.sqlite"):
LOG.d("remove existing db file")
os.remove("db.sqlite")
# Create all tables
db.create_all()
# Create a user
user = User.create(
email="*****@*****.**",
name="John Wick",
password="******",
activated=True,
is_admin=True,
enable_otp=False,
otp_secret="base32secret3232",
intro_shown=True,
fido_uuid=None,
)
user.include_sender_in_reverse_alias = None
db.session.commit()
user.trial_end = None
LifetimeCoupon.create(code="coupon", nb_used=10, commit=True)
# Create a subscription for user
# Subscription.create(
# user_id=user.id,
# cancel_url="https://checkout.paddle.com/subscription/cancel?user=1234",
# update_url="https://checkout.paddle.com/subscription/update?user=1234",
# subscription_id="123",
# event_time=arrow.now(),
# next_bill_date=arrow.now().shift(days=10).date(),
# plan=PlanEnum.monthly,
# )
# db.session.commit()
CoinbaseSubscription.create(user_id=user.id,
end_at=arrow.now().shift(days=10),
commit=True)
api_key = ApiKey.create(user_id=user.id, name="Chrome")
api_key.code = "code"
api_key = ApiKey.create(user_id=user.id, name="Firefox")
api_key.code = "codeFF"
pgp_public_key = open(get_abs_path("local_data/public-pgp.asc")).read()
m1 = Mailbox.create(
user_id=user.id,
email="*****@*****.**",
verified=True,
pgp_public_key=pgp_public_key,
)
m1.pgp_finger_print = load_public_key(pgp_public_key)
db.session.commit()
for i in range(3):
if i % 2 == 0:
a = Alias.create(email=f"e{i}@{FIRST_ALIAS_DOMAIN}",
user_id=user.id,
mailbox_id=m1.id)
else:
a = Alias.create(
email=f"e{i}@{FIRST_ALIAS_DOMAIN}",
user_id=user.id,
mailbox_id=user.default_mailbox_id,
)
db.session.commit()
if i % 5 == 0:
if i % 2 == 0:
AliasMailbox.create(alias_id=a.id,
mailbox_id=user.default_mailbox_id)
else:
AliasMailbox.create(alias_id=a.id, mailbox_id=m1.id)
db.session.commit()
# some aliases don't have any activity
# if i % 3 != 0:
# contact = Contact.create(
# user_id=user.id,
# alias_id=a.id,
# website_email=f"contact{i}@example.com",
# reply_email=f"rep{i}@sl.local",
# )
# db.session.commit()
# for _ in range(3):
# EmailLog.create(user_id=user.id, contact_id=contact.id)
# db.session.commit()
# have some disabled alias
if i % 5 == 0:
a.enabled = False
db.session.commit()
CustomDomain.create(user_id=user.id, domain="ab.cd", verified=True)
CustomDomain.create(user_id=user.id,
domain="very-long-domain.com.net.org",
verified=True)
db.session.commit()
Directory.create(user_id=user.id, name="abcd")
Directory.create(user_id=user.id, name="xyzt")
db.session.commit()
# Create a client
client1 = Client.create_new(name="Demo", user_id=user.id)
client1.oauth_client_id = "client-id"
client1.oauth_client_secret = "client-secret"
client1.published = True
db.session.commit()
RedirectUri.create(client_id=client1.id, uri="https://ab.com")
client2 = Client.create_new(name="Demo 2", user_id=user.id)
client2.oauth_client_id = "client-id2"
client2.oauth_client_secret = "client-secret2"
client2.published = True
db.session.commit()
ClientUser.create(user_id=user.id, client_id=client1.id, name="Fake Name")
referral = Referral.create(user_id=user.id,
code="REFCODE",
name="First referral")
db.session.commit()
for i in range(6):
Notification.create(user_id=user.id,
message=f"""Hey hey <b>{i}</b> """ * 10)
db.session.commit()
User.create(
email="*****@*****.**",
password="******",
activated=True,
referral_id=referral.id,
)
db.session.commit()
def fake_data():
LOG.d("create fake data")
# Remove db if exist
if os.path.exists("db.sqlite"):
LOG.d("remove existing db file")
os.remove("db.sqlite")
# Create all tables
db.create_all()
# Create a user
user = User.create(
email="*****@*****.**",
name="John Wick",
password="******",
activated=True,
is_admin=True,
# enable_otp=True,
otp_secret="base32secret3232",
intro_shown=True,
fido_uuid=None,
)
user.trial_end = None
db.session.commit()
# add a profile picture
file_path = "profile_pic.svg"
s3.upload_from_bytesio(
file_path,
open(os.path.join(ROOT_DIR, "static", "default-icon.svg"), "rb"),
content_type="image/svg",
)
file = File.create(user_id=user.id, path=file_path, commit=True)
user.profile_picture_id = file.id
db.session.commit()
# create a bounced email
alias = Alias.create_new_random(user)
db.session.commit()
bounce_email_file_path = "bounce.eml"
s3.upload_email_from_bytesio(
bounce_email_file_path,
open(os.path.join(ROOT_DIR, "local_data", "email_tests", "2.eml"), "rb"),
"download.eml",
)
refused_email = RefusedEmail.create(
path=bounce_email_file_path,
full_report_path=bounce_email_file_path,
user_id=user.id,
commit=True,
)
contact = Contact.create(
user_id=user.id,
alias_id=alias.id,
website_email="*****@*****.**",
reply_email="*****@*****.**",
commit=True,
)
EmailLog.create(
user_id=user.id,
contact_id=contact.id,
refused_email_id=refused_email.id,
bounced=True,
commit=True,
)
LifetimeCoupon.create(code="coupon", nb_used=10, commit=True)
# Create a subscription for user
Subscription.create(
user_id=user.id,
cancel_url="https://checkout.paddle.com/subscription/cancel?user=1234",
update_url="https://checkout.paddle.com/subscription/update?user=1234",
subscription_id="123",
event_time=arrow.now(),
next_bill_date=arrow.now().shift(days=10).date(),
plan=PlanEnum.monthly,
commit=True,
)
CoinbaseSubscription.create(
user_id=user.id, end_at=arrow.now().shift(days=10), commit=True
)
api_key = ApiKey.create(user_id=user.id, name="Chrome")
api_key.code = "code"
api_key = ApiKey.create(user_id=user.id, name="Firefox")
api_key.code = "codeFF"
pgp_public_key = open(get_abs_path("local_data/public-pgp.asc")).read()
m1 = Mailbox.create(
user_id=user.id,
email="*****@*****.**",
verified=True,
pgp_public_key=pgp_public_key,
)
m1.pgp_finger_print = load_public_key(pgp_public_key)
db.session.commit()
for i in range(3):
if i % 2 == 0:
a = Alias.create(
email=f"e{i}@{FIRST_ALIAS_DOMAIN}", user_id=user.id, mailbox_id=m1.id
)
else:
a = Alias.create(
email=f"e{i}@{FIRST_ALIAS_DOMAIN}",
user_id=user.id,
mailbox_id=user.default_mailbox_id,
)
db.session.commit()
if i % 5 == 0:
if i % 2 == 0:
AliasMailbox.create(alias_id=a.id, mailbox_id=user.default_mailbox_id)
else:
AliasMailbox.create(alias_id=a.id, mailbox_id=m1.id)
db.session.commit()
# some aliases don't have any activity
# if i % 3 != 0:
# contact = Contact.create(
# user_id=user.id,
# alias_id=a.id,
# website_email=f"contact{i}@example.com",
# reply_email=f"rep{i}@sl.local",
# )
# db.session.commit()
# for _ in range(3):
# EmailLog.create(user_id=user.id, contact_id=contact.id)
# db.session.commit()
# have some disabled alias
if i % 5 == 0:
a.enabled = False
db.session.commit()
CustomDomain.create(user_id=user.id, domain="ab.cd", verified=True)
CustomDomain.create(
user_id=user.id, domain="very-long-domain.com.net.org", verified=True
)
db.session.commit()
Directory.create(user_id=user.id, name="abcd")
Directory.create(user_id=user.id, name="xyzt")
db.session.commit()
# Create a client
client1 = Client.create_new(name="Demo", user_id=user.id)
client1.oauth_client_id = "client-id"
client1.oauth_client_secret = "client-secret"
client1.published = True
db.session.commit()
RedirectUri.create(client_id=client1.id, uri="https://ab.com")
client2 = Client.create_new(name="Demo 2", user_id=user.id)
client2.oauth_client_id = "client-id2"
client2.oauth_client_secret = "client-secret2"
client2.published = True
db.session.commit()
ClientUser.create(user_id=user.id, client_id=client1.id, name="Fake Name")
referral = Referral.create(user_id=user.id, code="REFCODE", name="First referral")
db.session.commit()
for i in range(6):
Notification.create(user_id=user.id, message=f"""Hey hey <b>{i}</b> """ * 10)
db.session.commit()
user2 = User.create(
email="*****@*****.**",
password="******",
activated=True,
referral_id=referral.id,
)
Mailbox.create(user_id=user2.id, email="*****@*****.**", verified=True)
db.session.commit()
ManualSubscription.create(
user_id=user2.id, end_at=arrow.now().shift(years=1, days=1), commit=True
)
def update_referral(referral_id):
referral = Referral.query.get_or_404(referral_id)
user = User.query.get(current_user.id)
if referral.source_id != user.source_id and current_user.role != 'admin':
abort(403)
form = ReferralForm()
if form.validate_on_submit():
referral.firstname = form.firstname.data
referral.lastname = form.lastname.data
referral.phone = form.phone.data
referral.email = form.email.data
referral.dob = form.dob.data
referral.poa_address1 = form.poa_address1.data
referral.city = form.city.data
referral.state = form.state.data
referral.zip_code = form.zip_code.data
referral.medicare = Referral.encrypt_data(form.medicare.data)
referral.secondary = Referral.encrypt_data(form.secondary.data)
referral.discharge_date = form.discharge_date.data
referral.notes = form.notes.data
referral.disc_slp = form.disc_slp.data
referral.disc_ot = form.disc_ot.data
referral.disc_pt = form.disc_pt.data
referral.treat_oral = form.treat_oral.data
referral.treat_speech = form.treat_speech.data
referral.reat_cognitive = form.treat_cognitive.data
referral.treat_caregiver = form.treat_caregiver.data
referral.treat_dementia = form.treat_dementia.data
referral.treat_adl = form.treat_adl.data
referral.treat_safety = form.treat_safety.data
referral.treat_upper_extremity = form.treat_upper_extremity.data
referral.treat_ther_exercise = form.treat_ther_exercise.data
referral.treat_balance = form.treat_balance.data
referral.treat_ther_activity = form.treat_ther_activity.data
referral.treat_coordination = form.treat_coordination.data
referral.treat_transfer = form.treat_transfer.data
referral.treat_range = form.treat_range.data
referral.treat_massage = form.treat_massage.data
referral.treat_pain = form.treat_pain.data
referral.treat_wheelchair = form.treat_wheelchair.data
referral.treat_lower_extremity = form.treat_lower_extremity.data
referral.treat_cane = form.treat_cane.data
referral.treat_postural = form.treat_postural.data
referral.treat_gait = form.treat_gait.data
referral.treat_other = form.treat_other.data
referral.treat_other_desc = form.treat_other_desc.data
referral.med_type = form.med_type.data
referral.med_firstname = form.med_firstname.data
referral.med_lastname = form.med_lastname.data
referral.med_npi = form.med_npi.data
referral.med_phone = form.med_phone.data
referral.med_fax = form.med_fax.data
referral.med_email = form.med_email.data
referral.med_address1 = form.med_address1.data
referral.med_address2 = form.med_address2.data
referral.med_city = form.med_city.data
referral.med_state = form.med_state.data
referral.med_zip_code = form.med_zip_code.data
db.session.commit()
flash('The Referral was updated successfully.', 'success')
return redirect(url_for('referrals.referral', referral_id=referral_id))
elif request.method == 'GET':
form.firstname.data = referral.firstname
form.lastname.data = referral.lastname
form.phone.data = referral.phone
form.email.data = referral.email
form.dob.data = referral.dob
form.poa_address1.data = referral.poa_address1
form.city.data = referral.city
form.state.data = referral.state
form.zip_code.data = referral.zip_code
form.medicare.data = Referral.decrypt_data(referral.medicare)
form.secondary.data = Referral.decrypt_data(referral.secondary)
form.discharge_date.data = referral.discharge_date
form.notes.data = referral.notes
form.disc_slp.data = referral.disc_slp
form.disc_ot.data = referral.disc_ot
form.disc_pt.data = referral.disc_pt
form.treat_oral.data = referral.treat_oral
form.treat_speech.data = referral.treat_speech
form.treat_cognitive.data = referral.treat_cognitive
form.treat_caregiver.data = referral.treat_caregiver
form.treat_dementia.data = referral.treat_dementia
form.treat_adl.data = referral.treat_adl
form.treat_safety.data = referral.treat_safety
form.treat_upper_extremity.data = referral.treat_upper_extremity
form.treat_ther_exercise.data = referral.treat_ther_exercise
form.treat_balance.data = referral.treat_balance
form.treat_ther_activity.data = referral.treat_ther_activity
form.treat_coordination.data = referral.treat_coordination
form.treat_transfer.data = referral.treat_transfer
form.treat_range.data = referral.treat_range
form.treat_massage.data = referral.treat_massage
form.treat_pain.data = referral.treat_pain
form.treat_wheelchair.data = referral.treat_wheelchair
form.treat_lower_extremity.data = referral.treat_lower_extremity
form.treat_cane.data = referral.treat_cane
form.treat_postural.data = referral.treat_postural
form.treat_gait.data = referral.treat_gait
form.treat_other.data = referral.treat_other
form.treat_other_desc.data = referral.treat_other_desc
form.med_type.data = referral.med_type
form.med_firstname.data = referral.med_firstname
form.med_lastname.data = referral.med_lastname
form.med_npi.data = referral.med_npi
form.med_phone.data = referral.med_phone
form.med_fax.data = referral.med_fax
form.med_email.data = referral.med_email
form.med_address1.data = referral.med_address1
form.med_address2.data = referral.med_address2
form.med_city.data = referral.med_city
form.med_state.data = referral.med_state
form.med_zip_code.data = referral.med_zip_code
return render_template('referrals/crud_referral.html',
title='Update Referral',
form=form)
def clear_data_before_test(self):
r = Referral.find_referral_by_uid(88)
if r is not None:
db.session.delete(r)
db.session.commit()
def fake_data():
LOG.d("create fake data")
# Create a user
user = User.create(
email="*****@*****.**",
name="John Wick",
password="******",
activated=True,
is_admin=True,
# enable_otp=True,
otp_secret="base32secret3232",
intro_shown=True,
fido_uuid=None,
)
user.trial_end = None
Session.commit()
# add a profile picture
file_path = "profile_pic.svg"
s3.upload_from_bytesio(
file_path,
open(os.path.join(ROOT_DIR, "static", "default-icon.svg"), "rb"),
content_type="image/svg",
)
file = File.create(user_id=user.id, path=file_path, commit=True)
user.profile_picture_id = file.id
Session.commit()
# create a bounced email
alias = Alias.create_new_random(user)
Session.commit()
bounce_email_file_path = "bounce.eml"
s3.upload_email_from_bytesio(
bounce_email_file_path,
open(os.path.join(ROOT_DIR, "local_data", "email_tests", "2.eml"),
"rb"),
"download.eml",
)
refused_email = RefusedEmail.create(
path=bounce_email_file_path,
full_report_path=bounce_email_file_path,
user_id=user.id,
commit=True,
)
contact = Contact.create(
user_id=user.id,
alias_id=alias.id,
website_email="*****@*****.**",
reply_email="*****@*****.**",
commit=True,
)
EmailLog.create(
user_id=user.id,
contact_id=contact.id,
alias_id=contact.alias_id,
refused_email_id=refused_email.id,
bounced=True,
commit=True,
)
LifetimeCoupon.create(code="lifetime-coupon", nb_used=10, commit=True)
Coupon.create(code="coupon", commit=True)
# Create a subscription for user
Subscription.create(
user_id=user.id,
cancel_url="https://checkout.paddle.com/subscription/cancel?user=1234",
update_url="https://checkout.paddle.com/subscription/update?user=1234",
subscription_id="123",
event_time=arrow.now(),
next_bill_date=arrow.now().shift(days=10).date(),
plan=PlanEnum.monthly,
commit=True,
)
CoinbaseSubscription.create(user_id=user.id,
end_at=arrow.now().shift(days=10),
commit=True)
api_key = ApiKey.create(user_id=user.id, name="Chrome")
api_key.code = "code"
api_key = ApiKey.create(user_id=user.id, name="Firefox")
api_key.code = "codeFF"
pgp_public_key = open(get_abs_path("local_data/public-pgp.asc")).read()
m1 = Mailbox.create(
user_id=user.id,
email="*****@*****.**",
verified=True,
pgp_public_key=pgp_public_key,
)
m1.pgp_finger_print = load_public_key(pgp_public_key)
Session.commit()
# [email protected] is in a LOT of data breaches
Alias.create(email="*****@*****.**",
user_id=user.id,
mailbox_id=m1.id)
for i in range(3):
if i % 2 == 0:
a = Alias.create(email=f"e{i}@{FIRST_ALIAS_DOMAIN}",
user_id=user.id,
mailbox_id=m1.id)
else:
a = Alias.create(
email=f"e{i}@{FIRST_ALIAS_DOMAIN}",
user_id=user.id,
mailbox_id=user.default_mailbox_id,
)
Session.commit()
if i % 5 == 0:
if i % 2 == 0:
AliasMailbox.create(alias_id=a.id,
mailbox_id=user.default_mailbox_id)
else:
AliasMailbox.create(alias_id=a.id, mailbox_id=m1.id)
Session.commit()
# some aliases don't have any activity
# if i % 3 != 0:
# contact = Contact.create(
# user_id=user.id,
# alias_id=a.id,
# website_email=f"contact{i}@example.com",
# reply_email=f"rep{i}@sl.local",
# )
# Session.commit()
# for _ in range(3):
# EmailLog.create(user_id=user.id, contact_id=contact.id, alias_id=contact.alias_id)
# Session.commit()
# have some disabled alias
if i % 5 == 0:
a.enabled = False
Session.commit()
custom_domain1 = CustomDomain.create(user_id=user.id,
domain="ab.cd",
verified=True)
Session.commit()
Alias.create(
user_id=user.id,
email="*****@*****.**",
mailbox_id=user.default_mailbox_id,
custom_domain_id=custom_domain1.id,
commit=True,
)
Alias.create(
user_id=user.id,
email="*****@*****.**",
mailbox_id=user.default_mailbox_id,
custom_domain_id=custom_domain1.id,
commit=True,
)
Directory.create(user_id=user.id, name="abcd")
Directory.create(user_id=user.id, name="xyzt")
Session.commit()
# Create a client
client1 = Client.create_new(name="Demo", user_id=user.id)
client1.oauth_client_id = "client-id"
client1.oauth_client_secret = "client-secret"
Session.commit()
RedirectUri.create(client_id=client1.id,
uri="https://your-website.com/oauth-callback")
client2 = Client.create_new(name="Demo 2", user_id=user.id)
client2.oauth_client_id = "client-id2"
client2.oauth_client_secret = "client-secret2"
Session.commit()
ClientUser.create(user_id=user.id, client_id=client1.id, name="Fake Name")
referral = Referral.create(user_id=user.id,
code="Website",
name="First referral")
Referral.create(user_id=user.id, code="Podcast", name="First referral")
Payout.create(user_id=user.id,
amount=1000,
number_upgraded_account=100,
payment_method="BTC")
Payout.create(
user_id=user.id,
amount=5000,
number_upgraded_account=200,
payment_method="PayPal",
)
Session.commit()
for i in range(6):
Notification.create(user_id=user.id,
message=f"""Hey hey <b>{i}</b> """ * 10)
Session.commit()
user2 = User.create(
email="*****@*****.**",
password="******",
activated=True,
referral_id=referral.id,
)
Mailbox.create(user_id=user2.id,
email="*****@*****.**",
verified=True)
Session.commit()
ManualSubscription.create(
user_id=user2.id,
end_at=arrow.now().shift(years=1, days=1),
comment="Local manual",
commit=True,
)
SLDomain.create(domain="premium.com", premium_only=True, commit=True)
hibp1 = Hibp.create(name="first breach",
description="breach description",
commit=True)
hibp2 = Hibp.create(name="second breach",
description="breach description",
commit=True)
breached_alias1 = Alias.create(email="*****@*****.**",
user_id=user.id,
mailbox_id=m1.id,
commit=True)
breached_alias2 = Alias.create(email="*****@*****.**",
user_id=user.id,
mailbox_id=m1.id,
commit=True)
AliasHibp.create(hibp_id=hibp1.id, alias_id=breached_alias1.id)
AliasHibp.create(hibp_id=hibp2.id, alias_id=breached_alias2.id)
# old domain will have ownership_verified=True
CustomDomain.create(user_id=user.id,
domain="old.com",
verified=True,
ownership_verified=True)
def new_referral():
form = ReferralForm()
if request.method == 'POST':
user = User.query.get(current_user.id)
referral = Referral(
firstname=form.firstname.data,
lastname=form.lastname.data,
phone=form.phone.data,
email=form.email.data,
dob=form.dob.data,
poa_address1=form.poa_address1.data,
city=form.city.data,
state=form.state.data,
zip_code=form.zip_code.data,
medicare=Referral.encrypt_data(form.medicare.data),
secondary=Referral.encrypt_data(form.secondary.data),
discharge_date=form.discharge_date.data,
notes=form.notes.data,
disc_slp=form.disc_slp.data,
disc_ot=form.disc_ot.data,
disc_pt=form.disc_pt.data,
treat_oral=form.treat_oral.data,
treat_speech=form.treat_speech.data,
treat_cognitive=form.treat_cognitive.data,
treat_caregiver=form.treat_caregiver.data,
treat_dementia=form.treat_dementia.data,
treat_adl=form.treat_adl.data,
treat_safety=form.treat_safety.data,
treat_upper_extremity=form.treat_upper_extremity.data,
treat_ther_exercise=form.treat_ther_exercise.data,
treat_balance=form.treat_balance.data,
treat_ther_activity=form.treat_ther_activity.data,
treat_coordination=form.treat_coordination.data,
treat_transfer=form.treat_transfer.data,
treat_range=form.treat_range.data,
treat_massage=form.treat_massage.data,
treat_pain=form.treat_pain.data,
treat_wheelchair=form.treat_wheelchair.data,
treat_lower_extremity=form.treat_lower_extremity.data,
treat_cane=form.treat_cane.data,
treat_postural=form.treat_postural.data,
treat_gait=form.treat_gait.data,
treat_other=form.treat_other.data,
treat_other_desc=form.treat_other_desc.data,
med_type=form.med_type.data,
med_firstname=form.med_firstname.data,
med_lastname=form.med_lastname.data,
med_npi=form.med_npi.data,
med_phone=form.med_phone.data,
med_fax=form.med_fax.data,
med_email=form.med_email.data,
med_address1=form.med_address1.data,
med_address2=form.med_address2.data,
med_city=form.med_city.data,
med_state=form.med_state.data,
med_zip_code=form.med_zip_code.data,
user_id=user.id,
source_id=user.source_id)
db.session.add(referral)
db.session.commit()
referral = Referral.query.get(referral.id)
send_new_referral_email(referral, user)
flash('The Referral was submitted successfully.', 'success')
return redirect(url_for('referrals.list_referrals'))
return render_template('referrals/crud_referral.html',
title='Create Referral',
form=form)
