* Make API to upload an Image work

toolbox/src/access/db/__init__.py

@@ -34,28 +34,28 @@ def session_scope():
 meta = MetaData()
 
 Base = declarative_base()
-
-
-class Purpose(Base):
-    __tablename__ = "purpose"
+    
+    
+class Purposes(Base):
+    __tablename__ = "purposes"
     id = Column(Integer, primary_key=True)
     name = Column(String(100), nullable=False, unique=True)
     # Column("parent_id", Integer, ForeignKey('tree.id')),
     # relationship("parent", 'Tree', remote_side=[id])
 
 
-class PurposeException(Base):
-    __tablename__ = "purpose_exception"
+class Exceptions(Base):
+    __tablename__ = "exceptions"
     id = Column(Integer, primary_key=True)
     name = Column(String(100), unique=True)
-    purpose_id = Column(Integer, ForeignKey('purpose.id'))
+    purpose_id = Column(Integer, ForeignKey('purposes.id'))
     exception_list = Column(String(100))
 
 
-class Transformation(Base):
-    __tablename__ = "transformation"
+class Transformations(Base):
+    __tablename__ = "transformations"
     id = Column(Integer, primary_key=True)
-    name = Column(Integer, ForeignKey('purpose.id'), unique=True)
+    name = Column(Integer, ForeignKey('purposes.id'), unique=True)
     transformation_list = Column("transformation_list", String(100))
 
 

toolbox/src/access/pap.py

@@ -1,15 +1,21 @@
 import logging
-from fastapi import APIRouter
-import hashlib
+from fastapi import APIRouter, HTTPException
 from . import enforcer as e
-from access.db import database, session_scope, Purpose
+from access.db import session_scope, Purposes
+from pydantic import BaseModel
+from typing import Optional
 
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.DEBUG)
 
 pap_router = APIRouter()
 
 
+class PurposeIn(BaseModel):
+    name: str
+    # exceptions: Optional[list[str]] = [""]
+    # transformations: Optional[list[str]] = [""]
+
+
 class ListHandler(logging.Handler):
     def __init__(self, log_list):
         super().__init__()
@@ -21,17 +27,23 @@ def emit(self, record):
 
 
 @pap_router.post("/purpose/{purpose_name}", status_code=200)
-async def add_purpose(purpose_name: str):
+async def add_purpose(purpose: PurposeIn):
+    purpose_dict = purpose.dict()
     with session_scope() as session:
-        query = session.insert(Purpose).values(name=purpose_name)
-        last_record_id = await database.execute(query)
-        logger.info(f"Added new purpose: {purpose_name}")
+        purpose = Purposes(**purpose_dict)
+        try:
+            query = session.add(purpose)
+        except Exception as exc:
+            raise HTTPException(detail=f"A purpose with that name already exists. {exc.pgerror}", status_code=405)
+        # last_record_id = await database.execute(query)
+        logger.info(f"Added new purpose: {purpose_dict['name']}")
+        return {**purpose_dict, "id": 0}
 
 
-@pap_router.get("/purpose")
+@pap_router.get("/purposes")
 def list_purposes():
     with session_scope() as session:
-        purposes = session.query(Purpose).all()
+        purposes = session.query(Purposes).all()
         return purposes
 
 
@@ -51,12 +63,3 @@ def add_exception(item):
     purpose_name = items_dict["purpose"]
     logger.info(f"Added new exception for purpose: {purpose_name}")
 
-
-def tag_content(content, purpose: str):
-    my_list_as_bytes = str(content).encode()
-    my_hash = hashlib.sha256(my_list_as_bytes)
-    sub = ""
-    obj = my_hash
-    act = ""
-    purp = purpose
-    e.add_policy(sub, obj, act, purpose)

toolbox/src/access/pep.py

@@ -2,6 +2,8 @@
 import logging
 from fastapi import Request
 from exceptions import InvalidPurposeException
+from PIL import Image
+from utils import calculate_image_hash
 
 logger = logging.getLogger(__name__)
 
@@ -18,3 +20,9 @@ def _middleware(request: Request):
         return request
 
     return _middleware
+
+
+def tag_content(content: Image, sub: str = None, act: str = None, purp: str = None):
+    obj = calculate_image_hash(content)
+    logger.info(f"Adding a new policy rule with sub: {sub}, obj: {obj}, act: {act}, purp: {purp}")
+    enforcer.add_policy(sub, obj, act, purp)

toolbox/src/cloud/gcp/__init__.py

@@ -1,8 +1,11 @@
+import os
+
 from google.oauth2 import service_account
 
-credentials = service_account.Credentials.from_service_account_file('./creds.json')
+credentials = service_account.Credentials.from_service_account_file(os.getenv("GCP_CRED_FILE"))
 
 from fastapi import APIRouter
 
 gcp_router = APIRouter()
 import cloud.gcp.bq
+import cloud.gcp.storage

toolbox/src/cloud/gcp/bq.py

@@ -1,30 +1,27 @@
+import os
+
 from google.cloud import bigquery
 import logging
 from . import gcp_router, credentials
 
 logger = logging.getLogger(__name__)
 client = bigquery.Client(credentials=credentials,
-                         project="tu-berlin-privacy-engineering")
-
+                         project=os.getenv("GCP_PROJECT_NAME"))
 
-@gcp_router.get("/bq/dummy")
-def dummy():
-    return {"result": "test"}
 
-
-@gcp_router.get("/bq/query")
+@gcp_router.get("/bq/{query}")
 def query_bq(query: str):
     """Executes a client query in BigQuery and returns the result."""
     query_job = client.query(query)
     return list(query_job)
 
 
-@gcp_router.post("/bq/create")
+@gcp_router.post("/bq")
 def create_bq_dataset(dataset_id: str, location: str) -> str:
     """
     Create a new dataset in BigQuery based on the query params.
     """
-
+    
     dataset = bigquery.Dataset(dataset_id)
     dataset.location = location
     dataset = client.create_dataset(dataset, timeout=30)  # Make an API request.
@@ -33,7 +30,7 @@ def create_bq_dataset(dataset_id: str, location: str) -> str:
     return {"result": "success"}
 
 
-@gcp_router.delete("/bq/delete")
+@gcp_router.delete("/bq")
 def delete_bq_dataset(dataset_id: str) -> str:
     """Deletes a dataset in BigQuery."""
     client.delete_dataset(dataset_id, delete_contents=True, not_found_ok=True)