Refactor code and add new features

Author: mominur-helios

.env

@@ -1,5 +1,25 @@
+# True for development, False for production
 DEBUG=True
-SECRET_KEY=sdgfsjdgfjk
 
+# Flask ENV
 FLASK_APP=run.py
-FLASK_ENV=development
+FLASK_DEBUG=1
+
+# If not provided, a random one is generated 
+# SECRET_KEY=<YOUR_SUPER_KEY_HERE>
+
+# If DEBUG=False (production mode)
+# DB_ENGINE=mysql
+# DB_NAME=appseed_db
+# DB_HOST=localhost
+# DB_PORT=3306
+# DB_USERNAME=appseed_db_usr
+# DB_PASS=<STRONG_PASS>
+
+# SOCIAL AUTH Github
+# GITHUB_ID=YOUR_GITHUB_ID
+# GITHUB_SECRET=YOUR_GITHUB_SECRET
+
+# SOCIAL AUTH Google
+# GOOGLE_ID=YOUR_GOOGLE_ID
+# GOOGLE_SECRET=YOUR_GOOGLE_SECRET

apps/__init__.py

@@ -4,13 +4,10 @@
 """
 
 import os
-
-from flask import Flask, send_from_directory
+from flask import Flask
 from flask_login import LoginManager
 from flask_sqlalchemy import SQLAlchemy
 from importlib import import_module
-from celery import Celery, Task
-from apps.config import Config
 
 db = SQLAlchemy()
 login_manager = LoginManager()
@@ -20,73 +17,29 @@ def register_extensions(app):
     login_manager.init_app(app)
 
 def register_blueprints(app):
-    for module_name in ('authentication', 'home', ):
+    for module_name in ('authentication', 'home', 'dyn_dt', 'charts', ):
         module = import_module('apps.{}.routes'.format(module_name))
         app.register_blueprint(module.blueprint)
 
-def configure_database(app):
-
-    @app.before_first_request
-    def initialize_database():
-        try:
-            db.create_all()
-        except Exception as e:
-
-            print('> Error: DBMS Exception: ' + str(e) )
-
-            # fallback to SQLite
-            basedir = os.path.abspath(os.path.dirname(__file__))
-            app.config['SQLALCHEMY_DATABASE_URI'] = SQLALCHEMY_DATABASE_URI = 'sqlite:///' + os.path.join(basedir, 'db.sqlite3')
-
-            print('> Fallback to SQLite ')
-            db.create_all()
-
-    @app.teardown_request
-    def shutdown_session(exception=None):
-        db.session.remove()
-
-
-def celery_init_app(app: Flask) -> Celery:
-    class FlaskTask(Task):
-        def __call__(self, *args: object, **kwargs: object) -> object:
-            with app.app_context():
-                return self.run(*args, **kwargs)
-
-    celery_app = Celery(app.name, task_cls=FlaskTask)
-    celery_app.config_from_object(app.config["CELERY"])
-    celery_app.set_default()
-    app.extensions["celery"] = celery_app
-    return celery_app
-
+from apps.authentication.oauth import github_blueprint, google_blueprint
 
 def create_app(config):
 
-    # Read debug flag
-    DEBUG = (os.getenv('DEBUG', 'False') == 'True')
-
     # Contextual
-    static_prefix = '/static' if DEBUG else '/'
+    static_prefix = '/static'
+    templates_dir = os.path.dirname(config.BASE_DIR)
 
-    app = Flask(__name__,static_url_path=static_prefix)
+    TEMPLATES_FOLDER = os.path.join(templates_dir,'templates')
+    STATIC_FOLDER = os.path.join(templates_dir,'static')
 
-    @app.route('/media/<path:filename>')
-    def media_files(filename):
-        return send_from_directory(Config.MEDIA_FOLDER, filename)
+    print(' > TEMPLATES_FOLDER: ' + TEMPLATES_FOLDER)
+    print(' > STATIC_FOLDER:    ' + STATIC_FOLDER)
 
-    app.config.from_mapping(
-        CELERY=dict(
-            broker_url="redis://localhost",
-            result_backend="redis://localhost",
-            task_ignore_result=True,
-        ),
-    )
-    # app.config.from_prefixed_env()
-    celery_init_app(app)
+    app = Flask(__name__, static_url_path=static_prefix, template_folder=TEMPLATES_FOLDER, static_folder=STATIC_FOLDER)
 
     app.config.from_object(config)
     register_extensions(app)
     register_blueprints(app)
-    configure_database(app)
-
-
+    app.register_blueprint(github_blueprint, url_prefix="/login")    
+    app.register_blueprint(google_blueprint, url_prefix="/login")    
     return app

apps/authentication/models.py

@@ -3,21 +3,28 @@
 Copyright (c) 2019 - present AppSeed.us
 """
 
