add display for MetaData

kontor-api/src/apis/base.py

@@ -1,8 +1,10 @@
 from fastapi import APIRouter
 
-from src.apis.version1 import comic, media, tysc
+from src.apis.version1 import comic, media, tysc, admin, metadata
 
 api_router =  APIRouter(prefix="/api")
-api_router.include_router(comic.router, tags=["comics"])
-api_router.include_router(media.router, tags=["media"])
-api_router.include_router(tysc.router, tags=["tysc"])
+api_router.include_router(comic.router, prefix="/comics", tags=["comics"])
+api_router.include_router(media.router, prefix="/media", tags=["media"])
+api_router.include_router(tysc.router, prefix="/tysc", tags=["tysc"])
+api_router.include_router(admin.router, prefix="/login", tags=["login"])
+api_router.include_router(metadata.router, prefix="/metadata", tags=["metadata"])

kontor-api/src/apis/utils.py

@@ -1,4 +1,13 @@
 from typing import Annotated
+from typing import Dict
+from typing import Optional
+
+from fastapi import HTTPException
+from fastapi import Request
+from fastapi import status
+from fastapi.openapi.models import OAuthFlows as OAuthFlowsModel
+from fastapi.security import OAuth2
+from fastapi.security.utils import get_authorization_scheme_param
 
 from fastapi import Depends
 from sqlalchemy.orm import Session
@@ -6,3 +15,34 @@ from sqlalchemy.orm import Session
 from src.db.session import get_db
 
 SessionDep = Annotated[Session, Depends(get_db)]
+
+
+class OAuth2PasswordBearerWithCookie(OAuth2):
+    def __init__(
+        self,
+        tokenUrl: str,
+        scheme_name: Optional[str] = None,
+        scopes: Optional[Dict[str, str]] = None,
+        auto_error: bool = True,
+    ):
+        if not scopes:
+            scopes = {}
+        flows = OAuthFlowsModel(password={"tokenUrl": tokenUrl, "scopes": scopes})
+        super().__init__(flows=flows, scheme_name=scheme_name, auto_error=auto_error)
+
+    async def __call__(self, request: Request) -> Optional[str]:
+        authorization: str = request.cookies.get(
+            "access_token"
+        )  # changed to accept access token from httpOnly Cookie
+
+        scheme, param = get_authorization_scheme_param(authorization)
+        if not authorization or scheme.lower() != "bearer":
+            if self.auto_error:
+                raise HTTPException(
+                    status_code=status.HTTP_401_UNAUTHORIZED,
+                    detail="Not authenticated",
+                    headers={"WWW-Authenticate": "Bearer"},
+                )
+            else:
+                return None
+        return param

kontor-api/src/apis/version1/admin.py

@@ -0,0 +1,69 @@
+import logging
+from datetime import timedelta
+
+import bcrypt
+from fastapi import APIRouter, HTTPException, status, Response, Depends
+from fastapi.security import OAuth2PasswordRequestForm
+from jose import jwt, JWTError
+from src.apis.utils import SessionDep, OAuth2PasswordBearerWithCookie
+from src.core.config import settings
+from src.core.security import create_access_token
+from src.db.models.admin import Profile
+from src.db.repository.admin import get_profile
+from src.schema.admin import Token
+
+router = APIRouter()
+
+
+def authenticate_user(username: str, password: str, db: SessionDep) -> Profile | None:
+    user = get_profile(username=username, db=db)
+    print(user)
+    if not user:
+        return None
+    if bcrypt.checkpw(password.encode(), user.password.encode()):
+        print("User successful authenticated")
+    else:
+        logging.info("Authentication failed!")
+    return user
+
+
+@router.post("/token", response_model=Token)
+def login_for_access_token(response: Response, db: SessionDep, form_data: OAuth2PasswordRequestForm = Depends()):
+    user = authenticate_user(form_data.username, form_data.password, db)
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+        )
+    access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+    access_token = create_access_token(
+        data={"sub": user.email}, expires_delta=access_token_expires
+    )
+    response.set_cookie(
+        key="access_token", value=f"Bearer {access_token}", httponly=True
+    )
+    return {"access_token": access_token, "token_type": "bearer"}
+
+
+oauth2_scheme = OAuth2PasswordBearerWithCookie(tokenUrl="/api/login/token")
+
+
+def get_current_user_from_token(db: SessionDep, token: str = Depends(oauth2_scheme)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+    )
+    try:
+        payload = jwt.decode(
+            token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM]
+        )
+        username: str = payload.get("sub")
+        print("username/email extracted is ", username)
+        if username is None:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+    user = get_profile(username=username, db=db)
+    if user is None:
+        raise credentials_exception
+    return user

