Feature Panel - Backend

app/database/models.py

@@ -31,6 +31,16 @@
 Base: DeclarativeMeta = declarative_base()
 
 
+class UserFeature(Base):
+    __tablename__ = "user_feature"
+
+    id = Column(Integer, primary_key=True, index=True)
+    feature_id = Column('feature_id', Integer, ForeignKey('features.id'))
+    user_id = Column('user_id', Integer, ForeignKey('users.id'))
+
+    is_enable = Column(Boolean, default=False)
+
+
 class User(Base):
     __tablename__ = "users"
 
@@ -65,6 +75,7 @@ class User(Base):
     )
     comments = relationship("Comment", back_populates="user")
 
+    features = relationship("Feature", secondary=UserFeature.__tablename__)
     oauth_credentials = relationship(
         "OAuthCredentials",
         cascade="all, delete",
@@ -81,6 +92,18 @@ async def get_by_username(db: Session, username: str) -> User:
         return db.query(User).filter(User.username == username).first()
 
 
+class Feature(Base):
+    __tablename__ = "features"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String, nullable=False)
+    route = Column(String, nullable=False)
+    creator = Column(String, nullable=True)
+    description = Column(String, nullable=False)
+
+    users = relationship("User", secondary=UserFeature.__tablename__)
+
+
 class Event(Base):
     __tablename__ = "events"
 

app/features/index.py

@@ -0,0 +1,51 @@
+'''
+    This file purpose is for developers to add their features to the database
+    in one convenient place, every time the system loads up it's adding and
+    updating the features in the features table in the database.
+
+    To update a feature, The developer needs to change the name or the route
+    and let the system load, but not change both at the same time otherwise
+    it will create junk and unnecessary duplicates.
+
+    *   IMPORTANT - To enable features panel functionlity the developer must  *
+    *   add the feature_access_filter decorator to ALL the feature routes     *
+    *   Please see the example below.                                         *
+
+    Enjoy and good luck :)
+'''
+
+'''
+Example to feature stracture:
+
+{
+    "name": "<feature name - str>",
+    "route": "/<the route like: /features - str>",
+    "description": "<description - str>",
+    "creator": "<creator name or nickname - str>"
+}
+'''
+
+'''
+*   IMPORTANT   *
+
+Example to decorator placement:
+
+    @router.get("/<my-route>")
+    @feature_access_filter     <---- just above def keyword!
+    def my_cool_feature_route():
+        ....
+        ...
+            some code.
+        ..
+        .
+
+'''
+
+features = [
+    {
+        "name": "Google Sync",
+        "route": "/google/sync",
+        "description": "Sync Google Calendar events with Pylender",
+        "creator": "Liran Caduri"
+    },
+]

app/features/utils.py

@@ -0,0 +1,34 @@
+from functools import wraps
+from starlette.responses import RedirectResponse
+
+from app.internal.features import is_feature_enabled
+
+
+def feature_access_filter(call_next):
+
+    @wraps(call_next)
+    async def wrapper(*args, **kwargs):
+        request = kwargs['request']
+
+        if request.headers['user-agent'] == 'testclient':
+            # in case it's a unit test.
+            return await call_next(*args, **kwargs)
+
+        # getting the url route path for matching with the database.
+        route = '/' + str(request.url).replace(str(request.base_url), '')
+
+        # getting access status.
+        is_enabled = is_feature_enabled(route=route)
+
+        if is_enabled:
+            # in case the feature is enabled or access is allowed.
+            return await call_next(*args, **kwargs)
+
+        elif 'referer' not in request.headers:
+            # in case request come straight from address bar in browser.
+            return RedirectResponse(url='/')
+
+        # in case the feature is disabled or access isn't allowed.
+        return RedirectResponse(url=request.headers['referer'])
+
+    return wrapper

app/internal/features.py

