Bloated commit, includes refactoring and account claims

hiboo/__init__.py

@@ -30,8 +30,10 @@ def create_app_from_config(config):
         return dict(config=app.config, utils=utils)
 
     # Import views
-    from hiboo import account, service, sso
+    from hiboo import account, user, identity, service, sso
     app.register_blueprint(account.blueprint, url_prefix='/account')
+    app.register_blueprint(user.blueprint, url_prefix='/user')
+    app.register_blueprint(identity.blueprint, url_prefix='/identity')
     app.register_blueprint(service.blueprint, url_prefix='/service')
     app.register_blueprint(sso.blueprint, url_prefix='/sso')
 

hiboo/account/__init__.py

-from flask import Blueprint
+import flask
 
 
-blueprint = Blueprint("account", __name__, template_folder="templates")
+blueprint = flask.Blueprint("account", __name__, template_folder="templates")
 
-from hiboo.account import login, profiles, settings
+from hiboo.account import login, home, settings

hiboo/account/forms.py

-from wtforms import validators, fields, widgets
+from wtforms import validators, fields
 from flask_babel import lazy_gettext as _
 
 import flask_wtf
@@ -28,17 +28,3 @@ class PasswordForm(flask_wtf.FlaskForm):
     password2 = fields.PasswordField(_('Confirm new password'),
         [validators.DataRequired(), validators.EqualTo('password')])
     submit = fields.SubmitField(_('Change password'))
-
-
-class ProfileForm(flask_wtf.FlaskForm):
-    username = fields.StringField(_('Username'), [validators.DataRequired()])
-    comment = fields.StringField(_('Comment'))
-    submit = fields.SubmitField(_('Create profile'))
-
-
-class ProfilePickForm(flask_wtf.FlaskForm):
-    profile_uuid = fields.TextField('profile', [])
-
-
-class AvatarForm(flask_wtf.FlaskForm):
-    submit = fields.SubmitField(_('Sign up'), [])

hiboo/account/home.py

+from hiboo.account import blueprint
+from hiboo import security
+
+import flask
+import flask_login
+
+
+@blueprint.route("/home")
+@security.authentication_required()
+def home():
+    history = flask_login.current_user.history
+    return flask.render_template("account_home.html", history=history)

hiboo/account/profiles.py