kontor-api/src/apis/version1/comic.py

@@ -8,11 +8,7 @@ from src.schema.comics.artist import ArtistCreation, ArtistDetailResponse, Artis
 from src.db.models.comic import Comic, Artist, Issue
 from src.schema.comics.issue import IssueDetailsResponse
 
-router = APIRouter(
-    prefix="/comic",
-    tags=["comics"],
-    responses={404: {"description": "Not found"}},
-)
+router = APIRouter()
 
 
 @router.get("/comics")

kontor-api/src/apis/version1/media.py

@@ -1,22 +1,20 @@
 from typing import List, AnyStr
-from uuid import UUID
 
-from fastapi import APIRouter, status, HTTPException
+from fastapi import APIRouter, status, HTTPException, Depends
 from sqlalchemy import select, Sequence
 
 from src.apis.utils import SessionDep
+from src.apis.version1.admin import get_current_user_from_token
+from src.db.models.admin import Profile
 from src.schema.media.file import MediaFileResponse, Link, get_file_details, set_file
 from src.db.models.media import MediaFile
 
-router = APIRouter(
-    prefix="/media",
-    tags=["media"]
-)
+router = APIRouter()
 
 @router.get("/update-titles")
 def update_titles(db: SessionDep) -> list[MediaFileResponse]:
     results: list[MediaFileResponse] = []
-    files = db.query(MediaFile).filter(MediaFile.review == 1).all()
+    files = db.query(MediaFile).filter(MediaFile.review == True).all()
     for mediafile in files:
         mediafile.update_title()
         db.add(mediafile)
@@ -27,13 +25,13 @@ def update_titles(db: SessionDep) -> list[MediaFileResponse]:
 
 
 @router.get("/files", response_model=List[MediaFileResponse])
-def get_all_files(db: SessionDep, review: bool = False, download: bool = False) -> List[MediaFileResponse]:
+def get_all_files(db: SessionDep, review: bool = False, download: bool = False, current_user: Profile = Depends(get_current_user_from_token)) -> List[MediaFileResponse]:
     results: list[MediaFileResponse] = []
     files: Sequence[MediaFile]
     if review:
-        files = db.query(MediaFile).filter(MediaFile.review == 1).all()
+        files = db.query(MediaFile).filter(MediaFile.review == True).all()
     elif download:
-        files = db.query(MediaFile).filter(MediaFile.should_download == 1).all()
+        files = db.query(MediaFile).filter(MediaFile.should_download == True).all()
     else:
         files = db.scalars(select(MediaFile)).all()
     for mediafile in files:
@@ -66,8 +64,8 @@ def add_file(new_link: Link, db: SessionDep) -> MediaFileResponse:
     try:
         mediaFile: MediaFile = MediaFile()
         setattr(mediaFile, "url", new_link.url)
-        setattr(mediaFile, "review", 1)
-        setattr(mediaFile, "should_download", 1)
+        setattr(mediaFile, "review", True)
+        setattr(mediaFile, "should_download", True)
         db.add(mediaFile)
         db.commit()
     except:

kontor-api/src/apis/version1/metadata.py

