def test_suggested_emails_for_user_who_cannot_create_new_alias(flask_client):
# make sure user is not in trial
user = User.create(
email="[email protected]",
password="******",
name="Test User",
activated=True,
trial_end=None,
)
db.session.commit()
# make sure user runs out of quota to create new email
for i in range(MAX_NB_EMAIL_FREE_PLAN):
GenEmail.create_new(user_id=user.id, prefix="test")
db.session.commit()
suggested_email, other_emails = user.suggested_emails(website_name="test")
# the suggested email is chosen from existing GenEmail
assert GenEmail.get_by(email=suggested_email)
# all other emails are generated emails
for email in other_emails:
assert GenEmail.get_by(email=email)
def test_out_of_quota(flask_client):
user = User.create(email="[email protected]",
password="******",
name="Test User",
activated=True)
user.trial_end = None
db.session.commit()
# create api_key
api_key = ApiKey.create(user.id, "for test")
db.session.commit()
# create MAX_NB_EMAIL_FREE_PLAN custom alias to run out of quota
for _ in range(MAX_NB_EMAIL_FREE_PLAN):
GenEmail.create_new(user.id, prefix="test")
word = random_word()
r = flask_client.post(
url_for("api.new_custom_alias", hostname="www.test.com"),
headers={"Authentication": api_key.code},
json={
"alias_prefix": "prefix",
"alias_suffix": f".{word}@{EMAIL_DOMAIN}"
},
)
assert r.status_code == 400
assert r.json == {
"error":
"You have reached the limitation of a free account with the maximum of 3 aliases, please upgrade your plan to create more aliases"
}
def test_success_with_pagination(flask_client):
user = User.create(email="[email protected]",
password="******",
name="Test User",
activated=True)
db.session.commit()
# create api_key
api_key = ApiKey.create(user.id, "for test")
db.session.commit()
# create more aliases than PAGE_LIMIT
for _ in range(PAGE_LIMIT + 1):
GenEmail.create_new_random(user.id)
db.session.commit()
# get aliases on the 1st page, should return PAGE_LIMIT aliases
r = flask_client.get(
url_for("api.get_aliases", page_id=0),
headers={"Authentication": api_key.code},
)
assert r.status_code == 200
assert len(r.json["aliases"]) == PAGE_LIMIT
# get aliases on the 2nd page, should return 2 aliases
# as the total number of aliases is PAGE_LIMIT +2
# 1 alias is created when user is created
r = flask_client.get(
url_for("api.get_aliases", page_id=1),
headers={"Authentication": api_key.code},
)
assert r.status_code == 200
assert len(r.json["aliases"]) == 2
def new_custom_alias():
"""
Create a new custom alias
Input:
alias_prefix, for ex "www_groupon_com"
alias_suffix, either [email protected] or @my-domain.com
optional "hostname" in args
optional "note"
Output:
201 if success
409 if the alias already exists
"""
user: User = g.user
if not user.can_create_new_alias():
LOG.d("user %s cannot create any custom alias", user)
return (
jsonify(
error="You have reached the limitation of a free account with the maximum of "
f"{MAX_NB_EMAIL_FREE_PLAN} aliases, please upgrade your plan to create more aliases"
),
400,
)
user_custom_domains = [cd.domain for cd in user.verified_custom_domains()]
hostname = request.args.get("hostname")
data = request.get_json()
if not data:
return jsonify(error="request body cannot be empty"), 400
alias_prefix = data.get("alias_prefix", "").strip()
alias_suffix = data.get("alias_suffix", "").strip()
note = data.get("note")
alias_prefix = convert_to_id(alias_prefix)
if not verify_prefix_suffix(user, alias_prefix, alias_suffix, user_custom_domains):
return jsonify(error="wrong alias prefix or suffix"), 400
full_alias = alias_prefix + alias_suffix
if GenEmail.get_by(email=full_alias):
LOG.d("full alias already used %s", full_alias)
return jsonify(error=f"alias {full_alias} already exists"), 409
gen_email = GenEmail.create(
user_id=user.id, email=full_alias, mailbox_id=user.default_mailbox_id, note=note
)
db.session.commit()
if hostname:
AliasUsedOn.create(gen_email_id=gen_email.id, hostname=hostname)
db.session.commit()
return jsonify(alias=full_alias), 201
def custom_alias():
# check if user has not exceeded the alias quota
if not current_user.can_create_new_alias():
# notify admin
LOG.error("user %s tries to create custom alias", current_user)
flash("ony premium user can choose custom alias", "warning")
return redirect(url_for("dashboard.index"))
user_custom_domains = [cd.domain for cd in current_user.verified_custom_domains()]
# List of (is_custom_domain, alias-suffix)
suffixes = []
# put custom domain first
for alias_domain in user_custom_domains:
suffixes.append((True, "@" + alias_domain))
# then default domain
for domain in ALIAS_DOMAINS:
suffixes.append(
(
False,
("" if DISABLE_ALIAS_SUFFIX else "." + random_word()) + "@" + domain,
)
)
if request.method == "POST":
alias_prefix = request.form.get("prefix")
alias_suffix = request.form.get("suffix")
if verify_prefix_suffix(
current_user, alias_prefix, alias_suffix, user_custom_domains
):
full_alias = alias_prefix + alias_suffix
if GenEmail.get_by(email=full_alias):
LOG.d("full alias already used %s", full_alias)
flash(
f"Alias {full_alias} already exists, please choose another one",
"warning",
)
else:
gen_email = GenEmail.create(user_id=current_user.id, email=full_alias)
db.session.commit()
flash(f"Alias {full_alias} has been created", "success")
session[HIGHLIGHT_GEN_EMAIL_ID] = gen_email.id
return redirect(url_for("dashboard.index"))
# only happen if the request has been "hacked"
else:
flash("something went wrong", "warning")
return render_template("dashboard/custom_alias.html", **locals())
def test_create_contact_route(flask_client):
user = User.create(email="[email protected]",
password="******",
name="Test User",
activated=True)
db.session.commit()
# create api_key
api_key = ApiKey.create(user.id, "for test")
db.session.commit()
gen_email = GenEmail.create_new_random(user)
db.session.commit()
r = flask_client.post(
url_for("api.create_contact_route", alias_id=gen_email.id),
headers={"Authentication": api_key.code},
json={"contact": "First Last <*****@*****.**>"},
)
assert r.status_code == 201
assert r.json["contact"] == "First Last <*****@*****.**>"
assert "creation_date" in r.json
assert "creation_timestamp" in r.json
assert r.json["last_email_sent_date"] is None
assert r.json["last_email_sent_timestamp"] is None
assert r.json["reverse_alias"]
# re-add a contact, should return 409
r = flask_client.post(
url_for("api.create_contact_route", alias_id=gen_email.id),
headers={"Authentication": api_key.code},
json={"contact": "First2 Last2 <*****@*****.**>"},
)
assert r.status_code == 409
def test_custom_mode(flask_client):
user = User.create(email="[email protected]",
password="******",
name="Test User",
activated=True)
db.session.commit()
# create api_key
api_key = ApiKey.create(user.id, "for test")
db.session.commit()
# without note
r = flask_client.post(
url_for("api.new_random_alias", hostname="www.test.com", mode="uuid"),
headers={"Authentication": api_key.code},
)
assert r.status_code == 201
# extract the uuid part
alias = r.json["alias"]
uuid_part = alias[:len(alias) - len(EMAIL_DOMAIN) - 1]
assert is_valid_uuid(uuid_part)
# with note
r = flask_client.post(
url_for("api.new_random_alias", hostname="www.test.com", mode="uuid"),
headers={"Authentication": api_key.code},
json={"note": "test note"},
)
assert r.status_code == 201
alias = r.json["alias"]
ge = GenEmail.get_by(email=alias)
assert ge.note == "test note"
def new_random_alias():
"""
Create a new random alias
Output:
201 if success
"""
user = g.user
if not user.can_create_new_alias():
LOG.d("user %s cannot create new random alias", user)
return (
jsonify(
error=
f"You have reached the limitation of a free account with the maximum of "
f"{MAX_NB_EMAIL_FREE_PLAN} aliases, please upgrade your plan to create more aliases"
),
400,
)
scheme = user.alias_generator
gen_email = GenEmail.create_new_random(user_id=user.id, scheme=scheme)
db.session.commit()
hostname = request.args.get("hostname")
if hostname:
AliasUsedOn.create(gen_email_id=gen_email.id, hostname=hostname)
db.session.commit()
return jsonify(alias=gen_email.email), 201
def domain_detail(custom_domain_id):
custom_domain = CustomDomain.get(custom_domain_id)
if not custom_domain or custom_domain.user_id != current_user.id:
flash("You cannot see this page", "warning")
return redirect(url_for("dashboard.index"))
if request.method == "POST":
if request.form.get("form-name") == "switch-catch-all":
custom_domain.catch_all = not custom_domain.catch_all
db.session.commit()
if custom_domain.catch_all:
flash(
f"The catch-all has been enabled for {custom_domain.domain}",
"success",
)
else:
flash(
f"The catch-all has been disabled for {custom_domain.domain}",
"warning",
)
return redirect(
url_for("dashboard.domain_detail",
custom_domain_id=custom_domain.id))
elif request.form.get("form-name") == "delete":
name = custom_domain.domain
CustomDomain.delete(custom_domain_id)
db.session.commit()
flash(f"Domain {name} has been deleted", "success")
return redirect(url_for("dashboard.custom_domain"))
nb_alias = GenEmail.filter_by(custom_domain_id=custom_domain.id).count()
return render_template("dashboard/domain_detail/info.html", **locals())
def get_alias_log(gen_email: GenEmail, page_id=0):
logs: [AliasLog] = []
mailbox = gen_email.mailbox_email()
q = (db.session.query(ForwardEmail, ForwardEmailLog).filter(
ForwardEmail.id == ForwardEmailLog.forward_id).filter(
ForwardEmail.gen_email_id == gen_email.id).order_by(
ForwardEmailLog.id.desc()).limit(PAGE_LIMIT).offset(
page_id * PAGE_LIMIT))
for fe, fel in q:
al = AliasLog(
website_email=fe.website_email,
website_from=fe.website_from,
alias=gen_email.email,
when=fel.created_at,
is_reply=fel.is_reply,
blocked=fel.blocked,
bounced=fel.bounced,
mailbox=mailbox,
)
logs.append(al)
logs = sorted(logs, key=lambda l: l.when, reverse=True)
return logs
def update_alias(alias_id):
"""
Update alias note
Input:
alias_id: in url
note: in body
Output:
200
"""
data = request.get_json()
if not data:
return jsonify(error="request body cannot be empty"), 400
user = g.user
gen_email: GenEmail = GenEmail.get(alias_id)
if gen_email.user_id != user.id:
return jsonify(error="Forbidden"), 403
new_note = data.get("note")
gen_email.note = new_note
db.session.commit()
return jsonify(note=new_note), 200
def alias_log(alias_id, page_id):
gen_email = GenEmail.get(alias_id)
# sanity check
if not gen_email:
flash("You do not have access to this page", "warning")
return redirect(url_for("dashboard.index"))
if gen_email.user_id != current_user.id:
flash("You do not have access to this page", "warning")
return redirect(url_for("dashboard.index"))
logs = get_alias_log(gen_email, page_id)
base = (db.session.query(ForwardEmail, ForwardEmailLog).filter(
ForwardEmail.id == ForwardEmailLog.forward_id).filter(
ForwardEmail.gen_email_id == gen_email.id))
total = base.count()
email_forwarded = (base.filter(ForwardEmailLog.is_reply == False).filter(
ForwardEmailLog.blocked == False).count())
email_replied = base.filter(ForwardEmailLog.is_reply == True).count()
email_blocked = base.filter(ForwardEmailLog.blocked == True).count()
last_page = (len(logs) < PAGE_LIMIT
) # lightweight pagination without counting all objects
return render_template("dashboard/alias_log.html", **locals())
def get_alias_contacts_route(alias_id):
"""
Get alias contacts
Input:
page_id: in query
Output:
- contacts: list of contacts:
- creation_date
- creation_timestamp
- last_email_sent_date
- last_email_sent_timestamp
- contact
- reverse_alias
"""
user = g.user
try:
page_id = int(request.args.get("page_id"))
except (ValueError, TypeError):
return jsonify(error="page_id must be provided in request query"), 400
gen_email: GenEmail = GenEmail.get(alias_id)
if gen_email.user_id != user.id:
return jsonify(error="Forbidden"), 403
contacts = get_alias_contacts(gen_email, page_id)
return jsonify(contacts=contacts), 200
def test_gen_email_create_random(flask_client):
user = User.create(email="[email protected]",
password="******",
name="Test User",
activated=True)
db.session.commit()
alias = GenEmail.create_new_random(user.id)
assert alias.email.endswith(EMAIL_DOMAIN)
def delete_alias(alias_id):
"""
Delete alias
Input:
alias_id: in url
Output:
200 if deleted successfully
"""
user = g.user
gen_email = GenEmail.get(alias_id)
if gen_email.user_id != user.id:
return jsonify(error="Forbidden"), 403
GenEmail.delete(alias_id)
db.session.commit()
return jsonify(deleted=True), 200
def test_out_of_quota(flask_client):
user = User.create(email="[email protected]",
password="******",
name="Test User",
activated=True)
db.session.commit()
# create api_key
api_key = ApiKey.create(user.id, "for test")
db.session.commit()
# create 3 random alias to run out of quota
for _ in range(MAX_NB_EMAIL_FREE_PLAN):
GenEmail.create_new(user.id, prefix="test1")
GenEmail.create_new(user.id, prefix="test2")
GenEmail.create_new(user.id, prefix="test3")
r = flask_client.post(
url_for("api.new_random_alias", hostname="www.test.com"),
headers={"Authentication": api_key.code},
)
assert r.status_code == 400
assert (
r.json["error"] ==
"You have reached the limitation of a free account with the maximum of 3 aliases, please upgrade your plan to create more aliases"
)
def test_out_of_quota(flask_client):
user = User.create(email="[email protected]",
password="******",
name="Test User",
activated=True)
db.session.commit()
# create api_key
api_key = ApiKey.create(user.id, "for test")
db.session.commit()
# create 3 custom alias to run out of quota
GenEmail.create_new(user.id, prefix="test")
GenEmail.create_new(user.id, prefix="test")
GenEmail.create_new(user.id, prefix="test")
r = flask_client.post(
url_for("api.new_custom_alias", hostname="www.test.com"),
headers={"Authentication": api_key.code},
json={
"alias_prefix": "prefix",
"alias_suffix": f".abcdef@{EMAIL_DOMAIN}"
},
)
assert r.status_code == 400
assert r.json == {
"error":
"You have created 3 custom aliases, please upgrade to create more"
}
def try_auto_create_directory(alias: str) -> Optional[GenEmail]:
"""
Try to create an alias with directory
"""
# check if alias belongs to a directory, ie having directory/anything@EMAIL_DOMAIN format
if email_belongs_to_alias_domains(alias):
# if there's no directory separator in the alias, no way to auto-create it
if "/" not in alias and "+" not in alias and "#" not in alias:
return None
# alias contains one of the 3 special directory separator: "/", "+" or "#"
if "/" in alias:
sep = "/"
elif "+" in alias:
sep = "+"
else:
sep = "#"
directory_name = alias[: alias.find(sep)]
LOG.d("directory_name %s", directory_name)
directory = Directory.get_by(name=directory_name)
if not directory:
return None
dir_user: User = directory.user
if not dir_user.can_create_new_alias():
send_cannot_create_directory_alias(dir_user, alias, directory_name)
return None
# if alias has been deleted before, do not auto-create it
if DeletedAlias.get_by(email=alias, user_id=directory.user_id):
LOG.warning(
"Alias %s was deleted before, cannot auto-create using directory %s, user %s",
alias,
directory_name,
dir_user,
)
return None
LOG.d("create alias %s for directory %s", alias, directory)
gen_email = GenEmail.create(
email=alias,
user_id=directory.user_id,
directory_id=directory.id,
mailbox_id=dir_user.default_mailbox_id,
)
db.session.commit()
return gen_email
def test_alias_contacts(flask_client):
user = User.create(email="[email protected]",
password="******",
name="Test User",
activated=True)
db.session.commit()
# create api_key
api_key = ApiKey.create(user.id, "for test")
db.session.commit()
gen_email = GenEmail.create_new_random(user)
db.session.commit()
# create some alias log
for i in range(PAGE_LIMIT + 1):
forward_email = ForwardEmail.create(
website_email=f"marketing-{i}@example.com",
reply_email=f"reply-{i}@a.b",
gen_email_id=gen_email.id,
)
db.session.commit()
ForwardEmailLog.create(forward_id=forward_email.id, is_reply=True)
db.session.commit()
r = flask_client.get(
url_for("api.get_alias_contacts_route",
alias_id=gen_email.id,
page_id=0),
headers={"Authentication": api_key.code},
)
assert r.status_code == 200
assert len(r.json["contacts"]) == PAGE_LIMIT
for ac in r.json["contacts"]:
assert ac["creation_date"]
assert ac["creation_timestamp"]
assert ac["last_email_sent_date"]
assert ac["last_email_sent_timestamp"]
assert ac["contact"]
assert ac["reverse_alias"]
# second page, should return 1 result only
r = flask_client.get(
url_for("api.get_alias_contacts_route",
alias_id=gen_email.id,
page_id=1),
headers={"Authentication": api_key.code},
)
assert len(r.json["contacts"]) == 1
def create_contact_route(alias_id):
"""
Create contact for an alias
Input:
alias_id: in url
contact: in body
Output:
201 if success
409 if contact already added
"""
data = request.get_json()
if not data:
return jsonify(error="request body cannot be empty"), 400
user = g.user
gen_email: GenEmail = GenEmail.get(alias_id)
if gen_email.user_id != user.id:
return jsonify(error="Forbidden"), 403
contact_email = data.get("contact")
# generate a reply_email, make sure it is unique
# not use while to avoid infinite loop
reply_email = f"ra+{random_string(25)}@{EMAIL_DOMAIN}"
for _ in range(1000):
reply_email = f"ra+{random_string(25)}@{EMAIL_DOMAIN}"
if not ForwardEmail.get_by(reply_email=reply_email):
break
website_email = get_email_part(contact_email)
# already been added
if ForwardEmail.get_by(gen_email_id=gen_email.id,
website_email=website_email):
return jsonify(error="Contact already added"), 409
forward_email = ForwardEmail.create(
gen_email_id=gen_email.id,
website_email=website_email,
website_from=contact_email,
reply_email=reply_email,
)
LOG.d("create reverse-alias for %s %s", contact_email, gen_email)
db.session.commit()
return jsonify(**serialize_forward_email(forward_email)), 201
def alias_log(alias):
gen_email = GenEmail.get_by(email=alias)
# sanity check
if not gen_email:
flash("You do not have access to this page", "warning")
return redirect(url_for("dashboard.index"))
if gen_email.user_id != current_user.id:
flash("You do not have access to this page", "warning")
return redirect(url_for("dashboard.index"))
return render_template("dashboard/alias_log.html",
logs=get_alias_log(gen_email),
alias=alias)
def get_alias_activities(alias_id):
"""
Get aliases
Input:
page_id: in query
Output:
- activities: list of activity:
- from
- to
- timestamp
- action: forward|reply|block
"""
user = g.user
try:
page_id = int(request.args.get("page_id"))
except (ValueError, TypeError):
return jsonify(error="page_id must be provided in request query"), 400
gen_email: GenEmail = GenEmail.get(alias_id)
if gen_email.user_id != user.id:
return jsonify(error="Forbidden"), 403
alias_logs = get_alias_log(gen_email, page_id)
activities = []
for alias_log in alias_logs:
activity = {"timestamp": alias_log.when.timestamp}
if alias_log.is_reply:
activity["from"] = alias_log.alias
activity["to"] = alias_log.website_from or alias_log.website_email
activity["action"] = "reply"
else:
activity["to"] = alias_log.alias
activity[
"from"] = alias_log.website_from or alias_log.website_email
if alias_log.bounced:
activity["action"] = "bounced"
elif alias_log.blocked:
activity["action"] = "block"
else:
activity["action"] = "forward"
activities.append(activity)
return jsonify(activities=activities), 200
def test_alias_activities(flask_client):
user = User.create(email="[email protected]",
password="******",
name="Test User",
activated=True)
db.session.commit()
# create api_key
api_key = ApiKey.create(user.id, "for test")
db.session.commit()
gen_email = GenEmail.create_new_random(user.id)
db.session.commit()
# create some alias log
forward_email = ForwardEmail.create(
website_email="*****@*****.**",
reply_email="[email protected]",
gen_email_id=gen_email.id,
)
db.session.commit()
for _ in range(int(PAGE_LIMIT / 2)):
ForwardEmailLog.create(forward_id=forward_email.id, is_reply=True)
for _ in range(int(PAGE_LIMIT / 2) + 2):
ForwardEmailLog.create(forward_id=forward_email.id, blocked=True)
r = flask_client.get(
url_for("api.get_alias_activities", alias_id=gen_email.id, page_id=0),
headers={"Authentication": api_key.code},
)
assert r.status_code == 200
assert len(r.json["activities"]) == PAGE_LIMIT
for ac in r.json["activities"]:
assert ac["action"]
assert ac["from"]
assert ac["action"]
assert ac["action"]
# second page, should return 1 or 2 results only
r = flask_client.get(
url_for("api.get_alias_activities", alias_id=gen_email.id, page_id=1),
headers={"Authentication": api_key.code},
)
assert len(r.json["activities"]) < 3
def test_different_scenarios(flask_client):
user = User.create(email="[email protected]",
password="******",
name="Test User",
activated=True)
db.session.commit()
# create api_key
api_key = ApiKey.create(user.id, "for test")
db.session.commit()
# <<< without hostname >>>
r = flask_client.get(url_for("api.options"),
headers={"Authentication": api_key.code})
# {
# "can_create_custom": True,
# "custom": {"suffixes": ["*****@*****.**"], "suggestion": ""},
# "existing": ["*****@*****.**"],
# }
assert r.status_code == 200
assert r.json["can_create_custom"]
assert len(r.json["existing"]) == 1
assert len(r.json["custom"]["suffixes"]) == 3
assert r.json["custom"]["suggestion"] == "" # no hostname => no suggestion
# <<< with hostname >>>
r = flask_client.get(
url_for("api.options", hostname="www.test.com"),
headers={"Authentication": api_key.code},
)
assert r.json["custom"]["suggestion"] == "test"
# <<< with recommendation >>>
alias = GenEmail.create_new(user.id, prefix="test")
db.session.commit()
AliasUsedOn.create(gen_email_id=alias.id, hostname="www.test.com")
db.session.commit()
r = flask_client.get(
url_for("api.options", hostname="www.test.com"),
headers={"Authentication": api_key.code},
)
assert r.json["recommendation"]["alias"] == alias.email
assert r.json["recommendation"]["hostname"] == "www.test.com"
def new_random_alias():
"""
Create a new random alias
Input:
(Optional) note
Output:
201 if success
"""
user = g.user
if not user.can_create_new_alias():
LOG.d("user %s cannot create new random alias", user)
return (
jsonify(
error=
f"You have reached the limitation of a free account with the maximum of "
f"{MAX_NB_EMAIL_FREE_PLAN} aliases, please upgrade your plan to create more aliases"
),
400,
)
note = None
data = request.get_json(silent=True)
if data:
note = data.get("note")
scheme = user.alias_generator
mode = request.args.get("mode")
if mode:
if mode == "word":
scheme = AliasGeneratorEnum.word.value
elif mode == "uuid":
scheme = AliasGeneratorEnum.uuid.value
else:
return jsonify(error=f"{mode} must be either word or alias"), 400
gen_email = GenEmail.create_new_random(user=user, scheme=scheme, note=note)
db.session.commit()
hostname = request.args.get("hostname")
if hostname:
AliasUsedOn.create(gen_email_id=gen_email.id, hostname=hostname)
db.session.commit()
return jsonify(alias=gen_email.email), 201
def try_auto_create_catch_all_domain(alias: str) -> Optional[GenEmail]:
"""Try to create an alias with catch-all domain"""
# try to create alias on-the-fly with custom-domain catch-all feature
# check if alias is custom-domain alias and if the custom-domain has catch-all enabled
alias_domain = get_email_domain_part(alias)
custom_domain = CustomDomain.get_by(domain=alias_domain)
if not custom_domain:
return None
# custom_domain exists
if not custom_domain.catch_all:
return None
# custom_domain has catch-all enabled
domain_user: User = custom_domain.user
if not domain_user.can_create_new_alias():
send_cannot_create_domain_alias(domain_user, alias, alias_domain)
return None
# if alias has been deleted before, do not auto-create it
if DeletedAlias.get_by(email=alias, user_id=custom_domain.user_id):
LOG.warning(
"Alias %s was deleted before, cannot auto-create using domain catch-all %s, user %s",
alias,
custom_domain,
domain_user,
)
return None
LOG.d("create alias %s for domain %s", alias, custom_domain)
gen_email = GenEmail.create(
email=alias,
user_id=custom_domain.user_id,
custom_domain_id=custom_domain.id,
automatic_creation=True,
mailbox_id=domain_user.default_mailbox_id,
)
db.session.commit()
return gen_email
def test_different_scenarios_v2(flask_client):
user = User.create(email="[email protected]",
password="******",
name="Test User",
activated=True)
db.session.commit()
# create api_key
api_key = ApiKey.create(user.id, "for test")
db.session.commit()
# <<< without hostname >>>
r = flask_client.get(url_for("api.options_v2"),
headers={"Authentication": api_key.code})
assert r.status_code == 200
# {'can_create': True, 'existing': ['*****@*****.**'], 'prefix_suggestion': '', 'suffixes': ['*****@*****.**']}
assert r.json["can_create"]
assert len(r.json["existing"]) == 1
assert r.json["suffixes"]
assert r.json["prefix_suggestion"] == "" # no hostname => no suggestion
# <<< with hostname >>>
r = flask_client.get(
url_for("api.options_v2", hostname="www.test.com"),
headers={"Authentication": api_key.code},
)
assert r.json["prefix_suggestion"] == "test"
# <<< with recommendation >>>
alias = GenEmail.create_new(user.id, prefix="test")
db.session.commit()
AliasUsedOn.create(gen_email_id=alias.id, hostname="www.test.com")
db.session.commit()
r = flask_client.get(
url_for("api.options_v2", hostname="www.test.com"),
headers={"Authentication": api_key.code},
)
assert r.json["recommendation"]["alias"] == alias.email
assert r.json["recommendation"]["hostname"] == "www.test.com"
def test_toggle_alias(flask_client):
user = User.create(email="[email protected]",
password="******",
name="Test User",
activated=True)
db.session.commit()
# create api_key
api_key = ApiKey.create(user.id, "for test")
db.session.commit()
gen_email = GenEmail.create_new_random(user.id)
db.session.commit()
r = flask_client.post(
url_for("api.toggle_alias", alias_id=gen_email.id),
headers={"Authentication": api_key.code},
)
assert r.status_code == 200
assert r.json == {"enabled": False}
def toggle_alias(alias_id):
"""
Enable/disable alias
Input:
alias_id: in url
Output:
200 along with new status:
- enabled
"""
user = g.user
gen_email: GenEmail = GenEmail.get(alias_id)
if gen_email.user_id != user.id:
return jsonify(error="Forbidden"), 403
gen_email.enabled = not gen_email.enabled
db.session.commit()
return jsonify(enabled=gen_email.enabled), 200
def unsubscribe(gen_email_id):
gen_email = GenEmail.get(gen_email_id)
if not gen_email:
flash("Incorrect link. Redirect you to the home page", "warning")
return redirect(url_for("dashboard.index"))
if gen_email.user_id != current_user.id:
flash(
"You don't have access to this page. Redirect you to the home page",
"warning",
)
return redirect(url_for("dashboard.index"))
# automatic unsubscribe, according to https://tools.ietf.org/html/rfc8058
if request.method == "POST":
gen_email.enabled = False
flash(f"Alias {gen_email.email} has been blocked", "success")
db.session.commit()
return redirect(url_for("dashboard.index"))
else: # ask user confirmation
return render_template("dashboard/unsubscribe.html",
alias=gen_email.email)