-from hiboo.account import blueprint, forms
-from hiboo.sso import forms as sso_forms
-from hiboo import models, utils, security
-
-import flask
-import flask_login
-
-
-def get_profile(service, **redirect_args):
-    form = forms.ProfilePickForm()
-    if form.validate_on_submit():
-        profile = models.Profile.query.get(form.profile_uuid.data)
-        if not (profile.user == flask_login.current_user and
-                profile.service == service and
-                profile.status == models.Profile.ACTIVE):
-            return None
-        return profile
-    next = ("account.pick_avatar" if service.max_profiles == 0
-            else "account.pick_profile")
-    utils.force_redirect(utils.url_for(next, **redirect_args))
-
-
-@blueprint.route("/profile/pick")
-@security.authentication_required()
-def pick_profile():
-    service_uuid = flask.request.args.get("service_uuid") or flask.abort(404)
-    service = models.Service.query.get(service_uuid) or flask.abort(404)
-    profiles = models.Profile.filter(service, flask_login.current_user).all()
-    form = forms.ProfilePickForm()
-    return flask.render_template("profile_pick.html",
-        service=service, profiles=profiles, form=form,
-        action_create=utils.url_for("account.create_profile", intent="account.pick_profile"),
-        action_pick=utils.url_or_intent("account.home"))
-
-
-@blueprint.route("/profile/create", methods=["GET", "POST"])
-@security.authentication_required()
-def create_profile():
-    service_uuid = flask.request.args.get("service_uuid") or flask.abort(404)
-    service = models.Service.query.get(service_uuid) or flask.abort(404)
-    status = models.Profile.ACTIVE
-    profiles = models.Profile.filter(service, flask_login.current_user).all()
-    # Do not create profile for reserved or locked services
-    if service.policy in (models.Service.RESERVED, models.Service.LOCKED):
-        flask.flash("You cannot request a profile for this service", "danger")
-        return flask.redirect(flask.url_for("account.home"))
-    # Only burst services are allowed to exceed profile count
-    elif len(profiles) >= service.max_profiles and service.policy != models.Service.BURST:
-        flask.flash("Your reached the maximum number of profiles", "danger")
-        return flask.redirect(flask.url_for("account.home"))
-    # Managed services and bursting accounts require approval
-    elif len(profiles) >= service.max_profiles or service.policy == models.Service.MANAGED:
-        flask.flash("Your profile creation requires approval", "warning")
-        status = models.Profile.REQUEST
-    # Actually display the form
-    form = forms.ProfileForm()
-    if form.validate_on_submit():
-        conflict = models.Profile.query.filter_by(
-            service_uuid=service_uuid, username=form.username.data
-        ).first()
-        if conflict:
-            flask.flash("A profile with that username exists already", "danger")
-        else:
-            profile = models.Profile()
-            profile.username = form.username.data
-            profile.user = flask_login.current_user
-            profile.service = service
-            profile.comment = form.comment.data
-            profile.status = status
-            models.db.session.add(profile)
-            models.log(models.History.CREATE, profile.username, profile.comment,
-                user=flask_login.current_user, service=service, profile=profile)
-            models.db.session.commit()
-            return flask.redirect(utils.url_or_intent("account.home"))
-    return flask.render_template("profile_create.html", form=form, service=service)
-
-
-@blueprint.route("/avatar/pick")
-@security.authentication_required()
-def pick_avatar():
-    service_uuid = flask.request.args.get("service_uuid") or flask.abort(404)
-    service = models.Service.query.get(service_uuid) or flask.abort(404)
-    avatar = models.Profile.filter(service, flask_login.current_user).first()
-    form = forms.ProfilePickForm()
-    if avatar:
-        if avatar.status == models.Profile.REQUEST:
-            flask.flash("Your account request is awaiting approval", "warning")
-            return flask.redirect(fflask.url_for("account.home"))
-        elif avatar.status == models.Profile.BLOCKED:
-            flask.flash("You are currently blocked", "danger")
-            return flask.redirect(fflask.url_for("account.home"))
-        elif avatar.status in (models.Profile.DELETED, models.Profile.UNCLAIMED):
-            flask.flash("Your avatar is unavailable", "danger")
-            return flask.redirect(fflask.url_for("account.home"))
-    elif service.policy not in (models.Service.OPEN, models.Service.MANAGED):
-        flask.flash("You cannot access this service", "danger")
-        return flask.redirect(fflask.url_for("account.home"))
-    else:
-        return flask.redirect(utils.url_for("account.create_avatar", intent="account.pick_avatar"))
-    return flask.render_template("avatar_pick.html",
-        service=service, avatar=avatar, form=form,
-        action_pick=utils.url_or_intent("account.home"),
-        action_create=utils.url_for("account.create_avatar", intent="account.pick_avatar"))
-
-
-@blueprint.route("/avatar/create", methods=["GET", "POST"])
-@security.authentication_required()
-def create_avatar():
-    service_uuid = flask.request.args.get("service_uuid") or flask.abort(404)
-    service = models.Service.query.get(service_uuid) or flask.abort(404)
-    # Cannot create an avatar if one exists already
-    existing = models.Profile.filter(service, flask_login.current_user).first()
-    existing and flask.abort(403)
-    # Cannot create an avatar for anything but a managed or open service
-    if service.policy == models.Service.OPEN:
-        status = models.Profile.ACTIVE
-    elif service.policy == models.Service.MANAGED:
-        status = models.Profile.REQUEST
-    else:
-        flask.abort(403)
-    form = forms.AvatarForm()
-    if form.validate_on_submit():
-        avatar = models.Profile()
-        avatar.username = flask_login.current_user.username
-        avatar.user = flask_login.current_user
-        avatar.service = service
-        avatar.status = models.Profile.ACTIVE
-        models.db.session.add(avatar)
-        models.db.session.commit()
-        return flask.redirect(utils.url_or_intent("account.home"))
-    return flask.render_template("avatar_create.html", form=form, service=service)

hiboo/account/settings.py

@@ -5,13 +5,6 @@ import flask
 import flask_login
 
 