@@ -0,0 +1,26 @@
+from typing import List
+
+from fastapi import APIRouter
+
+from src.apis.utils import SessionDep
+from src.db.models.metadata import MetaDataTable, MetaDataColumn
+from src.db.repository.metadata import get_tables, get_columns
+from src.schema.admin import MetaDataTableResponse, MetaDataColumnResponse
+
+router = APIRouter()
+
+
+
+@router.get("/tables")
+def get_meta_data_tables(db: SessionDep) -> List[MetaDataTableResponse]:
+    tables = db.query(MetaDataTable).all()
+    response: List[MetaDataTableResponse] = get_tables(tables)
+    return response
+
+
+
+@router.get("/columns")
+def get_meta_data_columns(db: SessionDep) -> List[MetaDataColumnResponse]:
+    columns = db.query(MetaDataColumn).all()
+    response: List[MetaDataColumnResponse] = get_columns(columns)
+    return response

kontor-api/src/apis/version1/tysc.py

@@ -5,11 +5,7 @@ from src.apis.utils import SessionDep
 from src.schema.tysc.sport import SportResponse
 from src.db.models.tysc import Sport
 
-router = APIRouter(
-    prefix="/tysc",
-    tags=["tysc"],
-    responses={404: {"description": "Not found"}},
-)
+router = APIRouter()
 
 @router.get("/sports")
 def get_all_sports(db: SessionDep) -> List[SportResponse]:

kontor-api/src/core/config.py

@@ -17,7 +17,9 @@ class Settings:
     DB_PORT: str = os.getenv("DB_PORT", 5432)
     DB_DBNAME: str = os.getenv("DB_DBNAME", "kontor")
     DATABASE_URL: str = f"postgresql://{DB_USER}:{DB_PASSWORD}@{DB_SERVER}:{DB_PORT}/{DB_DBNAME}"
-
+    SECRET_KEY: str = os.getenv("SECRET_KEY", "J6GOtcwC2NJI1l0VkHu20PacPFGTxpirBxWwynoHjsc=")
+    ALGORITHM = "HS256"
+    ACCESS_TOKEN_EXPIRE_MINUTES = 30  # in mins
 
 settings = Settings()
 

kontor-api/src/core/security.py

@@ -0,0 +1,21 @@
+from datetime import datetime
+from datetime import timedelta
+from typing import Optional
+
+from src.core.config import settings
+from jose import jwt
+
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(
+            minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES
+        )
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(
+        to_encode, settings.SECRET_KEY, algorithm=settings.ALGORITHM
+    )
+    return encoded_jwt

kontor-api/src/db/models/admin.py

@@ -27,6 +27,9 @@ class Profile(Base, BaseMixin):
             full_name += self.last_name
         return full_name
 
+    def __str__(self):
+        return f"Profile({self.id} {self.user_name}, {self.email})"
+
 
 class Token(Base, BaseMixin):
     __tablename__ = "token"

kontor-api/src/db/models/database.py

@@ -1,10 +1,9 @@
 import json
 import logging
-import uuid
 from datetime import datetime
 from enum import Enum, auto
 from pathlib import Path
-from typing import Any
+from typing import Any, List
 
 from sqlalchemy import select
 from sqlalchemy.exc import IntegrityError
@@ -360,7 +359,7 @@ class KontorDB:
                 update_list[link.id] = link.title
         return update_list
 
-    def get_download_list(self) -> list[uuid.UUID]:
+    def get_download_list(self) -> List[str]:
         download_list = []
         __session__ = sessionmaker(self.engine)
         _filter = { 'should_download': True}

kontor-api/src/db/repository/admin.py

@@ -0,0 +1,10 @@
+from typing import AnyStr
+
+from sqlalchemy.orm import Session
+
+from src.db.models.admin import Profile
+
+
+def get_profile(username: AnyStr, db: Session):
+    profile = db.query(Profile).filter(Profile.email == username).first()
+    return profile

kontor-api/src/db/repository/metadata.py

