Initial commit

.gitignore

@@ -0,0 +1,23 @@
+# Cache
+__pycache__
+*.py[cod]
+*$py.class
+
+# Environments
+.env
+.venv
+env/
+venv/
+
+# OS
+.DS_Store
+
+# IDE
+*.vscode
+*.code-workspace
+
+# Settings
+.envrc
+
+# DB
+app.db

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Oleg Komarov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,4 @@
+# Build your viral queue page with flask
+An example how to build a viral queue page with flask
+
+For details and how to use, please read: 

app/__init__.py

@@ -0,0 +1,34 @@
+from flask import Flask
+
+from app.config import BaseConfig
+
+
+def create_app():
+    app = Flask(__name__)
+    app.config.from_object(BaseConfig)
+
+    register_extensions(app)
+    register_blueprints(app)
+
+    return app
+
+
+def register_extensions(app):
+    from app.extensions import db
+    from app.extensions import mail
+    from app.extensions import migrate
+
+    db.init_app(app)
+    mail.init_app(app)
+    migrate.init_app(app, db)
+
+
+def register_blueprints(app):
+    from app.routes import webapp_bp
+    app.register_blueprint(webapp_bp)
+
+    from app.routes import error_bp
+    app.register_blueprint(error_bp)
+
+
+app = create_app()

app/config.py

@@ -0,0 +1,15 @@
+import os
+
+
+class BaseConfig:
+    MAIL_PASSWORD = os.environ['MAIL_PASSWORD']
+    MAIL_PORT = os.environ['MAIL_PORT']
+    MAIL_SERVER = os.environ['MAIL_SERVER']
+    MAIL_USE_SSL = True
+    MAIL_USE_TLS = False
+    MAIL_USERNAME = os.environ['MAIL_USERNAME']
+    PROJECT_NAME = 'Mega Duper App'
+    PROJECT_URL = 'https://megaduperapp.com'
+    SECRET_KEY = os.environ['SECRET_KEY']
+    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL')
+    SQLALCHEMY_TRACK_MODIFICATIONS = False

app/extensions.py

@@ -0,0 +1,8 @@
+from flask_mail import Mail
+from flask_migrate import Migrate
+from flask_sqlalchemy import SQLAlchemy
+
+
+db = SQLAlchemy()
+mail = Mail()
+migrate = Migrate()

app/forms.py

@@ -0,0 +1,10 @@
+from flask_wtf import FlaskForm
+from wtforms import SubmitField
+from wtforms.fields.html5 import EmailField
+from wtforms.validators import DataRequired
+from wtforms.validators import Email
+
+
+class EmailForm(FlaskForm):
+    email = EmailField('Email', validators=[DataRequired(), Email()])
+    submit = SubmitField('Get early access')

app/logic.py

@@ -0,0 +1,73 @@
+from datetime import datetime
+from datetime import timezone
+
+
+from sqlalchemy.exc import IntegrityError
+
+
+from app import utils
+from app.models import referrals
+from app.models import User
+from app.models import Waitlist
+
+
+def get_user(user_id):
+    return User.query.filter_by(id=user_id).one_or_none()
+
+
+def get_user_by_email(email):
+    return User.query.filter_by(email=email).one_or_none()
+
+
+def get_waitlist_user(uuid):
+    return Waitlist.query.filter_by(uuid=uuid).one_or_none()
+
+
+def create_user(email):
+    email = utils.normalize_email(email)
+    user = User(email=email)
+    user.save()
+
+    waitlist_user = Waitlist(user.id)
+    waitlist_user.save()
+
+    return user
+
+
+def verify_email(token):
+    payload = utils.decode_jwt_token(token)
+    user = get_user(payload['user_id'])
+    if user is None:
+        return
+
+    if not user.email_confirmed:
+        user.email_confirmed = True
+        now = datetime.now(timezone.utc)
+        user.email_confirmed_on = now
+        user.save()
+
+    if payload['referring_uuid'] is not None:
+        refer(payload['referring_uuid'], user.waitlist.uuid)
+
+
+def refer(referring_uuid, referred_uuid):
+    referring_user = get_waitlist_user(referring_uuid)
+    referred_user = get_waitlist_user(referred_uuid)
+    try:
+        referring_user.referred.append(referred_user)
+        referring_user.score -= Waitlist.decrease_per_referral
+        referring_user.save()
+    except IntegrityError:
+        pass
+
+
+def get_waitlist_position(uuid):
+    waitlist_user = get_waitlist_user(uuid)
+    score = waitlist_user.score
+    return Waitlist.query.filter(Waitlist.score <= score).count()
+
+
+def get_completed_referrals(uuid):
+    waitlist_user = get_waitlist_user(uuid)
+    return waitlist_user.referred.filter(
+        referrals.c.referring == waitlist_user.uuid).count()

app/models.py

