IoSL/service-aware-frontend
3
0
Fork 0
generated from Luis/nextjs-python-web-template
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactored api calls to REST. Clients endpoint is now services without self. repository view is the same as get all services.

Browse Source
This commit is contained in:
Luis-Hebendanz
2024-01-04 23:27:35 +01:00
parent 5fad1e678f
commit 68b7171852
4 changed files with 59 additions and 351 deletions
Download Patch File Download Diff File Expand all files Collapse all files

173
pkgs/clan-cli/clan_cli/webui/routers/sql_connect.py
View File

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

50
pkgs/clan-cli/clan_cli/webui/schemas.py
View File

@@ -1,6 +1,5 @@
from datetime import datetime from datetime import datetime
from enum import Enum from enum import Enum
from typing import List
from pydantic import BaseModel from pydantic import BaseModel
@@ -39,48 +38,6 @@ class Service(ServiceCreate):
orm_mode = True 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 # # Entity #
@@ -90,7 +47,6 @@ class EntityBase(BaseModel):
did: str = "did:sov:test:1234" did: str = "did:sov:test:1234"
name: str = "C1" name: str = "C1"
ip: str = "127.0.0.1" ip: str = "127.0.0.1"
attached: bool = False
visible: bool = True visible: bool = True
other: dict = { other: dict = {
"network": "Carlo's Home Network", "network": "Carlo's Home Network",
@@ -103,9 +59,7 @@ class EntityCreate(EntityBase):
class Entity(EntityCreate): class Entity(EntityCreate):
services: List[Service] = [] attached: bool
clients: List[Client] = []
repository: List[Repository] = []
class Config: class Config:
orm_mode = True orm_mode = True
@@ -116,8 +70,6 @@ class Entity(EntityCreate):
# Resolution # # Resolution #
# # # #
######################### #########################
class ResolutionBase(BaseModel): class ResolutionBase(BaseModel):
requester_name: str = "C1" requester_name: str = "C1"
requester_did: str = "did:sov:test:1122" requester_did: str = "did:sov:test:1122"

128
pkgs/clan-cli/clan_cli/webui/sql_crud.py
View File

@@ -46,101 +46,25 @@ def delete_service_by_entity_did(db: Session, entity_did: str) -> None:
db.commit() db.commit()
######################### def get_services_without_entity_id(
# #
# 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(
db: Session, entity_did: str, skip: int = 0, limit: int = 100 db: Session, entity_did: str, skip: int = 0, limit: int = 100
) -> List[sql_models.Client]: ) -> List[sql_models.Service]:
return ( return (
db.query(sql_models.Client) db.query(sql_models.Service)
.filter(sql_models.Client.entity_did == entity_did) .filter(sql_models.Service.entity_did != entity_did)
.offset(skip) .offset(skip)
.limit(limit) .limit(limit)
.all() .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 # # Entity #
# # # #
######################### #########################
def create_entity(db: Session, entity: schemas.EntityCreate) -> sql_models.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.add(db_entity)
db.commit() db.commit()
db.refresh(db_entity) 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: def delete_entity_by_did_recursive(db: Session, did: str) -> None:
delete_service_by_entity_did(db, did) 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) 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()

55
pkgs/clan-cli/clan_cli/webui/sql_models.py
View File

@@ -2,15 +2,11 @@ from sqlalchemy import (
JSON, JSON,
Boolean, Boolean,
Column, Column,
DateTime,
ForeignKey, ForeignKey,
Integer,
String, String,
Text, Text,
UniqueConstraint,
) )
from sqlalchemy.orm import relationship from sqlalchemy.orm import relationship
from sqlalchemy.sql import func
from .sql_db import Base from .sql_db import Base
@@ -34,9 +30,6 @@ class Entity(Base):
## Relations ## ## Relations ##
services = relationship("Service", back_populates="entity") 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): class ServiceAbstract(Base):
@@ -57,55 +50,7 @@ class ServiceAbstract(Base):
class Service(ServiceAbstract): class Service(ServiceAbstract):
__tablename__ = "services" __tablename__ = "services"
# Usage is the clients column
## Relations ## ## Relations ##
# One entity can have many services # One entity can have many services
entity = relationship("Entity", back_populates="services") entity = relationship("Entity", back_populates="services")
entity_did = Column(String, ForeignKey("entities.did")) 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())