Feature Panel - Backend

AUTHORS.md

@@ -33,6 +33,7 @@
          * PureDreamer - Developer
          * ShiZinDle - Developer
          * YairEn - Developer
+         * LiranCaduri - Developer
 
 # Special thanks to
 

app/database/models.py

@@ -32,6 +32,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"
 
@@ -67,6 +77,7 @@ class User(Base):
     )
     comments = relationship("Comment", back_populates="user")
 
+    features = relationship("Feature", secondary=UserFeature.__tablename__)
     oauth_credentials = relationship(
         "OAuthCredentials",
         cascade="all, delete",
@@ -83,6 +94,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/internal/features.py

@@ -0,0 +1,169 @@
+from fastapi import Depends
+from functools import wraps
+from starlette.responses import RedirectResponse
+from typing import List
+
+from app.database.models import UserFeature, Feature
+from app.dependencies import get_db, SessionLocal
+from app.internal.features_index import features
+from app.internal.utils import create_model, get_current_user
+
+
+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_access_allowd(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
+
+
+def create_features_at_startup(session: SessionLocal) -> bool:
+    for feat in features:
+        if not is_feature_exists(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=get_current_user(session=session).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(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_enabled(
+    feature: Feature, session: SessionLocal = Depends(get_db)
+) -> bool:
+    enabled_features = get_user_enabled_features(session=session)
+    return any(ef.id == feature.id for ef in enabled_features)
+
+
+def is_access_allowd(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_user_feature_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)
+    enabled = []
+    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()
+            enabled.append(feature)
+
+    return enabled
+
+
+def get_user_uninstalled_features(session: SessionLocal) -> List:
+    uninstalled = []
+    all_features = session.query(Feature).all()
+
+    for feat in all_features:
+        in_enabled = is_feature_enabled(
+            feature=feat, session=session
+        )
+
+        if not in_enabled:
+            uninstalled.append(feat)
+
+    return uninstalled

app/internal/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/main.py

@@ -15,8 +15,10 @@
     SOUNDS_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
@@ -60,6 +62,7 @@ def create_tables(engine, psql_environment):
     email,
     event,
     export,
+    features,
     four_o_four,
     friendview,
     google_connect,
@@ -109,6 +112,7 @@ async def swagger_ui_redirect():
     email.router,
     event.router,
     export.router,
+    features.router,
     four_o_four.router,
     friendview.router,
     google_connect.router,
@@ -131,6 +135,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)

app/routers/features.py

@@ -0,0 +1,74 @@
+from app.internal.utils import get_current_user
+from fastapi import APIRouter, Request, Depends
+from typing import List
+
+from app.dependencies import get_db, SessionLocal
+from app.database.models import UserFeature, Feature
+from app.internal.features import (
+    create_user_feature_association,
+    is_association_exists_in_db,
+)
+
+router = APIRouter(
+    prefix="/features",
+    tags=["features"],
+    responses={404: {"description": "Not found"}},
+)
+
+
+@router.get('/')
+async def index(
+    request: Request, session: SessionLocal = Depends(get_db)
+) -> List:
+    features = session.query(Feature).all()
+    return features
+
+
+@router.post('/add')
+async def add_feature_to_user(
+    request: Request, session: SessionLocal = Depends(get_db)
+) -> UserFeature:
+    form = await request.form()
+
+    user = get_current_user(session=session)
+    feat = session.query(Feature).filter_by(id=form['feature_id']).first()
+
+    is_exist = is_association_exists_in_db(form=form, session=session)
+
+    if feat is None or is_exist:
+        # in case there is no feature in the database with that same id
+        # and or the association is exist
+        return False
+
+    association = create_user_feature_association(
+        db=session,
+        feature_id=feat.id,
+        user_id=user.id,
+        is_enable=True
+    )
+
+    return session.query(UserFeature).filter_by(id=association.id).first()
+
+
+@router.post('/delete')
+async def delete_user_feature_association(
+    request: Request,
+    session: SessionLocal = Depends(get_db)
+) -> bool:
+    form = await request.form()
+
+    user = get_current_user(session=session)
+    feature_id = form['feature_id']
+
+    is_exist = is_association_exists_in_db(form=form, session=session)
+
+    if not is_exist:
+        return False
+
+    session.query(UserFeature).filter_by(
+        feature_id=feature_id,
+        user_id=user.id
+    ).delete()
+    session.commit()
+
+    return True