-import enum
 from flask_login import UserMixin
+
+from sqlalchemy.exc import SQLAlchemyError, IntegrityError
+from flask_dance.consumer.storage.sqla import OAuthConsumerMixin
+
 from apps import db, login_manager
 from apps.authentication.util import hash_pass
-from sqlalchemy.orm import relationship
-from sqlalchemy import event
 
 class Users(db.Model, UserMixin):
 
-    __tablename__ = 'Users'
+    __tablename__ = 'users'
+
+    id            = db.Column(db.Integer, primary_key=True)
+    username      = db.Column(db.String(64), unique=True)
+    email         = db.Column(db.String(64), unique=True)
+    password      = db.Column(db.LargeBinary)
+    bio           = db.Column(db.Text(), nullable=True)
 
-    id = db.Column(db.Integer, primary_key=True)
-    username = db.Column(db.String(64), unique=True)
-    email = db.Column(db.String(64), unique=True)
-    password = db.Column(db.LargeBinary)
+    oauth_github  = db.Column(db.String(100), nullable=True)
+    oauth_google  = db.Column(db.String(100), nullable=True)
+
+    readonly_fields = ["id", "username", "email", "oauth_github", "oauth_google"]
 
     def __init__(self, **kwargs):
         for property, value in kwargs.items():
@@ -36,52 +43,50 @@ def __init__(self, **kwargs):
     def __repr__(self):
         return str(self.username)
 
+    @classmethod
+    def find_by_email(cls, email: str) -> "Users":
+        return cls.query.filter_by(email=email).first()
+
+    @classmethod
+    def find_by_username(cls, username: str) -> "Users":
+        return cls.query.filter_by(username=username).first()
+    
+    @classmethod
+    def find_by_id(cls, _id: int) -> "Users":
+        return cls.query.filter_by(id=_id).first()
+   
+    def save(self) -> None:
+        try:
+            db.session.add(self)
+            db.session.commit()
+          
+        except SQLAlchemyError as e:
+            db.session.rollback()
+            db.session.close()
+            error = str(e.__dict__['orig'])
+            raise IntegrityError(error, 422)
+    
+    def delete_from_db(self) -> None:
+        try:
+            db.session.delete(self)
+            db.session.commit()
+        except SQLAlchemyError as e:
+            db.session.rollback()
+            db.session.close()
+            error = str(e.__dict__['orig'])
+            raise IntegrityError(error, 422)
+        return
 
 @login_manager.user_loader
 def user_loader(id):
     return Users.query.filter_by(id=id).first()
 
-
 @login_manager.request_loader
 def request_loader(request):
     username = request.form.get('username')
     user = Users.query.filter_by(username=username).first()
     return user if user else None
 