@@ -0,0 +1,61 @@
+from app import utils
+from app.extensions import db
+
+
+class BaseModel(object):
+    def save(self):
+        db.session.add(self)
+        db.session.commit()
+
+
+class User(BaseModel, db.Model):
+    __tablename__ = 'user'
+
+    id = db.Column(db.Integer, primary_key=True)
+    email = db.Column(db.String(120), unique=True, nullable=False)
+    email_confirmed = db.Column(db.Boolean, default=False)
+    email_confirmed_on = db.Column(db.DateTime(timezone=True))
+    waitlist = db.relationship('Waitlist', uselist=False, back_populates='user')
+
+    def __init__(self, email):
+        self.email = email
+
+
+referrals = db.Table(
+    'referral',
+    db.Column('referring', db.String(8), db.ForeignKey('waitlist.uuid')),
+    db.Column('referred', db.String(8), db.ForeignKey('waitlist.uuid')),
+    db.PrimaryKeyConstraint('referring', 'referred', name='referrals_pk')
+)
+
+
+class Waitlist(BaseModel, db.Model):
+    __tablename__ = 'waitlist'
+
+    initial_score = 65231
+    decrease_per_referral = 10
+
+    uuid = db.Column(db.String(8), primary_key=True)
+    user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
+    user = db.relationship('User', back_populates='waitlist')
+    score = db.Column(db.Integer)
+    referred = db.relationship(
+        'Waitlist',
+        secondary=referrals,
+        primaryjoin=(referrals.c.referring == uuid),
+        secondaryjoin=(referrals.c.referred == uuid),
+        backref=db.backref('referral', lazy='dynamic'), lazy='dynamic')
+
+    def __init__(self, user_id):
+        self.user_id = user_id
+        self.set_uuid()
+        self.set_initial_score()
+
+    def set_uuid(self):
+        uuid = utils.generate_simple_uuid(8)
+        while db.session.query(Waitlist).filter_by(uuid=uuid).one_or_none():
+            uuid = utils.generate_simple_uuid(8)
+        self.uuid = uuid
+
+    def set_initial_score(self):
+        self.score = self.initial_score + db.session.query(Waitlist).count() + 1

app/myemail.py

@@ -0,0 +1,40 @@
+from threading import Thread
+
+from flask import current_app
+from flask import render_template
+from flask_mail import Message
+
+from app import utils
+from app.extensions import mail
+
+
+def _send_async(app, msg):
+    with app.app_context():
+        mail.send(msg)
+
+
+def send(subject, sender, recipients, text_body, html_body):
+    msg = Message(subject, sender=sender, recipients=recipients)
+    msg.body = text_body
+    msg.html = html_body
+    Thread(target=_send_async,
+           args=(current_app._get_current_object(), msg)).start()
+
+
+def send_from_default(subject, recipients, text_body, html_body):
+    send(subject,
+         current_app._get_current_object().config['MAIL_USERNAME'],
+         recipients, text_body, html_body)
+
+
+def send_verification_email(user_id, user_email, referring_uuid=''):
+    payload = {
+        'user_id': user_id,
+        'referring_uuid': referring_uuid}
+    jwt_token = utils.encode_jwt_token(payload)
+    send_from_default(subject='Please verify your email address',
+                      recipients=[user_email],
+                      text_body=render_template(
+                          'email/verify_email.txt', token=jwt_token),
+                      html_body=render_template(
+                          'email/verify_email.html', token=jwt_token))

app/routes.py

@@ -0,0 +1,70 @@
+from flask import abort
+from flask import Blueprint
+from flask import redirect
+from flask import render_template
+from flask import request
+from flask import url_for
+
+from app import logic
+from app import myemail
+from app import utils
+from app.forms import EmailForm
+
+
+webapp_bp = Blueprint('main', __name__)
+error_bp = Blueprint('errors', __name__)
+
+
+@webapp_bp.route('/', methods=['POST', 'GET'])
+def index():
+    referring_uuid = request.args.get('user')
+    form = EmailForm()
+    if request.method == 'POST':
+        if form.validate():
+            email = utils.normalize_email(form.email.data)
+            user = logic.get_user_by_email(email)
+
+            if user is None:
+                user = logic.create_user(email)
+
+                myemail.send_verification_email(
+                    user.id, user.email,
+                    referring_uuid=referring_uuid)
+
+            return redirect(url_for('main.waitlist', user=user.waitlist.uuid))
+
+    elif request.method == 'GET':
+        return render_template(
+            'index.html', form=form, referring_uuid=referring_uuid)
+
+
+@webapp_bp.route('/verify_email/<token>/')
+def verify_email(token):
+    logic.verify_email(token)
+    return redirect(url_for('main.index'))
+
+
+@webapp_bp.route('/waitlist/')
+def waitlist():
+    uuid = request.args.get('user')
+    waitlist_user = logic.get_waitlist_user(uuid)
+    if waitlist_user is None:
+        return abort(404)
+    else:
+        waitlist_position = logic.get_waitlist_position(uuid)
+        completed_referrals = logic.get_completed_referrals(uuid)
+        return render_template(
+            'waitlist.html',
+            uuid=uuid,
+            waitlist_position=waitlist_position,
+            completed_referrals=completed_referrals)
+
+
+@error_bp.app_errorhandler(404)
+def not_found_error(error):
+    return render_template('errors/404.html'), 404
+
+
+@error_bp.app_errorhandler(500)
+def internal_error(error):
+    return render_template('errors/500.html'), 500