@@ -0,0 +1,146 @@
+from fastapi import Depends
+from typing import List
+
+from app.database.models import UserFeature, Feature
+from app.dependencies import get_db, SessionLocal
+from app.features.index import features
+from app.internal.utils import create_model, get_current_user
+
+
+def create_features_at_startup(session: SessionLocal) -> bool:
+    for feat in features:
+        if not is_feature_exists_in_db(feature=feat, session=session):
+            create_feature(**feat, db=session)
+
+    return True
+
+
+def is_association_exists_in_db(form: dict, session: SessionLocal) -> bool:
+    db_association = session.query(UserFeature).filter_by(
+        feature_id=form['feature_id'],
+        user_id=form['user_id']
+    ).first()
+
+    return db_association is not None
+
+
+def delete_feature(
+    feature: Feature, session: SessionLocal = Depends(get_db)
+) -> None:
+    session.query(UserFeature).filter_by(feature_id=feature.id).delete()
+    session.query(Feature).filter_by(id=feature.id).delete()
+    session.commit()
+
+
+def is_feature_exists_in_db(feature: dict, session: SessionLocal) -> bool:
+    db_feature = session.query(Feature).filter(
+        (Feature.name == feature['name']) |
+        (Feature.route == feature['route'])).first()
+
+    if db_feature is None:
+        return False
+
+    # Update if found
+    update_feature(
+        feature=db_feature, new_feature_obj=feature, session=session)
+    return True
+
+
+def update_feature(feature: Feature, new_feature_obj: dict,
+                   session: SessionLocal = Depends(get_db)) -> Feature:
+    feature.name = new_feature_obj['name']
+    feature.route = new_feature_obj['route']
+    feature.description = new_feature_obj['description']
+    feature.creator = new_feature_obj['creator']
+    session.commit()
+
+    return feature
+
+
+def is_feature_exists_in_enabled(
+    feature: Feature, session: SessionLocal = Depends(get_db)
+) -> bool:
+    enabled_features = get_user_enabled_features(session=session)
+    return any(ef['feature'].id == feature.id for ef in enabled_features)
+
+
+def is_feature_exists_in_disabled(
+    feature: Feature, session: SessionLocal = Depends(get_db)
+) -> bool:
+    disable_features = get_user_disabled_features(session=session)
+    return any(ef['feature'].id == feature.id for ef in disable_features)
+
+
+def is_feature_enabled(route: str) -> bool:
+    session = SessionLocal()
+    user = get_current_user(session=session)
+    feature = session.query(Feature).filter_by(route=route).first()
+
+    if feature is None:
+        # in case there is no feature exists in the database that match the
+        # route that gived by to the request.
+        return True
+
+    user_pref = session.query(UserFeature).filter_by(
+        feature_id=feature.id,
+        user_id=user.id
+    ).first()
+
+    return user_pref is not None and user_pref.is_enable
+
+
+def create_feature(name: str, route: str,
+                   description: str, creator: str = None,
+                   db: SessionLocal = Depends()) -> Feature:
+    """Creates a feature."""
+
+    db = SessionLocal()
+    return create_model(
+        db, Feature,
+        name=name,
+        route=route,
+        creator=creator,
+        description=description
+    )
+
+
+def create_association(
+    db: SessionLocal, feature_id: int, user_id: int, is_enable: bool
+) -> UserFeature:
+    """Creates an association."""
+    return create_model(
+        db, UserFeature,
+        user_id=user_id,
+        feature_id=feature_id,
+        is_enable=is_enable
+    )
+
+
+def get_user_enabled_features(session: SessionLocal = Depends(get_db)) -> List:
+    user = get_current_user(session=session)
+    data = []
+    user_prefs = session.query(UserFeature).filter_by(user_id=user.id).all()
+
+    for pref in user_prefs:
+        if pref.is_enable:
+            feature = session.query(Feature).filter_by(
+                id=pref.feature_id).first()
+            data.append({'feature': feature, 'is_enabled': pref.is_enable})
+
+    return data
+
+
+def get_user_disabled_features(
+    session: SessionLocal = Depends(get_db)
+) -> List:
+    user = get_current_user(session=session)
+    data = []
+    user_prefs = session.query(UserFeature).filter_by(user_id=user.id).all()
+
+    for pref in user_prefs:
+        if not pref.is_enable:
+            feature = session.query(Feature).filter_by(
+                id=pref.feature_id).first()
+            data.append({'feature': feature, 'is_enabled': pref.is_enable})
+
+    return data

app/main.py

@@ -8,8 +8,10 @@
 
 from app import config
 from app.database import engine, models
-from app.dependencies import get_db, logger, MEDIA_PATH, STATIC_PATH, templates
+from app.dependencies import (
+    get_db, logger, MEDIA_PATH, STATIC_PATH, templates, SessionLocal)
 from app.internal import daily_quotes, json_data_loader
+import app.internal.features as internal_features
 from app.internal.languages import set_ui_language
 from app.internal.security.ouath2 import auth_exception_handler
 from app.routers.salary import routes as salary
@@ -41,7 +43,7 @@ def create_tables(engine, psql_environment):
 
 from app.routers import (  # noqa: E402
     about_us, agenda, calendar, categories, celebrity, credits,
-    currency, dayview, email, event, export, four_o_four, friendview,
+    currency, dayview, email, event, export, four_o_four, features, friendview,
     google_connect, invitation, login, logout, profile,
     register, search, telegram, user, weekview, whatsapp,
 )
@@ -79,6 +81,7 @@ async def swagger_ui_redirect():
     email.router,
     event.router,
     export.router,
+    features.router,
     four_o_four.router,
     google_connect.router,
     invitation.router,
@@ -97,6 +100,13 @@ async def swagger_ui_redirect():
     app.include_router(router)
 
 
+@app.on_event("startup")
+async def startup_event():
+    session = SessionLocal()
+    internal_features.create_features_at_startup(session=session)
+    session.close()
+
+
 # TODO: I add the quote day to the home page
 # until the relevant calendar view will be developed.
 @app.get("/", include_in_schema=False)