@@ -0,0 +1,32 @@
+from typing import List
+
+from src.db.models.metadata import MetaDataTable, MetaDataColumn
+from src.schema.admin import MetaDataTableResponse, MetaDataColumnResponse
+
+
+def get_tables(tables: List[MetaDataTable]) -> List[MetaDataTableResponse]:
+    results: List[MetaDataTableResponse] = []
+    for table in tables:
+        result = MetaDataTableResponse(id=table.id, name=table.table_name)
+        results.append(result)
+    return results
+
+def get_columns(columns: List[MetaDataColumn]) -> List[MetaDataColumnResponse]:
+    results: List[MetaDataColumnResponse] = []
+    for column in columns:
+        result = MetaDataColumnResponse(
+            id=column.id,
+            table_name=column.table.table_name,
+            column_name=column.column_name,
+            column_sync_name=column.column_sync_name,
+            column_type=column.column_type,
+            column_modifier=column.column_modifier,
+            column_order=column.column_order,
+            is_shown=column.is_shown,
+            column_label=column.column_label,
+            show_filter=column.show_filter,
+            filter_label=column.filter_label,
+            ref_column=column.ref_column
+        )
+        results.append(result)
+    return results

kontor-api/src/db/utils.py

@@ -0,0 +1,28 @@
+import databases
+from src.db.session import SQLALCHEMY_DATABASE_URL
+
+
+async def check_db_connected():
+    try:
+        if not str(SQLALCHEMY_DATABASE_URL).__contains__("sqlite"):
+            database = databases.Database(SQLALCHEMY_DATABASE_URL)
+            if not database.is_connected:
+                await database.connect()
+                await database.execute("SELECT 1")
+        print("Database is connected (^_^)")
+    except Exception as e:
+        print(
+            "Looks like db is missing or is there is some problem in connection,see below traceback"
+        )
+        raise e
+
+
+async def check_db_disconnected():
+    try:
+        if not str(SQLALCHEMY_DATABASE_URL).__contains__("sqlite"):
+            database = databases.Database(SQLALCHEMY_DATABASE_URL)
+            if database.is_connected:
+                await database.disconnect()
+        print("Database is Disconnected (-_-) zZZ")
+    except Exception as e:
+        raise e

kontor-api/src/main.py

@@ -1,10 +1,12 @@
 import logging
+from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
 from fastapi.staticfiles import StaticFiles
 
 from src.apis.base import api_router
 from src.db.session import engine
+from src.db.utils import check_db_connected, check_db_disconnected
 from src.webapps.base import api_router as web_app_router
 from src.core.config import settings
 from src.db.models.base import Base
@@ -13,6 +15,12 @@ logging.basicConfig(level=logging.INFO,
                     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
                     handlers=[logging.StreamHandler()])  # Logs to console
 
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await check_db_connected()
+    yield
+    await check_db_disconnected()
+
 def include_router(app: FastAPI):
     app.include_router(api_router)
     app.include_router(web_app_router)
@@ -25,7 +33,7 @@ def create_tables():
 
 def start_application():
     logging.info(f"using database: {settings.DATABASE_URL}")
-    app = FastAPI(title=settings.PROJECT_NAME, version=settings.PROJECT_VERSION)
+    app = FastAPI(title=settings.PROJECT_NAME, version=settings.PROJECT_VERSION, lifespan=lifespan)
     include_router(app)
     configure_static(app)
     create_tables()

kontor-api/src/schema/admin.py

@@ -0,0 +1,26 @@
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+class MetaDataTableResponse(BaseModel):
+    id: str
+    name: str
+
+class MetaDataColumnResponse(BaseModel):
+    id: str
+    table_name: str
+    column_name: str
+    column_sync_name: str
+    column_type: str
+    column_modifier: Optional[str]
+    column_order: int
+    is_shown: bool
+    column_label: Optional[str]
+    show_filter: bool
+    filter_label: Optional[str]
+    ref_column: Optional[str]

kontor-api/src/schema/comics/artist.py