-@blueprint.route("/home")
-@security.authentication_required()
-def home():
-    history = flask_login.current_user.history
-    return flask.render_template("account_home.html", history=history)
-
-
 @blueprint.route("/password", methods=["GET", "POST"])
 @security.authentication_required()
 def password():

hiboo/account/templates/account_home.html

@@ -12,7 +12,7 @@
           {{ macros.infobox("Account age", "{} days".format((current_user.created_at.today() - current_user.created_at).total_seconds() // 86400), "aqua", "calendar") }}
         </div>
         <div class="col-md-6 col-xs-12">
-          {{ macros.infobox("Profile count", current_user.profiles.__len__(), "red", "users") }}
+          {{ macros.infobox("Identity count", current_user.identities.__len__(), "red", "users") }}
         </div>
       </div>
       <div class="row">

hiboo/identity/__init__.py

+import flask
+
+
+blueprint = flask.Blueprint("identity", __name__, template_folder="templates")
+
+import flask_login
+from hiboo import models, utils
+from hiboo.identity import profiles, avatars, forms
+
+
+def get_identity(service, **redirect_args):
+    form = forms.IdentityPickForm()
+    if form.validate_on_submit():
+        identity = models.Identity.query.get(form.identity_uuid.data)
+        if not (identity and
+                identity.user == flask_login.current_user and
+                identity.service == service and
+                identity.status == models.Identity.ACTIVE):
+            return None
+        return identity
+    next = ("identity.pick_avatar" if service.max_profiles == 0
+            else "identity.pick_profile")
+    utils.force_redirect(utils.url_for(next, **redirect_args))

hiboo/identity/avatars.py

+from hiboo.identity import blueprint, forms
+from hiboo import models, utils, security
+
+import flask
+import flask_login
+
+
+@blueprint.route("/avatar/pick/<service_uuid>")
+@security.authentication_required()
+def pick_avatar(service_uuid):
+    service = models.Service.query.get(service_uuid) or flask.abort(404)
+    service.max_profiles == 0 or flask.abort(404)
+    avatar = models.Identity.filter(service, flask_login.current_user).first()
+    form = forms.IdentityPickForm()
+    if avatar:
+        if avatar.status == models.Identity.REQUEST:
+            flask.flash("Your account request is awaiting approval", "warning")
+            return flask.redirect(fflask.url_for("account.home"))
+        elif avatar.status == models.Identity.BLOCKED:
+            flask.flash("You are currently blocked", "danger")
+            return flask.redirect(fflask.url_for("account.home"))
+        elif avatar.status in (models.Identity.DELETED, models.Identity.UNCLAIMED):
+            flask.flash("Your avatar is unavailable", "danger")
+            return flask.redirect(fflask.url_for("account.home"))
+    elif service.policy not in (models.Service.OPEN, models.Service.MANAGED):
+        flask.flash("You cannot access this service", "danger")
+        return flask.redirect(fflask.url_for("account.home"))
+    else:
+        return flask.redirect(utils.url_for("identity.create_avatar", intent=True))
+    return flask.render_template("avatar_pick.html", service=service, avatar=avatar, form=form)
+
+
+@blueprint.route("/avatar/create/<service_uuid>", methods=["GET", "POST"])
+@security.authentication_required()
+def create_avatar(service_uuid):
+    service = models.Service.query.get(service_uuid) or flask.abort(404)
+    service.max_profiles == 0 or flask.abort(404)
+    # Cannot create an avatar if one exists already
+    models.Identity.filter(service, flask_login.current_user).first() and flask.abort(403)
+    # Cannot create an avatar for anything but a managed or open service
+    if service.policy == models.Service.OPEN:
+        status = models.Identity.ACTIVE
+    elif service.policy == models.Service.MANAGED:
+        status = models.Identity.REQUEST
+    else:
+        flask.abort(403)
+    form = forms.AvatarForm()
+    if form.validate_on_submit():
+        avatar = models.Identity()
+        avatar.username = flask_login.current_user.username
+        avatar.user = flask_login.current_user
+        avatar.service = service
+        avatar.status = models.Identity.ACTIVE
+        models.db.session.add(avatar)
+        models.db.session.commit()
+        return flask.redirect(utils.url_or_intent("account.home"))
+    return flask.render_template("avatar_create.html", form=form, service=service)

hiboo/identity/forms.py

+from wtforms import validators, fields
+from flask_babel import lazy_gettext as _
+
+import flask_wtf
+
+
+class ProfileForm(flask_wtf.FlaskForm):
+    username = fields.StringField(_('Username'), [validators.DataRequired()])
+    comment = fields.StringField(_('Comment'))
+    submit = fields.SubmitField(_('Create profile'))
+
+
+class IdentityPickForm(flask_wtf.FlaskForm):
+    identity_uuid = fields.TextField('identity', [])
+
+
+class AvatarForm(flask_wtf.FlaskForm):
+    submit = fields.SubmitField(_('Sign up'), [])
+
+
+class ClaimForm(flask_wtf.FlaskForm):
+    username = fields.StringField(_('Username'), [validators.DataRequired()])
+    password = fields.PasswordField(_('Password'), [validators.DataRequired()])
+    submit = fields.SubmitField(_('Claim profile'))

hiboo/identity/profiles.py

+from hiboo.identity import blueprint, forms
+from hiboo import models, utils, security
+from hiboo import user as hiboo_user
+from passlib import context, hash
+
+import flask
+import flask_login
+
+
+@blueprint.route("/profile/pick/<service_uuid>")
+@security.authentication_required()
+def pick_profile(service_uuid):
+    service = models.Service.query.get(service_uuid) or flask.abort(404)
+    service.max_profiles > 0 or flask.abort(404)
+    profiles = models.Identity.filter(service, flask_login.current_user).all()
+    form = forms.IdentityPickForm()
+    return flask.render_template("profile_pick.html", service=service, profiles=profiles, form=form)
+
+
+@blueprint.route("/profile/create_for/<service_uuid>", methods=["GET", "POST"], defaults={"create_for": True}, endpoint="create_profile_for")
+@blueprint.route("/profile/create/<service_uuid>", methods=["GET", "POST"])
+@security.authentication_required()
+def create_profile(service_uuid, create_for=False):
+    service = models.Service.query.get(service_uuid) or flask.abort(404)
+    service.max_profiles > 0 or flask.abort(404)
+    status = models.Identity.ACTIVE
+    # If the admin passed a user uuid, use that one, otherwise ignore it
+    if create_for and flask_login.current_user.is_admin:
+        user = hiboo_user.get_user(intent="identity.create_profile_for", create_for=None)
+    else:
+        user = flask_login.current_user
+    # Do not create profile for locked services
+    if service.policy == models.Service.LOCKED:
+        flask.flash("You cannot request a profile for this service", "danger")
+        return flask.redirect(flask.url_for("account.home"))
+    # Other restrictions do not apply to admins or managers
+    if not flask_login.current_user.is_admin:
+        profiles = models.Identity.filter(service, user).all()
+        # Do not create profile for locked services
+        if service.policy == models.Service.RESERVED:
+            flask.flash("You cannot request a profile for this service", "danger")
+            return flask.redirect(flask.url_for("account.home"))
+        # Only burst services are allowed to exceed profile count
+        elif len(profiles) >= service.max_profiles and service.policy != models.Service.BURST:
+            flask.flash("Your reached the maximum number of profiles", "danger")
+            return flask.redirect(flask.url_for("account.home"))
+        # Managed services and bursting accounts require approval
+        elif len(profiles) >= service.max_profiles or service.policy == models.Service.MANAGED:
+            flask.flash("Your profile creation requires approval", "warning")
+            status = models.Profile.REQUEST
+    # Actually display the form
+    form = forms.ProfileForm()
+    if form.validate_on_submit():
+        existing = models.Identity.query.filter_by(
+            service_uuid=service_uuid, username=form.username.data
+        ).first()
+        if existing:
+            flask.flash("A profile with that username exists already", "danger")
+        else:
+            profile = models.Identity()
+            profile.username = form.username.data
+            profile.user = user
+            profile.service = service
+            profile.comment = form.comment.data
+            profile.status = status
+            models.db.session.add(profile)
+            models.log(models.History.CREATE, profile.username, profile.comment,
+                user=user, service=service, identity=profile)
+            models.db.session.commit()
+            return flask.redirect(utils.url_or_intent("account.home"))
+    return flask.render_template("profile_create.html", form=form, service=service,
+        user=user, create_for=create_for)
+
+
+@blueprint.route("/profile/claim/<service_uuid>", methods=["GET", "POST"])
+@security.authentication_required()
+def claim_profile(service_uuid):
+    service = models.Service.query.get(service_uuid) or flask.abort(404)
+    service.max_profiles > 0 or flask.abort(404)
+    form = forms.ClaimForm()
+    if form.validate_on_submit():
+        profile = models.Identity.query.filter_by(
+            service_uuid=service_uuid, username=form.username.data,
+            status = models.Identity.UNCLAIMED
+        ).first()
+        check = context.CryptContext([
+            scheme for scheme in dir(hash) if not scheme.startswith('__')
+        ])
+        if profile and check.verify(form.password.data, profile.extra.get("password")):
+            profile.user = flask_login.current_user
+            profile.status = models.Identity.ACTIVE
+            del profile.extra["password"]
+            models.db.session.add(profile)
+            models.db.session.commit()
+            flask.flash("Successfully claimed the profile!", "success")
+        else:
+            flask.flash("Wrong username or password", "danger")
+    return flask.render_template("profile_claim.html", form=form, service=service)
+
+
+@blueprint.route("/profile/service/<service_uuid>")
+@security.admin_required()
+def list_profiles(service_uuid=None):
+    service = models.Service.query.get(service_uuid) or flask.abort(404)
+    service.max_profiles > 0 or flask.abort(404)
+    return flask.render_template("profile_list.html", profiles=service.profiles,
+        service=service)

hiboo/account/templates/avatar_create.html → hiboo/identity/templates/avatar_create.html

 {% extends "base.html" %}
 
 {% block title %}{% trans %}Sign-up{% endtrans %}{% endblock %}
-{% block subtitle %}{% trans %}for the service {{ service.name }}{% endtrans %}{% endblock %}
+{% block subtitle %}{% trans service_name %}for the service {{ service_name }}{% endtrans %}{% endblock %}
 
 {% block content %}
 <div class="box">
   <div class="box-body">
     <p>{% trans %}Your are about to sign up for {{ service.name }}{% endtrans %}.</p>
   </div>
-  <form method="POST" action="{{ action_pick }}" class="form">
-      {{ form.hidden_tag() }}
-      <input type="submit" value="Sign up" style="opacity: 0.8" class="btn btn-lg btn-flat bg-gray text-black">
-  </form>
+  {{ macros.form(form) }}
 </div>
 {% endblock %}

hiboo/account/templates/avatar_pick.html → hiboo/identity/templates/avatar_pick.html

 {% extends "base.html" %}
 
 {% block title %}{% trans %}Sign in{% endtrans %}{% endblock %}
-{% block subtitle %}{% trans %}for the service {{ service.name }}{% endtrans %}{% endblock %}
+{% block subtitle %}{% trans service_name %}for the service {{ service_name }}{% endtrans %}{% endblock %}
 
 {% block content %}
 <div class="box">
   <div class="box-body">
     <p>{% trans %}Please confirm that you wish to sign in to {{ service.name }}.{% endtrans %}</p>
   </div>
-  <form method="POST" action="{{ action_pick }}" class="form">
+  <form method="POST" action="{{ utils.url_or_intent("account.home") }}" class="form">
       {{ form.hidden_tag() }}
-      <input type="hidden" name="profile_uuid" value="{{ avatar.uuid }}">
-      <input type="submit" value="Sign in" style="opacity: 0.8" class="btn btn-lg btn-flat bg-gray text-black">
+      <input type="hidden" name="identity_uuid" value="{{ avatar.uuid }}">
+      <input type="submit" value="Sign in" class="btn btn-lg btn-flat bg-gray text-black">
   </form>
 </div>
 {% endblock %}

hiboo/identity/templates/profile_claim.html

+{% extends "base.html" %}
+
+{% set service_name = service.name %}
+{% block title %}{% trans %}Claim profile{% endtrans %}{% endblock %}
+{% block subtitle %}{% trans service_name %}for the service {{ service_name }}{% endtrans %}{% endblock %}
+
+{% block content %}
+
+{% call macros.help(_("Claim an existing profile"), auto=utils.display_help("main")) %}
+  <p>{% trans %}You are about to create your first profile.{% endtrans %}</p>
+  <p>{% trans %}Please choose a username wisely, you will not be able to change it later. You may pick anything that is valid for the service, as long as it is available.{% endtrans %}</p>
+  <p>{% trans %}If your profile request is submitted for validation, please add a useful comment that will help us validate (describe shortly what your profile is for or why you need one).{% endtrans %}</p>
+{% endcall %}
+
+{{ macros.form(form) }}
+
+{% endblock %}

hiboo/account/templates/profile_create.html → hiboo/identity/templates/profile_create.html

@@ -2,7 +2,10 @@
 
 {% set service_name = service.name %}
 {% block title %}{% trans %}New profile{% endtrans %}{% endblock %}
-{% block subtitle %}{% trans service_name %}for the service {{ service_name }}{% endtrans %}{% endblock %}
+{% block subtitle %}
+  {% trans service_name %}for the service {{ service_name }}{% endtrans %}
+  {% if create_for %}{% trans %}and user{% endtrans %} {{ user.username }}{% endif %}
+{% endblock %}
 
 {% block content %}
 

hiboo/identity/templates/profile_list.html

+{% extends "base.html" %}
+
+{% block title %}{% trans %}Profile list{% endtrans %}{% endblock %}
+{% block subtitle %}{% if service %}{{ service.name }}{% endif %}{% endblock %}
+
+{% block content %}
+<div class="row">
+  <div class="col-xs-12">
+    <div class="box">
+      <div class="box-body table-responsive no-padding">
+        <table class="table table-hover">
+          <tr>
+            <th>{% trans %}Service{% endtrans %}</th>
+            <th>{% trans %}User{% endtrans %}</th>
+            <th>{% trans %}Identity{% endtrans %}</th>
+            <th>{% trans %}Created on{% endtrans %}</th>
+          </tr>
+          {% for profile in profiles %}
+          <tr>
+            <td>{{ profile.service.name }}</td>
+            <td>{{ profile.user.username }}</td>
+            <td>{{ profile.username }}</td>
+            <td>{{ profile.created_on }}</td>
+          </tr>
+          {% endfor %}
+        </table>
+      </div>
+    </div>
+  </div>
+</div>
+{% endblock %}
+
+{% block actions %}
+{% if service %}
+<a href="{{ url_for(".create_profile_for", service_uuid=service.uuid) }}" class="btn btn-success">{% trans %}Create a profile{% endtrans %}</a>
+{% endif %}
+{% endblock %}

hiboo/account/templates/profile_pick.html → hiboo/identity/templates/profile_pick.html

@@ -13,9 +13,9 @@
     <div class="box box-widget widget-user-2">
       <div class="widget-user-header bg-{{ colors[loop.index0 % 7] }}">
         {% if profile.status == "active" %}
-        <form method="POST" action="{{ action_pick }}" class="form">
+        <form method="POST" action="{{ utils.url_or_intent("account.home") }}" class="form">
             {{ form.hidden_tag() }}
-            <input type="hidden" name="profile_uuid" value="{{ profile.uuid }}">
+            <input type="hidden" name="identity_uuid" value="{{ profile.uuid }}">
             <input type="submit" value="Sign in" style="opacity: 0.8" class="btn btn-lg btn-flat bg-gray text-black pull-right">
         </form>
         {% elif profile.status == "blocked" %}
@@ -61,11 +61,14 @@
 {% endblock %}
 
 {% block actions %}
+{% if service.policy not in ("locked") %}
+<a href="{{ utils.url_for(".claim_profile", intent=True) }}" class="btn btn-primary">Claim profile</a>
+{% endif %}
 {% if service.policy in ("open", "burst") and profiles.__len__() < service.max_profiles %}
-<a href="{{ utils.url_for(".create_profile") }}" class="btn btn-primary">Create profile</a>
+<a href="{{ utils.url_for(".create_profile", intent=True) }}" class="btn btn-success">Create profile</a>
 {% elif service.policy in ("managed", "burst") %}
-<a href="{{ utils.url_for(".create_profile") }}" class="btn btn-warning">Request profile</a>
+<a href="{{ utils.url_for(".create_profile", intent=True) }}" class="btn btn-warning">Request profile</a>
 {% else %}
-<a href="#" class="btn btn-primary" disabled>Create profile</a>
+<a href="#" class="btn btn-success" disabled>Create profile</a>
 {% endif %}
 {% endblock %}

hiboo/models.py

@@ -10,7 +10,7 @@ import json
 import uuid
 
 
-def log(category, value=None, comment=None, user=None, profile=None, service=None, actor=None):
+def log(category, value=None, comment=None, user=None, identity=None, service=None, actor=None):
     """ Log a history event
     """
     event = History()
@@ -18,7 +18,7 @@ def log(category, value=None, comment=None, user=None, profile=None, service=Non
     event.value = value
     event.comment = comment
     event.user = user
-    event.profile = profile
+    event.identity = identity
     event.service = service
     event.actor = actor
     db.session.add(event)
@@ -164,10 +164,11 @@ class Service(db.Model):
     config = db.Column(JSONEncoded)
 
 
-class Profile(db.Model):
-    """ A profile is a user instance for a given service.
+class Identity(db.Model):
+    """ An identity is either a profile or an avatar for a user and given
+    service.
     """
-    __tablename__ = "profile"
+    __tablename__ = "identity"
 
     UNCLAIMED = "unclaimed"
     REQUEST = "request"
@@ -184,6 +185,7 @@ class Profile(db.Model):
 
     username = db.Column(db.String(255), nullable=False)
     status = db.Column(db.String(25), nullable=False)
+    extra = db.Column(JSONEncoded)
 
     @property
     def email(self):
@@ -198,7 +200,7 @@ class Profile(db.Model):
 
 
 class History(db.Model):
-    """ Records an even in an account's or profile's lifetime.
+    """ Records an even in an account's or identity's lifetime.
     """
     __tablename__ = "history"
 
@@ -211,17 +213,17 @@ class History(db.Model):
 
     DESCRIPTION = {
         SIGNUP: _("signed up for this account"),
-        CREATE: _("created the profile {this.profile.username} on {this.service.name}"),
+        CREATE: _("created the identity {this.identity.username} on {this.service.name}"),
         PASSWORD: _("changed your password")
     }
 
     user_uuid = db.Column(db.String(36), db.ForeignKey(User.uuid))
-    profile_uuid = db.Column(db.String(36), db.ForeignKey(Profile.uuid))
+    identity_uuid = db.Column(db.String(36), db.ForeignKey(Identity.uuid))
     service_uuid = db.Column(db.String(36), db.ForeignKey(Service.uuid))
     actor_uuid = db.Column(db.String(36), db.ForeignKey(User.uuid))
     user = db.relationship(User, foreign_keys=[user_uuid],
         backref=db.backref('history', cascade='all, delete-orphan'))
-    profile = db.relationship(Profile,
+    identity = db.relationship(Identity,
         backref=db.backref('history', cascade='all, delete-orphan'))
     service = db.relationship(Service,
         backref=db.backref('history', cascade='all, delete-orphan'))

hiboo/security.py

 import flask_login
+import flask_wtf
 import flask
 import functools
+import flask_babel
+import wtforms
 
 
 def permissions_wrapper(handler):
@@ -39,3 +42,23 @@ def authentication_required(args, kwargs):
     """ The view is only available to logged in users.
     """
     return True
+
+
+class ConfirmationForm(flask_wtf.FlaskForm):
+    submit = wtforms.fields.SubmitField(flask_babel.lazy_gettext('Confirm'))
+
+
+def confirmation_required(action):
+    """ The view is only available after manual confirmation.
+    """
+    def inner(decorated):
+        @functools.wraps(decorated)
+        def wrapper(*args, **kwargs):
+            form = ConfirmationForm()
+            if form.validate_on_submit():
+                return decorated(*args, **kwargs)
+            return flask.render_template(
+                "confirm.html", action=action.format(*args, **kwargs), form=form
+            )
+        return wrapper
+    return inner

hiboo/service/__init__.py

-from flask import Blueprint
+import flask
 
 
-blueprint = Blueprint("service", __name__, template_folder="templates")
+blueprint = flask.Blueprint("service", __name__, template_folder="templates")
 
 from hiboo.service import admin