Features Icons in features panel

.gitignore

@@ -151,6 +151,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"
 
@@ -44,10 +54,25 @@ class User(Base):
     )
     comments = relationship("Comment", back_populates="user")
 
+    features = relationship("Feature", secondary=UserFeature.__tablename__)
+
     def __repr__(self):
         return f'<User {self.id}>'
 
 
+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)
+    icon = Column(String, nullable=False)
+
+    users = relationship("User", secondary=UserFeature.__tablename__)
+
+
 class Event(Base):
     __tablename__ = "events"
 

app/features/index.py

@@ -0,0 +1,83 @@
+'''
+    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.
+
+    Enjoy and good luck :)
+'''
+
+'''
+All icons come from https://ionicons.com/.
+
+If you want your feature to have an icon Go To: https://ionicons.com/
+and follow the next steps:
+
+1. pick an icon and press on it, copy the name.
+2. create dict in the icons list below.
+3. copy and paste your feature name and your
+    icon name you copied earlier (follow the example).
+
+4. And You Are Done. the icon will show automaticly.
+
+If you dont pick an icon your feature will have a default icon.
+
+Example to feature icon stracture:
+
+{
+    .
+    .
+    .
+    "<feature name>": '<icon name>',
+    .
+    .
+    .
+}
+'''
+
+# Add to last!
+icons = {
+    'feature-panel': 'albums-outline'
+    }
+
+
+'''
+Example to feature stracture:
+
+{
+    "name": '<feature name>',
+    "route": '/<the route like: /features >',
+    "description": '<description>',
+    "creator": '<creator name or nickname>'
+}
+'''
+
+features = [
+    {
+        "name": 'agenda',
+        "route": '/agenda',
+        "description": 'description',
+        "creator": 'creator'
+    },
+    {
+        "name": 'feature-panel',
+        "route": '/features/',
+        "description": 'description',
+        "creator": 'liran caduri'
+    },
+    {
+        "name": 'invitations',
+        "route": '/invitations/',
+        "description": 'description',
+        "creator": 'creator2'
+    },
+    {
+        "name": 'association',
+        "route": '/features/test-association',
+        "description": 'description',
+        "creator": 'creator2'
+    }
+]

app/internal/features.py

@@ -0,0 +1,185 @@
+from fastapi import Depends
+
+from app.features.index import features, icons
+from app.database.models import UserFeature, Feature
+from app.internal.utils import create_model
+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):
+            icon = icons.get(feat['name'])
+            create_feature(**feat, icon=icon, 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']
+
+    icon = icons.get(feature.name)
+    if icon is None:
+        icon = "extension-puzzle"
+
+    feature.icon = icon
+    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()
+
+    # TODO - get active user id.
+    user_id = 1
+
+    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,
+                   icon: str,
+                   creator: str = None,
+                   db: SessionLocal = Depends()):
+    """Creates a feature."""
+
+    db = SessionLocal()
+
+    if icon is None:
+        icon = "extension-puzzle"
+
+    feature = create_model(
+        db, Feature,
+        name=name,
+        route=route,
+        creator=creator,
+        description=description,
+        icon=icon
+    )
+    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)):
+
+    # TODO - get active user id
+    user_id = 1
+
+    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)):
+
+    # TODO - get active user id
+    user_id = 1
+
+    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,12 +1,14 @@
 from fastapi import Depends, FastAPI, Request
 from fastapi.staticfiles import StaticFiles
 from sqlalchemy.orm import Session
+from starlette.responses import RedirectResponse
 
 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.routers.salary import routes as salary
 
@@ -39,7 +41,7 @@ def create_tables(engine, psql_environment):
 
     agenda, calendar, categories, celebrity, currency, dayview,
     email, event, export, four_o_four, invitation, profile, search,
-    weekview, telegram, whatsapp,
+    weekview, telegram, whatsapp, features
 )
 
 json_data_loader.load_to_db(next(get_db()))
@@ -62,14 +64,42 @@ def create_tables(engine, psql_environment):
     search.router,
     telegram.router,
     whatsapp.router,
+    features.router,
 ]
 
 for router in routers_to_include:
     app.include_router(router)
 
 
+@app.middleware("http")
+async def filter_access_to_features(request: Request, call_next):
+
+    # getting the url route path for matching with the database.
+    route = '/' + str(request.url).replace(str(request.base_url), '')
+
+    # getting access status.
+    is_enabled = internal_features.is_feature_enabled(route=route)
+    if is_enabled:
+        # in case the feature is enabled or access is allowed.
+        return await call_next(request)
+
+    elif 'referer' not in request.headers:
+        # in case request come straight from address bar in browser.
+        return RedirectResponse(url=app.url_path_for('home'))
+
+    # in case the feature is disabled or access isn't allowed.
+    return RedirectResponse(url=request.headers['referer'])
+
+
+@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.
+# until the relavent calendar view will be developed.
 @app.get("/")
 @logger.catch()
 async def home(request: Request, db: Session = Depends(get_db)):