@@ -1,9 +1,7 @@
 from typing import List, Dict
-from uuid import UUID
 
 from pydantic import BaseModel
 
-from src.db.models.comic import Artist
 
 
 class ArtistCreation(BaseModel):

kontor-api/src/schema/comics/comic.py

@@ -1,5 +1,4 @@
 from typing import List, Dict
-from uuid import UUID
 
 from pydantic import BaseModel
 

kontor-api/src/schema/media/file.py

@@ -1,12 +1,12 @@
 from datetime import datetime
-from uuid import UUID
+from typing import AnyStr
 
 from src.db.models.media import MediaFile
 from pydantic import BaseModel
 
 
 class MediaFileResponse(BaseModel):
-    id: UUID
+    id: AnyStr
     title: str | None = None
     file_name: str | None = None
     cloud_link: str | None = None

kontor-api/src/schema/tysc/sport.py

@@ -1,8 +1,8 @@
-from uuid import UUID
 
+from typing import AnyStr
 from pydantic import BaseModel
 
 
 class SportResponse(BaseModel):
-    id: UUID
+    id: AnyStr
     name: str

kontor-api/src/templates/admin/metadata.html

@@ -0,0 +1,21 @@
+{% extends "shared/base.html" %}
+
+{% block title %}
+  <title>MetaData</title>
+{% endblock %}
+
+{% block content %}
+  {% with msg=msg %}
+    {% include "components/alerts.html" %}
+  {% endwith %}
+  <div class="container">
+    {% for table in data %}
+    <div class="row">
+        {% with obj=table %}
+      	  {% include "components/metadatatable_cards.html" %}
+        {% endwith %}
+      <br>
+    </div>
+    {% endfor %}
+  </div>
+{% endblock %}

kontor-api/src/templates/auth/login.html

@@ -0,0 +1,40 @@
+{% extends "shared/base.html" %}
+
+
+{% block title %}
+  <title>Login</title>
+{% endblock %}
+
+{% block content %}
+  <div class="container">
+    <div class="row">
+      <h5 class="display-5">Login to Kontor</h5>
+      <div class="text-danger font-weight-bold">
+          {% for error in errors %}
+            <li>{{error}}</li>
+          {% endfor %}
+      </div>
+      <div class="text-success font-weight-bold">
+        {% if msg %}
+        <div class="badge bg-success text-wrap font-weight-bold" style="font-size: large;">
+          {{msg}}
+        </div>
+        {% endif %}
+    </div>
+    </div>
+
+    <div class="row my-5">
+      <form method="POST">
+        <div class="mb-3">
+          <label>Email</label>
+          <input type="text" required placeholder="Your email" name="email" value="{{email}}" class="form-control">
+        </div>
+        <div class="mb-3">
+          <label>Password</label>
+          <input type="password" required placeholder="Choose a secure password" value="{{password}}" name="password" class="form-control">
+        </div>
+        <button type="submit" class="btn btn-primary">Submit</button>
+      </form>
+    </div>
+  </div>
+  {% endblock %}

kontor-api/src/templates/components/metadatatable_cards.html

@@ -0,0 +1,35 @@
+<div class="card shadow p-3 mb-2 bg-body rounded">
+  <div class="card-body">
+    <h5 class="card-title">{{obj.table_name}}</h5>
+    <table class="table table-hover">
+      <thead><tr>
+        <th scope="col">Column Name</th>
+        <th scope="col">Column Sync Name</th>
+        <th scope="col">Column Type</th>
+        <th scope="col">Column Modifier</th>
+        <th scope="col">Column Order</th>
+        <th scope="col">Is Shown</th>
+        <th scope="col">Column Label</th>
+        <th scope="col">Show Filter</th>
+        <th scope="col">Filter Label</th>
+        <th scope="col">Ref Column</th>
+      </tr></thead>
+      <tbody>
+        {% for column in obj.table_columns %}
+        <tr>
+           <th scope="row"><a href="/admin/metadata/{{column.id}}">{{column.column_name}}</a></th>
+           <td>{{column.column_sync_name}}</td>
+           <td>{{column.column_type}}</td>
+           <td>{{column.column_modifier}}</td>
+           <td>{{column.column_order}}</td>
+           <td>{% with check=column.is_shown %}{% include "components/check.html" %}{% endwith %}</td>
+           <td>{{column.column_label}}</td>
+           <td>{% with check=column.show_filter %}{% include "components/check.html" %}{% endwith %}</td>
+           <td>{{column.filter_label}}</td>
+           <td>{{column.ref_column}}</td>
+        </tr>
+        {% endfor %}
+      </tbody>
+    </table>
+  </div>
+</div>

