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

@@ -1,7 +1,7 @@
 from fastapi import APIRouter, status, HTTPException, Depends
 from sqlalchemy import select, Sequence
 from src.core.log_conf import logger
-from src.db.repository.media import create_new_mediaactorfile, create_new_mediafile
+from src.db.repository.media import create_new_mediaactorfile, create_new_mediafile, delete_mediafile
 from src.db.session import SessionDep
 from src.schema.media.actor import MediaActorResponse
 from src.schema.media.actorfile import MediaActorFileResponse
@@ -47,6 +47,17 @@ def get_file(file_id: str, db: SessionDep) -> MediaFileResponse:
     response = get_file_details(mediafile)
     return response
 
+@router.delete("/files/{file_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_file(file_id: str, db: SessionDep):
+    mediafile = db.get(MediaFile, file_id)
+    if not mediafile:
+        raise HTTPException(status_code=404, detail="MediaFile could not be found")
+    logger.info(f"delete MediaFile: {file_id}")
+    actor_files = mediafile.media_actor_files
+    logger.info(f"MediaActorFiles links {len(actor_files)}")
+    if len(actor_files) == 0:
+        delete_mediafile(db, mediafile.id)
+
 @router.get("/files/{file_id}/actors", response_model=list[MediaActorResponse])
 def get_file_actors(file_id: str, db: SessionDep) -> list[MediaActorResponse]:
     mediafile = db.get(MediaFile, file_id)

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

@@ -38,6 +38,12 @@ def create_new_mediafile(link: str, db: Session) -> MediaFile:
     logger.info(f"created {media_file}")
     return media_file
 
+def delete_mediafile(db: Session, media_file_id: str):
+    logger.info(f"delete MediaFile with id {media_file_id}")
+    media_file = db.get(MediaFile, media_file_id)
+    db.delete(media_file)
+    db.commit()
+
 def create_new_mediaactor(new_actor: Actor, db: Session) -> MediaActor:
     logger.info(f"create MediaActor with url {new_actor.url}")
     media_actor: MediaActor = MediaActor()

kontor-scripts/import.py

@@ -4,22 +4,25 @@ import data from json file to PostgreSQL
 from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
 
 from datetime import datetime, date
+from logging import Logger
 from typing import Any, Dict, List
 import os
 import json
 
 from pathlib import Path
+import requests
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker, Session
 from db.models.base import Base
 from db.models import registry
 from psycopg2.errors import NotNullViolation
-from config import get_logger
+from config import get_api_config, get_logger
 
 parser = ArgumentParser(formatter_class=ArgumentDefaultsHelpFormatter)
 parser.add_argument('--verbose', '-v', action='count', default=0)
+parser.add_argument("--config", "-c", default="kontor-docker")
 parser.add_argument('--dry-run', '-m', action='store_true')
-parser.add_argument('--cleanup', '-c', action='store_true')
+parser.add_argument('--cleanup', '-d', action='store_true')
 parser.add_argument('--file', '-f', default='~/data.json')
 args = parser.parse_args()
 
@@ -109,10 +112,26 @@ def item_import(db: Session, import_data: Dict[str, Any], dry_run: bool, log):
         except Exception as error:
             log.info(f"import failed: {error}")
 
+def item_delete(table_name: str, item_id: str, api_data: Dict[str, Any], log: Logger):
+    log.info(f"delete item {item_id} from {table_name}")
+    host = api_data["host"]
+    port = api_data["port"]
+    token = api_data['token']
+    url = ""
+    match table_name:
+        case "media_file":
+            url = f"http://{host}:{port}/api/media/files/{item_id}"
+        case "media_actor_file":
+            url = f"http://{host}:{port}/api/media/actorfiles/{item_id}"
+    headers: Dict[str, str] = {"Authorization": f"Bearer {token}"}
+    response = requests.delete(url, headers=headers)
+    log.debug(f"Status: {response.status_code}")
+
 
 if __name__ == '__main__':
     logger = get_logger(args.verbose, "kontor")
     logger.info('kontor.import started')
+    api_data = get_api_config(logger, args.config)
     engine = create_engine(DATABASE_URL)
     Base.metadata.create_all(bind=engine, checkfirst=True)
     SessionLocal = sessionmaker(bind=engine)
@@ -142,4 +161,13 @@ if __name__ == '__main__':
             logger.debug(f"remaining items for {tablename}: {len(existing_ids)}")
             if len(existing_ids) > 0:
                 logger.info(f"remaining items for {tablename}: {existing_ids}")
+            for item_id in existing_ids:
+                match tablename:
+                    case "media_file":
+                        item_delete(table_name=tablename, item_id=item_id, api_data=api_data, log=logger)
+                    case "media_actor_file":
+                        item_delete(table_name=tablename, item_id=item_id, api_data=api_data, log=logger)
+                    case _:
+                        logger.info("Method to remove remaining item not implemented")
+                        
     logger.info('kontor.import finished')