Feature Panel - Backend

.gitignore

@@ -157,6 +157,9 @@ app/.vscode/
 
 app/routers/stam
 
+bin
+routes 1.py
+
 # PyCharm
 .idea
 

app/database/models.py

@@ -19,6 +19,16 @@
 Base = 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)
+
+
 class User(Base):
     __tablename__ = "users"
 
@@ -46,6 +56,7 @@ class User(Base):
     )
     comments = relationship("Comment", back_populates="user")
 
+    features = relationship("Feature", secondary=UserFeature.__tablename__)
     oauth_credentials = relationship(
         "OAuthCredentials", cascade="all, delete", back_populates="owner",
         uselist=False)
@@ -60,6 +71,18 @@ async def get_by_username(db: Session, username: str) -> User:
             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 routs      *
+    *   Please see the example below.                                         *
+
+    Enjoy and good luck :)
+'''
+
+'''
+Example to feature stracture:
+
+{
+    "name": '<feature name>',
+    "route": '/<the route like: /features >',
+    "description": '<description>',
+    "creator": '<creator name or nickname>'
+}
+'''
+
+'''
+*   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,30 @@
+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']
+
+        # 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)
+        print(is_enabled)
+        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,169 @@
+from fastapi import Depends
+
+from app.features.index import features
+from app.database.models import UserFeature, Feature
+from app.internal.utils import create_model, get_current_user
+from app.dependencies import get_db, SessionLocal
+
+
+def create_features_at_startup(session: SessionLocal):
+
+    for feat in features:
+        if not is_feature_exist_in_db(feature=feat, session=session):
+            create_feature(**feat, db=session)
+
+    return True
+
+
+def is_association_exist_in_db(form: dict, session: SessionLocal):
+    db_association = session.query(UserFeature).filter_by(
+        feature_id=form['feature_id'],
+        user_id=form['user_id']
+    ).first()
+
+    if db_association is not None:
+        return True
+    return False
+
+
+def delete_feature(feature: Feature, session: SessionLocal = Depends(get_db)):
+    session.query(UserFeature).filter_by(feature_id=feature.id).delete()
+    session.query(Feature).filter_by(id=feature.id).delete()
+    session.commit()
+
+
+def is_feature_exist_in_db(feature: dict, session: SessionLocal):
+    db_feature = session.query(Feature).filter(
+        (Feature.name == feature['name']) |
+        (Feature.route == feature['route'])).first()
+
+    if db_feature is not None:
+        # Update if found
+        update_feature(feature=db_feature,
+                       new_feature_obj=feature,
+                       session=session)
+        return True
+    return False
+
+
+def update_feature(feature: Feature, new_feature_obj: dict,
+                   session: SessionLocal = Depends(get_db)):
+
+    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_exist_in_enabled(feature: Feature,
+                                session: SessionLocal = Depends(get_db)):
+    enable_features = get_user_enabled_features(session=session)
+
+    for ef in enable_features:
+        if ef['feature'].id == feature.id:
+            return True
+
+    return False
+
+
+def is_feature_exist_in_disabled(feature: Feature,
+                                 session: SessionLocal = Depends(get_db)):
+    disable_features = get_user_disabled_features(session=session)
+
+    for df in disable_features:
+        if df['feature'].id == feature.id:
+            return True
+
+    return False
+
+
+def is_feature_enabled(route: str):
+    session = SessionLocal()
+
+    user = get_current_user(session=session)
+
+    feature = session.query(Feature).filter_by(route=route).first()
+
+    # *This condition must be before line 168 to avoid AttributeError!*
+    if feature is None:
+        # in case there is no feature exist 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()
+
+    if user_pref is None:
+        # in case the feature is unlinked to user.
+        return False
+    elif user_pref.is_enable:
+        # in case the feature is enabled.
+        return True
+    # in case the feature is disabled.
+    return False
+
+
+def create_feature(name: str, route: str,
+                   description: str, creator: str = None,
+                   db: SessionLocal = Depends()):
+    """Creates a feature."""
+
+    db = SessionLocal()
+
+    feature = create_model(
+        db, Feature,
+        name=name,
+        route=route,
+        creator=creator,
+        description=description
+    )
+    return feature
+
+
+def create_association(
+        db: SessionLocal, feature_id: int, user_id: int, is_enable: bool):
+    """Creates an association."""
+
+    association = create_model(
+        db, UserFeature,
+        user_id=user_id,
+        feature_id=feature_id,
+        is_enable=is_enable
+    )
+
+    return association
+
+
+def get_user_enabled_features(session: SessionLocal = Depends(get_db)):
+
+    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)):
+
+    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

@@ -1,20 +1,22 @@
+from fastapi import Depends, FastAPI, Request
+from fastapi.staticfiles import StaticFiles
+from sqlalchemy.orm import Session
+
 from app import config
 from app.database import engine, models
-from app.dependencies import get_db, logger, MEDIA_PATH, STATIC_PATH, templates
-from app.internal import daily_quotes, json_data_loader
-
+from app.dependencies import (
+    get_db, logger, MEDIA_PATH, STATIC_PATH, templates, SessionLocal)
+from app.internal import (
+    daily_quotes, json_data_loader, features as internal_features)
 from app.internal.languages import set_ui_language
 from app.internal.security.ouath2 import auth_exception_handler
 from app.utils.extending_openapi import custom_openapi
 from app.routers.salary import routes as salary
-from fastapi import Depends, FastAPI, Request
 from fastapi.openapi.docs import (
     get_swagger_ui_html,
     get_swagger_ui_oauth2_redirect_html,
 )
-from fastapi.staticfiles import StaticFiles
 from starlette.status import HTTP_401_UNAUTHORIZED
-from sqlalchemy.orm import Session
 
 
 def create_tables(engine, psql_environment):
@@ -43,7 +45,7 @@ def create_tables(engine, psql_environment):
 
 from app.routers import (  # noqa: E402
     about_us, agenda, calendar, categories, celebrity, currency, dayview,
-    email, event, export, four_o_four, google_connect,
+    email, event, export, features, four_o_four, 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)