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)