kontor-api/src/templates/components/navbar.html

@@ -42,7 +42,7 @@
             <li><a class="dropdown-item" href="/register/">Signup</a></li>
             <li><a class="dropdown-item" href="/login/">Login</a></li>
             <li><hr class="dropdown-divider"></li>
-            <li><a class="dropdown-item" href="#">Something else here</a></li>
+            <li><a class="dropdown-item" href="/admin/metadata">MetaData</a></li>
           </ul>
         </li>
       </ul>

kontor-api/src/webapps/admin/route_admin.py

@@ -0,0 +1,24 @@
+from fastapi import APIRouter, Request
+from fastapi.security.utils import get_authorization_scheme_param
+from fastapi.templating import Jinja2Templates
+
+from src.apis.utils import SessionDep
+from src.apis.version1.admin import get_current_user_from_token
+from src.db.models.admin import Profile
+from src.db.models.metadata import MetaDataColumn, MetaDataTable
+from src.db.repository.metadata import get_columns
+
+templates = Jinja2Templates(directory="src/templates")
+router = APIRouter(include_in_schema=False, prefix="/admin")
+
+@router.get("/metadata")
+def get_metadata(db: SessionDep, request: Request, msg: str = None):
+    token = request.cookies.get("access_token")
+    scheme, param = get_authorization_scheme_param(token)
+    current_user: Profile = get_current_user_from_token(token=param, db=db)
+    data = []
+    if current_user is None:
+        msg = "You are not logged in"
+        return templates.TemplateResponse("admin/metadata.html", {"request": request, "msg": msg, "data": data})
+    tables= db.query(MetaDataTable).all()
+    return templates.TemplateResponse("admin/metadata.html", {"request": request, "msg": msg, "data": tables})

kontor-api/src/webapps/auth/forms.py

@@ -0,0 +1,27 @@
+from typing import List
+from typing import Optional
+
+from fastapi import Request
+
+
+class LoginForm:
+    def __init__(self, request: Request):
+        self.request: Request = request
+        self.errors: List = []
+        self.username: Optional[str] = None
+        self.password: Optional[str] = None
+
+    async def load_data(self):
+        form = await self.request.form()
+        # since auth works on username field we are considering email as username
+        self.username = form.get("email")
+        self.password = form.get("password")
+
+    async def is_valid(self):
+        if not self.username or not (self.username.__contains__("@")):
+            self.errors.append("Email is required")
+        if not self.password or not len(self.password) >= 4:
+            self.errors.append("A valid password is required")
+        if not self.errors:
+            return True
+        return False

kontor-api/src/webapps/auth/route_login.py

