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

Rename producer to service and consumer to client

Browse Source
This commit is contained in:
Luis-Hebendanz
2024-01-04 22:40:10 +01:00
parent 824edac9e9
commit 5fad1e678f
9 changed files with 140 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -9,16 +9,16 @@ from sqlalchemy.orm import Session
from ...errors import ClanError
from .. import sql_crud, sql_db, sql_models
from ..schemas import (
Consumer,
ConsumerCreate,
Client,
ClientCreate,
Entity,
EntityCreate,
Producer,
ProducerCreate,
Repository,
RepositoryCreate,
Resolution,
ResolutionCreate,
Service,
ServiceCreate,
)
from ..tags import Tags
@@ -29,92 +29,82 @@ log = logging.getLogger(__name__)
#########################
# #
# Producer #
# Service #
# #
#########################
@router.post("/api/v1/create_producer", response_model=Producer, tags=[Tags.producers])
def create_producer(
producer: ProducerCreate, db: Session = Depends(sql_db.get_db)
) -> Producer:
@router.post("/api/v1/create_service", response_model=Service, tags=[Tags.services])
def create_service(
service: ServiceCreate, db: Session = Depends(sql_db.get_db)
) -> Service:
# todo checken ob schon da ...
return sql_crud.create_producer(db=db, producer=producer)
return sql_crud.create_service(db=db, service=service)
@router.get(
"/api/v1/get_producers", response_model=List[Producer], tags=[Tags.producers]
)
def get_producers(
@router.get("/api/v1/get_services", response_model=List[Service], tags=[Tags.services])
def get_services(
skip: int = 0, limit: int = 100, db: Session = Depends(sql_db.get_db)
) -> List[sql_models.Producer]:
producers = sql_crud.get_producers(db, skip=skip, limit=limit)
return producers
) -> List[sql_models.Service]:
services = sql_crud.get_services(db, skip=skip, limit=limit)
return services
@router.get(
"/api/v1/get_producer", response_model=List[Producer], tags=[Tags.producers]
)
def get_producer(
@router.get("/api/v1/get_service", response_model=List[Service], tags=[Tags.services])
def get_service(
entity_did: str = "did:sov:test:1234",
skip: int = 0,
limit: int = 100,
db: Session = Depends(sql_db.get_db),
) -> List[sql_models.Producer]:
producer = sql_crud.get_producers_by_entity_did(db, entity_did=entity_did)
return producer
) -> List[sql_models.Service]:
service = sql_crud.get_services_by_entity_did(db, entity_did=entity_did)
return service
@router.delete("/api/v1/delete_producer", tags=[Tags.producers])
def delete_producer(
@router.delete("/api/v1/delete_service", tags=[Tags.services])
def delete_service(
entity_did: str = "did:sov:test:1234",
db: Session = Depends(sql_db.get_db),
) -> dict[str, str]:
sql_crud.delete_producer_by_entity_did(db, entity_did)
return {"message": "Producer deleted"}
sql_crud.delete_service_by_entity_did(db, entity_did)
return {"message": "service deleted"}
#########################
# #
# Consumer #
# Client #
# #
#########################
@router.post("/api/v1/create_consumer", response_model=Consumer, tags=[Tags.consumers])
def create_consumer(
consumer: ConsumerCreate, db: Session = Depends(sql_db.get_db)
) -> Consumer:
@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_consumer(db=db, consumer=consumer)
return sql_crud.create_client(db=db, client=client)
@router.get(
"/api/v1/get_consumers", response_model=List[Consumer], tags=[Tags.consumers]
)
def get_consumers(
@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.Consumer]:
consumers = sql_crud.get_consumers(db, skip=skip, limit=limit)
return consumers
) -> List[sql_models.Client]:
clients = sql_crud.get_clients(db, skip=skip, limit=limit)
return clients
@router.get(
"/api/v1/get_consumer", response_model=List[Consumer], tags=[Tags.consumers]
)
def get_consumer(
@router.get("/api/v1/get_client", response_model=List[Client], tags=[Tags.clients])
def get_client(
entity_did: str = "did:sov:test:1234",
skip: int = 0,
limit: int = 100,
db: Session = Depends(sql_db.get_db),
) -> List[sql_models.Consumer]:
consumer = sql_crud.get_consumers_by_entity_did(db, entity_did=entity_did)
return consumer
) -> List[sql_models.Client]:
client = sql_crud.get_client_by_entity_did(db, entity_did=entity_did)
return client
@router.delete("/api/v1/delete_consumer", tags=[Tags.consumers])
def delete_consumer(
@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_consumer_by_entity_did(db, entity_did)
return {"message": "Consumer deleted"}
sql_crud.delete_client_by_entity_did(db, entity_did)
return {"message": "client deleted"}
#########################

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

@@ -18,10 +18,10 @@ class Machine(BaseModel):
#########################
# #
# Producer #
# Service #
# #
#########################
class ProducerBase(BaseModel):
class ServiceBase(BaseModel):
uuid: str = "8e285c0c-4e40-430a-a477-26b3b81e30df"
service_name: str = "Carlo's Printing"
service_type: str = "3D Printing"
@@ -30,11 +30,11 @@ class ProducerBase(BaseModel):
other: dict = {"action": ["register", "deregister", "delete", "create"]}
class ProducerCreate(ProducerBase):
class ServiceCreate(ServiceBase):
entity_did: str = "did:sov:test:1234"
class Producer(ProducerCreate):
class Service(ServiceCreate):
class Config:
orm_mode = True
@@ -44,17 +44,17 @@ class Producer(ProducerCreate):
# Consumer #
# #
#########################
class ConsumerBase(BaseModel):
class ClientBase(BaseModel):
entity_did: str = "did:sov:test:1234"
producer_uuid: str = "8e285c0c-4e40-430a-a477-26b3b81e30df"
service_uuid: str = "8e285c0c-4e40-430a-a477-26b3b81e30df"
other: dict = {"test": "test"}
class ConsumerCreate(ConsumerBase):
class ClientCreate(ClientBase):
pass
class Consumer(ConsumerCreate):
class Client(ClientCreate):
id: int
class Config:
@@ -66,7 +66,7 @@ class Consumer(ConsumerCreate):
# REPOSITORY #
# #
#########################
class RepositoryBase(ProducerBase):
class RepositoryBase(ServiceBase):
pass
@@ -103,8 +103,8 @@ class EntityCreate(EntityBase):
class Entity(EntityCreate):
producers: List[Producer] = []
consumers: List[Consumer] = []
services: List[Service] = []
clients: List[Client] = []
repository: List[Repository] = []
class Config:

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

@@ -8,84 +8,80 @@ from . import schemas, sql_models
#########################
# #
# Producer #
# service #
# #
#########################
def create_producer(
db: Session, producer: schemas.ProducerCreate
) -> sql_models.Producer:
db_producer = sql_models.Producer(**producer.dict())
db.add(db_producer)
def create_service(db: Session, service: schemas.ServiceCreate) -> sql_models.Service:
db_service = sql_models.Service(**service.dict())
db.add(db_service)
db.commit()
db.refresh(db_producer)
return db_producer
db.refresh(db_service)
return db_service
def get_producers(
def get_services(
db: Session, skip: int = 0, limit: int = 100
) -> List[sql_models.Producer]:
return db.query(sql_models.Producer).offset(skip).limit(limit).all()
) -> List[sql_models.Service]:
return db.query(sql_models.Service).offset(skip).limit(limit).all()
def get_producers_by_entity_did(
def get_services_by_entity_did(
db: Session, entity_did: str, skip: int = 0, limit: int = 100
) -> List[sql_models.Producer]:
) -> List[sql_models.Service]:
return (
db.query(sql_models.Producer)
.filter(sql_models.Producer.entity_did == entity_did)
db.query(sql_models.Service)
.filter(sql_models.Service.entity_did == entity_did)
.offset(skip)
.limit(limit)
.all()
)
def delete_producer_by_entity_did(db: Session, entity_did: str) -> None:
db.query(sql_models.Producer).filter(
sql_models.Producer.entity_did == entity_did
def delete_service_by_entity_did(db: Session, entity_did: str) -> None:
db.query(sql_models.Service).filter(
sql_models.Service.entity_did == entity_did
).delete()
db.commit()
#########################
# #
# Consumer #
# client #
# #
#########################
def create_consumer(
db: Session, consumer: schemas.ConsumerCreate
) -> sql_models.Consumer:
db_consumer = sql_models.Consumer(**consumer.dict())
db.add(db_consumer)
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_consumer)
return db_consumer
db.refresh(db_client)
return db_client
def get_consumers(
def get_clients(
db: Session, skip: int = 0, limit: int = 100
) -> List[sql_models.Consumer]:
return db.query(sql_models.Consumer).offset(skip).limit(limit).all()
) -> List[sql_models.Client]:
return db.query(sql_models.Client).offset(skip).limit(limit).all()
def get_consumers_by_entity_did(
def get_client_by_entity_did(
db: Session, entity_did: str, skip: int = 0, limit: int = 100
) -> List[sql_models.Consumer]:
) -> List[sql_models.Client]:
return (
db.query(sql_models.Consumer)
.filter(sql_models.Consumer.entity_did == entity_did)
db.query(sql_models.Client)
.filter(sql_models.Client.entity_did == entity_did)
.offset(skip)
.limit(limit)
.all()
)
def delete_consumer_by_entity_did(db: Session, entity_did: str) -> None:
db.query(sql_models.Consumer).filter(
sql_models.Consumer.entity_did == entity_did
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()
@@ -198,8 +194,8 @@ def delete_entity_by_did(db: Session, did: str) -> None:
def delete_entity_by_did_recursive(db: Session, did: str) -> None:
delete_producer_by_entity_did(db, did)
delete_consumer_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)

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

@@ -33,13 +33,13 @@ class Entity(Base):
other = Column(JSON)
## Relations ##
producers = relationship("Producer", back_populates="entity")
consumers = relationship("Consumer", 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 ProducerAbstract(Base):
class ServiceAbstract(Base):
__abstract__ = True
# Queryable body
@@ -54,22 +54,22 @@ class ProducerAbstract(Base):
other = Column(JSON)
class Producer(ProducerAbstract):
__tablename__ = "producers"
class Service(ServiceAbstract):
__tablename__ = "services"
# Usage is the consumers column
# Usage is the clients column
## Relations ##
# One entity can have many producers
entity = relationship("Entity", back_populates="producers")
# One entity can have many services
entity = relationship("Entity", back_populates="services")
entity_did = Column(String, ForeignKey("entities.did"))
# One producer has many consumers
consumers = relationship("Consumer", back_populates="producer")
# One service has many clients
clients = relationship("Client", back_populates="service")
class Consumer(Base):
__tablename__ = "consumers"
class Client(Base):
__tablename__ = "clients"
## Queryable body ##
id = Column(Integer, primary_key=True, index=True)
@@ -78,18 +78,18 @@ class Consumer(Base):
other = Column(JSON)
## Relations ##
# one entity can have many consumers
entity = relationship("Entity", back_populates="consumers")
# one entity can have many clients
entity = relationship("Entity", back_populates="clients")
entity_did = Column(String, ForeignKey("entities.did"))
# one consumer has one producer
producer = relationship("Producer", back_populates="consumers")
producer_uuid = Column(String, ForeignKey("producers.uuid"))
# one client has one service
service = relationship("Service", back_populates="clients")
service_uuid = Column(String, ForeignKey("services.uuid"))
__table_args__ = (UniqueConstraint("producer_uuid", "entity_did"),)
__table_args__ = (UniqueConstraint("service_uuid", "entity_did"),)
class Repository(ProducerAbstract):
class Repository(ServiceAbstract):
__tablename__ = "repositories"
time_created = Column(DateTime(timezone=True), server_default=func.now())

12
pkgs/clan-cli/clan_cli/webui/tags.py
View File

@@ -3,8 +3,8 @@ from typing import Any, Dict, List
class Tags(Enum):
producers = "producers"
consumers = "consumers"
services = "services"
clients = "clients"
entities = "entities"
repositories = "repositories"
resolutions = "resolution"
@@ -15,12 +15,12 @@ class Tags(Enum):
tags_metadata: List[Dict[str, Any]] = [
{
"name": str(Tags.producers),
"description": "Operations on a producer.",
"name": str(Tags.services),
"description": "Operations on a service.",
},
{
"name": str(Tags.consumers),
"description": "Operations on a consumer.",
"name": str(Tags.clients),
"description": "Operations on a client.",
},
{
"name": str(Tags.entities),