-
-class Role(enum.Enum):
-    ADMIN = 1
-    USER = 2
-
-    def __str__(self):
-        return str(self.value)
-    
-class Profile(db.Model):
-    id = db.Column(db.Integer, primary_key=True)
-    role = db.Column(db.Enum(Role), default=Role.USER)
-    full_name = db.Column(db.String(255), name="full_name", nullable=True)
-    address = db.Column(db.String(255), name="address", nullable=True)
-    city = db.Column(db.String(255), name="city", nullable=True)
-    country = db.Column(db.String(255), name="country", nullable=True)
-    zip = db.Column(db.String(255), name="zip", nullable=True)
-    phone = db.Column(db.String(255), name="phone", nullable=True)
-    avatar = db.Column(db.String(1000), nullable=True)
-    user_id = db.Column(db.Integer, db.ForeignKey('Users.id', ondelete='cascade'), nullable=False)
-    user = relationship("Users", backref="profile")
-
-    @classmethod
-    def find_by_id(cls, _id: int) -> "Profile":
-        return cls.query.filter_by(id=_id).first()
-
-    @classmethod
-    def find_by_user_id(cls, _id: int):
-        return cls.query.filter_by(user_id=_id).first()
-
-
-# create profile
-def create_profile_for_user(mapper, connection, user):
-    connection.execute(Profile.__table__.insert().values(
-        user_id=user.id,
-    ))
-
-event.listen(Users, 'after_insert', create_profile_for_user)
+class OAuth(OAuthConsumerMixin, db.Model):
+    user_id = db.Column(db.Integer, db.ForeignKey("users.id", ondelete="cascade"), nullable=False)
+    user = db.relationship(Users)

apps/authentication/oauth.py

@@ -0,0 +1,103 @@
+# -*- encoding: utf-8 -*-
+"""
+Copyright (c) 2019 - present AppSeed.us
+"""
+
+import os
+from flask import current_app as app 
+from flask_login import current_user, login_user
+from flask_dance.consumer import oauth_authorized
+from flask_dance.contrib.github import github, make_github_blueprint
+from flask_dance.contrib.google import google, make_google_blueprint
+from flask_dance.consumer.storage.sqla import SQLAlchemyStorage
+from sqlalchemy.orm.exc import NoResultFound
+from apps.config import Config
+from .models import Users, db, OAuth
+from flask import redirect, url_for
+from flask import flash
+
+github_blueprint = make_github_blueprint(
+    client_id=Config.GITHUB_ID,
+    client_secret=Config.GITHUB_SECRET,
+    scope = 'user',
+    storage=SQLAlchemyStorage(
+        OAuth,
+        db.session,
+        user=current_user,
+        user_required=False,        
+    ),   
+)
+
+@oauth_authorized.connect_via(github_blueprint)
+def github_logged_in(blueprint, token):
+    info = github.get("/user")
+
+    if info.ok:
+
+        account_info = info.json()
+        username     = account_info["login"]
+
+        query = Users.query.filter_by(oauth_github=username)
+        try:
+
+            user = query.one()
+            login_user(user)
+
+        except NoResultFound:
+
+            # Save to db
+            user              = Users()
+            user.username     = '(gh)' + username
+            user.oauth_github = username
+
+            # Save current user
+            db.session.add(user)
+            db.session.commit()
+
+            login_user(user)
+
+# Google
+
+google_blueprint = make_google_blueprint(
+    client_id=Config.GOOGLE_ID,
+    client_secret=Config.GOOGLE_SECRET,
+    scope=[
+        "openid",
+        "https://www.googleapis.com/auth/userinfo.email",
+        "https://www.googleapis.com/auth/userinfo.profile",
+    ],
+    storage=SQLAlchemyStorage(
+        OAuth,
+        db.session,
+        user=current_user,
+        user_required=False,        
+    ),   
+)
+
+@oauth_authorized.connect_via(google_blueprint)
+def google_logged_in(blueprint, token):
+    info = google.get("/oauth2/v1/userinfo")
+
+    if info.ok:
+        account_info = info.json()
+        username     = account_info["given_name"]
+        email        = account_info["email"]
+
+        query = Users.query.filter_by(oauth_google=username)
+        try:
+
+            user = query.one()
+            login_user(user)
+
+        except NoResultFound:
+            # Save to db
+            user              = Users()
+            user.username     = '(google)' + username
+            user.oauth_google = username
+            user.email        = email
+
+            # Save current user
+            db.session.add(user)
+            db.session.commit()
+
+            login_user(user)