pkgs/clan-cli/clan_cli/webui/routers/sql_connect.py

@@ -1,5 +1,6 @@
 import logging
 import time
+from datetime import datetime
 from typing import List, Optional
 
 import httpx
@@ -9,14 +10,9 @@ from sqlalchemy.orm import Session
 from ...errors import ClanError
 from .. import sql_crud, sql_db, sql_models
 from ..schemas import (
-    Client,
-    ClientCreate,
     Entity,
     EntityCreate,
-    Repository,
-    RepositoryCreate,
     Resolution,
-    ResolutionCreate,
     Service,
     ServiceCreate,
 )
@@ -32,7 +28,7 @@ log = logging.getLogger(__name__)
 #        Service        #
 #                       #
 #########################
-@router.post("/api/v1/create_service", response_model=Service, tags=[Tags.services])
+@router.post("/api/v1/service", response_model=Service, tags=[Tags.services])
 def create_service(
     service: ServiceCreate, db: Session = Depends(sql_db.get_db)
 ) -> Service:
@@ -40,16 +36,18 @@ def create_service(
     return sql_crud.create_service(db=db, service=service)
 
 
-@router.get("/api/v1/get_services", response_model=List[Service], tags=[Tags.services])
-def get_services(
+@router.get("/api/v1/services", response_model=List[Service], tags=[Tags.services])
+def get_all_services(
     skip: int = 0, limit: int = 100, db: Session = Depends(sql_db.get_db)
 ) -> List[sql_models.Service]:
     services = sql_crud.get_services(db, skip=skip, limit=limit)
     return services
 
 
-@router.get("/api/v1/get_service", response_model=List[Service], tags=[Tags.services])
-def get_service(
+@router.get(
+    "/api/v1/{entity_did}/service", response_model=List[Service], tags=[Tags.services]
+)
+def get_service_by_did(
     entity_did: str = "did:sov:test:1234",
     skip: int = 0,
     limit: int = 100,
@@ -59,7 +57,7 @@ def get_service(
     return service
 
 
-@router.delete("/api/v1/delete_service", tags=[Tags.services])
+@router.delete("/api/v1/{entity_did}/service", tags=[Tags.services])
 def delete_service(
     entity_did: str = "did:sov:test:1234",
     db: Session = Depends(sql_db.get_db),
@@ -73,38 +71,19 @@ def delete_service(
 #         Client        #
 #                       #
 #########################
-@router.post("/api/v1/create_client", response_model=Client, tags=[Tags.clients])
-def create_client(client: ClientCreate, db: Session = Depends(sql_db.get_db)) -> Client:
-    # todo checken ob schon da ...
-    return sql_crud.create_client(db=db, client=client)
-
-
-@router.get("/api/v1/get_clients", response_model=List[Client], tags=[Tags.clients])
-def get_clients(
-    skip: int = 0, limit: int = 100, db: Session = Depends(sql_db.get_db)
-) -> List[sql_models.Client]:
-    clients = sql_crud.get_clients(db, skip=skip, limit=limit)
-    return clients
-
-
-@router.get("/api/v1/get_client", response_model=List[Client], tags=[Tags.clients])
-def get_client(
+@router.get(
+    "/api/v1/{entity_did}/clients", response_model=List[Service], tags=[Tags.clients]
+)
+def get_all_clients(
     entity_did: str = "did:sov:test:1234",
     skip: int = 0,
     limit: int = 100,
     db: Session = Depends(sql_db.get_db),
-) -> List[sql_models.Client]:
-    client = sql_crud.get_client_by_entity_did(db, entity_did=entity_did)
-    return client
-
-
-@router.delete("/api/v1/delete_client", tags=[Tags.clients])
-def delete_client(
-    entity_did: str = "did:sov:test:1234",
-    db: Session = Depends(sql_db.get_db),
-) -> dict[str, str]:
-    sql_crud.delete_client_by_entity_did(db, entity_did)
-    return {"message": "client deleted"}
+) -> List[sql_models.Service]:
+    clients = sql_crud.get_services_without_entity_id(
+        db, entity_did, skip=skip, limit=limit
+    )
+    return clients
 
 
 #########################
@@ -112,72 +91,44 @@ def delete_client(
 #       REPOSITORY      #
 #                       #
 #########################
-@router.post(
-    "/api/v1/create_repository", response_model=Repository, tags=[Tags.repositories]
-)
-def create_repository(
-    repository: RepositoryCreate, db: Session = Depends(sql_db.get_db)
-) -> sql_models.Repository:
-    # todo checken ob schon da ...
-    return sql_crud.create_repository(db=db, repository=repository)
 
 
 @router.get(
-    "/api/v1/get_repositories",
-    response_model=List[Repository],
+    "/api/v1/repositories",
+    response_model=List[Service],
     tags=[Tags.repositories],
 )
-def get_repositories(
+def get_all_repositories(
     skip: int = 0, limit: int = 100, db: Session = Depends(sql_db.get_db)
-) -> List[sql_models.Repository]:
-    repositories = sql_crud.get_repositories(db, skip=skip, limit=limit)
+) -> List[sql_models.Service]:
+    repositories = sql_crud.get_services(db, skip=skip, limit=limit)
     return repositories
 
 
-@router.get(
-    "/api/v1/get_repository", response_model=List[Repository], tags=[Tags.repositories]
-)
-def get_repository(
-    entity_did: str = "did:sov:test:1234",
-    skip: int = 0,
-    limit: int = 100,
-    db: Session = Depends(sql_db.get_db),
-) -> List[sql_models.Repository]:
-    repository = sql_crud.get_repository_by_entity_did(db, did=entity_did)
-    return repository
-
-
-@router.delete("/api/v1/delete_repository", tags=[Tags.repositories])
-def delete_repository(
-    entity_did: str = "did:sov:test:1234",
-    db: Session = Depends(sql_db.get_db),
-) -> dict[str, str]:
-    sql_crud.delete_repository_by_entity_did(db, did=entity_did)
-    return {"message": "Repository deleted"}
-
-
 #########################
 #                       #
 #        Entity         #
 #                       #
 #########################
-@router.post("/api/v1/create_entity", response_model=Entity, tags=[Tags.entities])
+@router.post("/api/v1/entity", response_model=Entity, tags=[Tags.entities])
 def create_entity(
     entity: EntityCreate, db: Session = Depends(sql_db.get_db)
 ) -> EntityCreate:
     return sql_crud.create_entity(db, entity)
 
 
-@router.get("/api/v1/get_entities", response_model=List[Entity], tags=[Tags.entities])
-def get_entities(
+@router.get("/api/v1/entities", response_model=List[Entity], tags=[Tags.entities])
+def get_all_entities(
     skip: int = 0, limit: int = 100, db: Session = Depends(sql_db.get_db)
 ) -> List[sql_models.Entity]:
     entities = sql_crud.get_entities(db, skip=skip, limit=limit)
     return entities
 
 
-@router.get("/api/v1/get_entity", response_model=Optional[Entity], tags=[Tags.entities])
-def get_entity(
+@router.get(
+    "/api/v1/{entity_did}/entity", response_model=Optional[Entity], tags=[Tags.entities]
+)
+def get_entity_by_did(
     entity_did: str = "did:sov:test:1234",
     db: Session = Depends(sql_db.get_db),
 ) -> Optional[sql_models.Entity]:
@@ -186,7 +137,7 @@ def get_entity(
 
 
 @router.get(
-    "/api/v1/get_attached_entities",
+    "/api/v1/attached_entities",
     response_model=List[Entity],
     tags=[Tags.entities],
 )
@@ -197,8 +148,8 @@ def get_attached_entities(
     return entities
 
 
-@router.post("/api/v1/detach", response_model=Entity, tags=[Tags.entities])
-async def detach(
+@router.post("/api/v1/{entity_did}/detach", response_model=Entity, tags=[Tags.entities])
+async def detach_entity(
     background_tasks: BackgroundTasks,
     entity_did: str = "did:sov:test:1234",
     skip: int = 0,
@@ -209,8 +160,8 @@ async def detach(
     return entity
 
 
-@router.post("/api/v1/attach", tags=[Tags.entities])
-async def attach(
+@router.post("/api/v1/{entity_did}/attach", tags=[Tags.entities])
+async def attach_entity(
     background_tasks: BackgroundTasks,
     entity_did: str = "did:sov:test:1234",
     skip: int = 0,
@@ -220,11 +171,11 @@ async def attach(
     if sql_crud.get_entity_by_did(db, entity_did) is None:
         raise ClanError(f"Entity with did '{entity_did}' not found")
 
-    background_tasks.add_task(attach_entity, db, entity_did)
+    background_tasks.add_task(attach_entity_loc, db, entity_did)
     return {"message": "Attaching in the background"}
 
 
-def attach_entity(db: Session, entity_did: str) -> None:
+def attach_entity_loc(db: Session, entity_did: str) -> None:
     db_entity = sql_crud.set_attached_by_entity_did(db, entity_did, True)
     try:
         while db_entity.attached:
@@ -244,7 +195,7 @@ def attach_entity(db: Session, entity_did: str) -> None:
         db_entity = sql_crud.set_attached_by_entity_did(db, entity_did, False)
 
 
-@router.delete("/api/v1/delete_entity_recursive", tags=[Tags.entities])
+@router.delete("/api/v1/{entity_did}/entity", tags=[Tags.entities])
 def delete_entity(
     entity_did: str = "did:sov:test:1234",
     db: Session = Depends(sql_db.get_db),
@@ -258,45 +209,23 @@ def delete_entity(
 #      Resolution       #
 #                       #
 #########################
-@router.post(
-    "/api/v1/create_resolution", response_model=Resolution, tags=[Tags.resolutions]
-)
-def create_resolution(
-    resolution: ResolutionCreate,
-    db: Session = Depends(sql_db.get_db),
-) -> sql_models.Resolution:
-    return sql_crud.create_resolution(db, resolution)
 
 
 @router.get(
-    "/api/v1/get_resolutions", response_model=List[Resolution], tags=[Tags.resolutions]
+    "/api/v1/resolutions", response_model=List[Resolution], tags=[Tags.resolutions]
 )
-def get_resolutions(
+def get_all_resolutions(
     skip: int = 0, limit: int = 100, db: Session = Depends(sql_db.get_db)
-) -> List[sql_models.Resolution]:
-    resolutions = sql_crud.get_resolutions(db, skip=skip, limit=limit)
-    return resolutions
+) -> List[Resolution]:
+    # TODO: Get resolutions from DLG entity
 
-
-@router.get(
-    "/api/v1/get_resolution", response_model=List[Resolution], tags=[Tags.resolutions]
-)
-def get_resolution(
-    requester_did: str = "did:sov:test:1122",
-    skip: int = 0,
-    limit: int = 100,
-    db: Session = Depends(sql_db.get_db),
-) -> List[sql_models.Resolution]:
-    resolution = sql_crud.get_resolution_by_requester_did(
-        db, requester_did=requester_did
-    )
-    return resolution
-
-
-@router.delete("/api/v1/delete_resolution", tags=[Tags.resolutions])
-def delete_resolution(
-    requester_did: str = "did:sov:test:1122",
-    db: Session = Depends(sql_db.get_db),
-) -> dict[str, str]:
-    sql_crud.delete_resolution_by_requester_did(db, requester_did=requester_did)
-    return {"message": "Resolution deleted"}
+    return [
+        Resolution(
+            requester_name="C1",
+            requester_did="did:sov:test:1122",
+            resolved_did="did:sov:test:1234",
+            other={"test": "test"},
+            timestamp=datetime.now(),
+            id=1,
+        )
+    ]

pkgs/clan-cli/clan_cli/webui/schemas.py

@@ -1,6 +1,5 @@
 from datetime import datetime
 from enum import Enum
-from typing import List
 
 from pydantic import BaseModel
 
@@ -39,48 +38,6 @@ class Service(ServiceCreate):
         orm_mode = True
 
 
-#########################
-#                       #
-#       Consumer        #
-#                       #
-#########################
-class ClientBase(BaseModel):
-    entity_did: str = "did:sov:test:1234"
-    service_uuid: str = "8e285c0c-4e40-430a-a477-26b3b81e30df"
-    other: dict = {"test": "test"}
-
-
-class ClientCreate(ClientBase):
-    pass
-
-
-class Client(ClientCreate):
-    id: int
-
-    class Config:
-        orm_mode = True
-
-
-#########################
-#                       #
-#       REPOSITORY      #
-#                       #
-#########################
-class RepositoryBase(ServiceBase):
-    pass
-
-
-class RepositoryCreate(RepositoryBase):
-    entity_did: str = "did:sov:test:1234"
-
-
-class Repository(RepositoryCreate):
-    time_created: datetime
-
-    class Config:
-        orm_mode = True
-
-
 #########################
 #                       #
 #        Entity         #
@@ -90,7 +47,6 @@ class EntityBase(BaseModel):
     did: str = "did:sov:test:1234"
     name: str = "C1"
     ip: str = "127.0.0.1"
-    attached: bool = False
     visible: bool = True
     other: dict = {
         "network": "Carlo's Home Network",
@@ -103,9 +59,7 @@ class EntityCreate(EntityBase):
 
 
 class Entity(EntityCreate):
-    services: List[Service] = []
-    clients: List[Client] = []
-    repository: List[Repository] = []
+    attached: bool
 
     class Config:
         orm_mode = True
@@ -116,8 +70,6 @@ class Entity(EntityCreate):
 #      Resolution       #
 #                       #
 #########################
-
-
 class ResolutionBase(BaseModel):
     requester_name: str = "C1"
     requester_did: str = "did:sov:test:1122"

pkgs/clan-cli/clan_cli/webui/sql_crud.py

@@ -8,7 +8,7 @@ from . import schemas, sql_models
 
 #########################
 #                       #
-#       service        #
+#       service         #
 #                       #
 #########################
 
@@ -46,101 +46,25 @@ def delete_service_by_entity_did(db: Session, entity_did: str) -> None:
     db.commit()
 
 
-#########################
-#                       #
-#       client        #
-#                       #
-#########################
-
-
-def create_client(db: Session, client: schemas.ClientCreate) -> sql_models.Client:
-    db_client = sql_models.Client(**client.dict())
-    db.add(db_client)
-    db.commit()
-    db.refresh(db_client)
-    return db_client
-
-
-def get_clients(
-    db: Session, skip: int = 0, limit: int = 100
-) -> List[sql_models.Client]:
-    return db.query(sql_models.Client).offset(skip).limit(limit).all()
-
-
-def get_client_by_entity_did(
+def get_services_without_entity_id(
     db: Session, entity_did: str, skip: int = 0, limit: int = 100
-) -> List[sql_models.Client]:
+) -> List[sql_models.Service]:
     return (
-        db.query(sql_models.Client)
-        .filter(sql_models.Client.entity_did == entity_did)
+        db.query(sql_models.Service)
+        .filter(sql_models.Service.entity_did != entity_did)
         .offset(skip)
         .limit(limit)
         .all()
     )
 
 
-def delete_client_by_entity_did(db: Session, entity_did: str) -> None:
-    db.query(sql_models.Client).filter(
-        sql_models.Client.entity_did == entity_did
-    ).delete()
-    db.commit()
-
-
-#########################
-#                       #
-#       REPOSITORY      #
-#                       #
-#########################
-def create_repository(
-    db: Session, repository: schemas.RepositoryCreate
-) -> sql_models.Repository:
-    db_repository = sql_models.Repository(**repository.dict())
-    db.add(db_repository)
-    db.commit()
-    db.refresh(db_repository)
-    return db_repository
-
-
-def get_repositories(
-    db: Session, skip: int = 0, limit: int = 100
-) -> List[sql_models.Repository]:
-    return db.query(sql_models.Repository).offset(skip).limit(limit).all()
-
-
-def get_repository_by_uuid(db: Session, uuid: str) -> Optional[sql_models.Repository]:
-    return (
-        db.query(sql_models.Repository)
-        .filter(sql_models.Repository.uuid == uuid)
-        .first()
-    )
-
-
-def get_repository_by_entity_did(
-    db: Session, did: str, skip: int = 0, limit: int = 100
-) -> List[sql_models.Repository]:
-    return (
-        db.query(sql_models.Repository)
-        .filter(sql_models.Repository.entity_did == did)
-        .offset(skip)
-        .limit(limit)
-        .all()
-    )
-
-
-def delete_repository_by_entity_did(db: Session, did: str) -> None:
-    db.query(sql_models.Repository).filter(
-        sql_models.Repository.entity_did == did
-    ).delete()
-    db.commit()
-
-
 #########################
 #                       #
 #        Entity         #
 #                       #
 #########################
 def create_entity(db: Session, entity: schemas.EntityCreate) -> sql_models.Entity:
-    db_entity = sql_models.Entity(**entity.dict())
+    db_entity = sql_models.Entity(**entity.dict(), attached=False)
     db.add(db_entity)
     db.commit()
     db.refresh(db_entity)
@@ -195,46 +119,4 @@ def delete_entity_by_did(db: Session, did: str) -> None:
 
 def delete_entity_by_did_recursive(db: Session, did: str) -> None:
     delete_service_by_entity_did(db, did)
-    delete_client_by_entity_did(db, did)
-    delete_repository_by_entity_did(db, did)
     delete_entity_by_did(db, did)
-
-
-#########################
-#                       #
-#      Resolution       #
-#                       #
-#########################
-def create_resolution(
-    db: Session, resolution: schemas.ResolutionCreate
-) -> sql_models.Resolution:
-    db_resolution = sql_models.Resolution(**resolution.dict())
-    db.add(db_resolution)
-    db.commit()
-    db.refresh(db_resolution)
-    return db_resolution
-
-
-def get_resolutions(
-    db: Session, skip: int = 0, limit: int = 100
-) -> List[sql_models.Resolution]:
-    return db.query(sql_models.Resolution).offset(skip).limit(limit).all()
-
-
-def get_resolution_by_requester_did(
-    db: Session, requester_did: str, skip: int = 0, limit: int = 100
-) -> List[sql_models.Resolution]:
-    return (
-        db.query(sql_models.Resolution)
-        .filter(sql_models.Resolution.requester_did == requester_did)
-        .offset(skip)
-        .limit(limit)
-        .all()
-    )
-
-
-def delete_resolution_by_requester_did(db: Session, requester_did: str) -> None:
-    db.query(sql_models.Resolution).filter(
-        sql_models.Resolution.requester_did == requester_did
-    ).delete()
-    db.commit()

pkgs/clan-cli/clan_cli/webui/sql_models.py

@@ -2,15 +2,11 @@ from sqlalchemy import (
     JSON,
     Boolean,
     Column,
-    DateTime,
     ForeignKey,
-    Integer,
     String,
     Text,
-    UniqueConstraint,
 )
 from sqlalchemy.orm import relationship
-from sqlalchemy.sql import func
 
 from .sql_db import Base
 
@@ -34,9 +30,6 @@ class Entity(Base):
 
     ## Relations ##
     services = relationship("Service", back_populates="entity")
-    clients = relationship("Client", back_populates="entity")
-    repository = relationship("Repository", back_populates="entity")
-    # TODO maby refactor to repositories
 
 
 class ServiceAbstract(Base):
@@ -57,55 +50,7 @@ class ServiceAbstract(Base):
 class Service(ServiceAbstract):
     __tablename__ = "services"
 
-    # Usage is the clients column
-
     ## Relations ##
     # One entity can have many services
     entity = relationship("Entity", back_populates="services")
     entity_did = Column(String, ForeignKey("entities.did"))
-
-    # One service has many clients
-    clients = relationship("Client", back_populates="service")
-
-
-class Client(Base):
-    __tablename__ = "clients"
-
-    ## Queryable body ##
-    id = Column(Integer, primary_key=True, index=True)
-
-    ## Non queryable body ##
-    other = Column(JSON)
-
-    ## Relations ##
-    # one entity can have many clients
-    entity = relationship("Entity", back_populates="clients")
-    entity_did = Column(String, ForeignKey("entities.did"))
-
-    # one client has one service
-    service = relationship("Service", back_populates="clients")
-    service_uuid = Column(String, ForeignKey("services.uuid"))
-
-    __table_args__ = (UniqueConstraint("service_uuid", "entity_did"),)
-
-
-class Repository(ServiceAbstract):
-    __tablename__ = "repositories"
-
-    time_created = Column(DateTime(timezone=True), server_default=func.now())
-
-    # one repository has one entity
-    entity = relationship("Entity", back_populates="repository")
-    entity_did = Column(Integer, ForeignKey("entities.did"))
-
-
-# TODO: Ask how this works exactly
-class Resolution(Base):
-    __tablename__ = "resolutions"
-
-    id = Column(Integer, primary_key=True)
-    requester_name = Column(String, index=True)
-    requester_did = Column(String, index=True)
-    resolved_did = Column(String, index=True)
-    other = Column(JSON)
-    timestamp = Column(DateTime(timezone=True), server_default=func.now())