@@ -0,0 +1,35 @@
+from src.apis.version1.admin import login_for_access_token
+from src.db.session import get_db
+from fastapi import APIRouter
+from fastapi import Depends
+from fastapi import HTTPException
+from fastapi import Request
+from fastapi.templating import Jinja2Templates
+from sqlalchemy.orm import Session
+from src.webapps.auth.forms import LoginForm
+
+
+templates = Jinja2Templates(directory="src/templates")
+router = APIRouter(include_in_schema=False)
+
+
+@router.get("/login/")
+def login(request: Request):
+    return templates.TemplateResponse("auth/login.html", {"request": request})
+
+
+@router.post("/login/")
+async def login(request: Request, db: Session = Depends(get_db)):
+    form = LoginForm(request)
+    await form.load_data()
+    if await form.is_valid():
+        try:
+            form.__dict__.update(msg="Login Successful :)")
+            response = templates.TemplateResponse("auth/login.html", form.__dict__)
+            login_for_access_token(response=response, form_data=form, db=db)
+            return response
+        except HTTPException:
+            form.__dict__.update(msg="")
+            form.__dict__.get("errors").append("Incorrect Email or Password")
+            return templates.TemplateResponse("auth/login.html", form.__dict__)
+    return templates.TemplateResponse("auth/login.html", form.__dict__)

kontor-api/src/webapps/base.py

@@ -1,6 +1,8 @@
 from fastapi import APIRouter, Request
 from fastapi.templating import Jinja2Templates
 
+from src.webapps.admin import route_admin
+from src.webapps.auth import route_login
 from src.webapps.comic import route_comics
 from src.webapps.media import route_media
 
@@ -9,6 +11,8 @@ templates = Jinja2Templates(directory="src/templates")
 api_router = APIRouter()
 api_router.include_router(route_comics.router)
 api_router.include_router(route_media.router)
+api_router.include_router(route_login.router)
+api_router.include_router(route_admin.router)
 
 @api_router.get("/")
 def home(request: Request, msg: str = None):

kontor-api/src/webapps/media/route_media.py

@@ -1,11 +1,13 @@
-from uuid import UUID
+from typing import AnyStr
 
 from fastapi import APIRouter, Request
+from fastapi.security.utils import get_authorization_scheme_param
 from fastapi.templating import Jinja2Templates
 
 from src.apis.utils import SessionDep
+from src.apis.version1.admin import get_current_user_from_token
+from src.db.models.admin import Profile
 from src.db.models.media import MediaFile, MediaActor
-#ifrom src.schema.media.comic import get_comic_details
 
 templates = Jinja2Templates(directory="src/templates")
 router = APIRouter(include_in_schema=False, prefix="/media")
@@ -13,10 +15,19 @@ router = APIRouter(include_in_schema=False, prefix="/media")
 @router.get("/files")
 def get_mediafiles(db: SessionDep, request: Request, msg: str = None):
     mediafiles = db.query(MediaFile).all()
-    return templates.TemplateResponse("media/files.html", {"request": request, "msg": msg, "mediafiles": mediafiles})
+    try:
+        token = request.cookies.get("access_token")
+        scheme, param = get_authorization_scheme_param(token)  # scheme will hold "Bearer" and param will hold actual token value
+        current_user: Profile = get_current_user_from_token(token=param, db=db)
+        return templates.TemplateResponse("media/files.html",
+                                          {"request": request, "msg": msg, "mediafiles": mediafiles})
+    except Exception as e:
+        print(e)
+        msg = "Nicht berechtigt!!"
+        return templates.TemplateResponse("media/files.html", {"request": request, "msg": msg, "mediafiles": []})
 
 @router.get("/files/{file_id}")
-def file_details(file_id: UUID, request: Request, db: SessionDep):
+def file_details(file_id: AnyStr, request: Request, db: SessionDep):
     mediafile = db.get(MediaFile, file_id)
     return templates.TemplateResponse("media/file_detail.html", {"request": request, "mediafile":mediafile})
 
@@ -26,7 +37,7 @@ def get_actors(db: SessionDep, request: Request, msg: str = None):
     return templates.TemplateResponse("media/actors.html", {"request": request, "msg": msg, "actors": actors})
 
 @router.get("/actors/{actor_id}")
-def artist_detail(actor_id: UUID, request: Request, db: SessionDep):
+def artist_detail(actor_id: AnyStr, request: Request, db: SessionDep):
     actor = db.get(MediaActor, actor_id)
     return templates.TemplateResponse("media/actor_detail.html", {"request": request, "actor": actor})