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

Merge branch 'main' into mermaid

Browse Source
This commit is contained in:
sara-pervana
2024-01-16 20:31:41 +01:00
parent c179ac2424 957f99a906
commit 140393e93d
48 changed files with 2183 additions and 771 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
formatter.nix
View File

@@ -18,6 +18,8 @@
treefmt.settings.formatter.prettier.excludes = [
"secrets.yaml"
"key.json"
"keyfile.json"
"**/pkgs/clan-cli/tests/openapi_client/**"
];
treefmt.programs.mypy.enable = true;

8
pkgs/clan-cli/clan_cli/config.py
View File

@@ -1,8 +1,10 @@
host = "127.0.0.1"
port_dlg = 7000
port_ap = 7500
port_client_base = 8000
_port_client_base = 8000
c1_port = _port_client_base + 1
c2_port = _port_client_base + 2
dlg_url = f"http://{host}:{port_dlg}/docs"
ap_url = f"http://{host}:{port_ap}/docs"
c1_url = f"http://{host}:{port_client_base}/docs"
c2_url = f"http://{host}:{port_client_base + 1}/docs"
c1_url = f"http://{host}:{c1_port}/docs"
c2_url = f"http://{host}:{c2_port}/docs"

28
pkgs/clan-cli/clan_cli/emulate_fastapi.py
View File

@@ -17,8 +17,8 @@ app_c2 = FastAPI(swagger_ui_parameters={"tryItOutEnabled": True})
apps = [
(app_dlg, config.port_dlg),
(app_ap, config.port_ap),
(app_c1, config.port_client_base),
(app_c2, config.port_client_base + 1),
(app_c1, config.c1_port),
(app_c2, config.c2_port),
]
@@ -79,7 +79,7 @@ def get_health(*, url: str, max_retries: int = 20, delay: float = 0.2) -> str |
# TODO send_msg???
@app_c1.get("/consume_service_from_other_entity", response_class=HTMLResponse)
@app_c1.get("/v1/print_daemon1", response_class=HTMLResponse)
async def consume_service_from_other_entity_c1() -> HTMLResponse:
html_content = """
<html>
@@ -92,7 +92,17 @@ async def consume_service_from_other_entity_c1() -> HTMLResponse:
return HTMLResponse(content=html_content, status_code=200)
@app_c2.get("/consume_service_from_other_entity", response_class=HTMLResponse)
@app_c1.get("/v1/print_daemon1/register", response_class=JSONResponse)
async def register_c1() -> JSONResponse:
return JSONResponse(content={"status": "registered"}, status_code=200)
@app_c1.get("/v1/print_daemon1/deregister", response_class=JSONResponse)
async def deregister_c1() -> JSONResponse:
return JSONResponse(content={"status": "deregistered"}, status_code=200)
@app_c2.get("/v1/print_daemon2", response_class=HTMLResponse)
async def consume_service_from_other_entity_c2() -> HTMLResponse:
html_content = """
<html>
@@ -105,6 +115,16 @@ async def consume_service_from_other_entity_c2() -> HTMLResponse:
return HTMLResponse(content=html_content, status_code=200)
@app_c2.get("/v1/print_daemon1/register", response_class=JSONResponse)
async def register_c2() -> JSONResponse:
return JSONResponse(content={"status": "registered"}, status_code=200)
@app_c2.get("/v1/print_daemon1/deregister", response_class=JSONResponse)
async def deregister_c2() -> JSONResponse:
return JSONResponse(content={"status": "deregistered"}, status_code=200)
@app_ap.get("/ap_list_of_services", response_class=JSONResponse)
async def ap_list_of_services() -> JSONResponse:
res = [

13
pkgs/clan-cli/clan_cli/webui/db_types.py Normal file
View File

@@ -0,0 +1,13 @@
from enum import Enum
class Status(Enum):
ONLINE = "online"
OFFLINE = "offline"
UNKNOWN = "unknown"
class Role(Enum):
PROSUMER = "service_prosumer"
AP = "AP"
DLG = "DLG"

81
pkgs/clan-cli/clan_cli/webui/routers/endpoints.py
View File

@@ -1,6 +1,6 @@
import logging
import time
from typing import Any, List, Optional
from typing import Any, List
import httpx
from fastapi import APIRouter, BackgroundTasks, Depends, Query
@@ -18,6 +18,7 @@ from ..schemas import (
Role,
Service,
ServiceCreate,
ServiceUsageCreate,
)
from ..tags import Tags
@@ -35,8 +36,39 @@ log = logging.getLogger(__name__)
def create_service(
service: ServiceCreate, db: Session = Depends(sql_db.get_db)
) -> Service:
# todo checken ob schon da ...
return sql_crud.create_service(db=db, service=service)
services = sql_crud.create_service(db=db, service=service)
return services
@router.post("/api/v1/service_usage", response_model=Service, tags=[Tags.services])
def add_service_usage(
usage: ServiceUsageCreate,
service_uuid: str = "bdd640fb-0667-1ad1-1c80-317fa3b1799d",
db: Session = Depends(sql_db.get_db),
) -> Service:
service = sql_crud.add_service_usage(db, service_uuid, usage)
return service
@router.put("/api/v1/inc_service_usage", response_model=Service, tags=[Tags.services])
def inc_service_usage(
usage: ServiceUsageCreate,
consumer_entity_did: str = "did:sov:test:120",
service_uuid: str = "bdd640fb-0667-1ad1-1c80-317fa3b1799d",
db: Session = Depends(sql_db.get_db),
) -> Service:
service = sql_crud.increment_service_usage(db, service_uuid, consumer_entity_did)
return service
@router.put("/api/v1/service", response_model=Service, tags=[Tags.services])
def update_service(
service: ServiceCreate,
uuid: str = "bdd640fb-0667-1ad1-1c80-317fa3b1799d",
db: Session = Depends(sql_db.get_db),
) -> Service:
service = sql_crud.set_service(db, uuid, service)
return service
@router.get("/api/v1/services", response_model=List[Service], tags=[Tags.services])
@@ -47,7 +79,9 @@ def get_all_services(
return services
@router.get("/api/v1/service", response_model=List[Service], tags=[Tags.services])
@router.get(
"/api/v1/service_by_did", response_model=List[Service], tags=[Tags.services]
)
def get_service_by_did(
entity_did: str = "did:sov:test:120",
skip: int = 0,
@@ -58,6 +92,19 @@ def get_service_by_did(
return service
@router.get("/api/v1/service", response_model=Service, tags=[Tags.services])
def get_service_by_uuid(
uuid: str = "bdd640fb-0667-1ad1-1c80-317fa3b1799d",
skip: int = 0,
limit: int = 100,
db: Session = Depends(sql_db.get_db),
) -> sql_models.Service:
service = sql_crud.get_service_by_uuid(db, uuid=uuid)
if service is None:
raise ClanError(f"Service with uuid '{uuid}' not found")
return service
@router.get(
"/api/v1/services_without_entity",
response_model=List[Service],
@@ -94,18 +141,6 @@ def create_entity(
return sql_crud.create_entity(db, entity)
@router.get(
"/api/v1/entity_by_name_or_did",
response_model=Optional[Entity],
tags=[Tags.entities],
)
def get_entity_by_name_or_did(
entity_name_or_did: str = "C1", db: Session = Depends(sql_db.get_db)
) -> Optional[sql_models.Entity]:
entity = sql_crud.get_entity_by_name_or_did(db, name=entity_name_or_did)
return entity
@router.get(
"/api/v1/entity_by_roles", response_model=List[Entity], tags=[Tags.entities]
)
@@ -124,12 +159,14 @@ def get_all_entities(
return entities
@router.get("/api/v1/entity", response_model=Optional[Entity], tags=[Tags.entities])
@router.get("/api/v1/entity", response_model=Entity, tags=[Tags.entities])
def get_entity_by_did(
entity_did: str = "did:sov:test:120",
db: Session = Depends(sql_db.get_db),
) -> Optional[sql_models.Entity]:
entity = sql_crud.get_entity_by_did(db, did=entity_did)
) -> sql_models.Entity:
entity = sql_crud.get_entity_by_name_or_did(db, name=entity_did)
if entity is None:
raise ClanError(f"Entity with did '{entity_did}' not found")
return entity
@@ -153,9 +190,6 @@ def detach_entity(
limit: int = 100,
db: Session = Depends(sql_db.get_db),
) -> dict[str, str]:
entity = sql_crud.get_entity_by_did(db, did=entity_did)
if entity is None:
raise ClanError(f"Entity with did '{entity_did}' not found")
sql_crud.set_stop_health_task(db, entity_did, True)
return {"message": f"Detached {entity_did} successfully"}
@@ -243,6 +277,8 @@ def get_rpc_by_role(db: Session, role: Role, path: str) -> Any:
raise ClanError(f"No {role} found")
if len(matching_entities) > 1:
raise ClanError(f"More than one {role} found")
if len(matching_entities) == 0:
raise ClanError(f"No {role} found")
dlg = matching_entities[0]
url = f"http://{dlg.ip}/{path}"
@@ -317,7 +353,6 @@ def get_all_eventmessages(
# #
##############################
@router.get("/emulate", response_class=HTMLResponse)
@router.get("/emu", response_class=HTMLResponse)
def get_emulated_enpoints() -> HTMLResponse:
from clan_cli.config import ap_url, c1_url, c2_url, dlg_url

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

@@ -1,25 +1,15 @@
import logging
from datetime import datetime
from enum import Enum
from typing import List
from pydantic import BaseModel, Field, validator
from . import sql_models
from .db_types import Role, Status
log = logging.getLogger(__name__)
class Status(Enum):
ONLINE = "online"
OFFLINE = "offline"
UNKNOWN = "unknown"
class Role(Enum):
PROSUMER = "service_prosumer"
AP = "AP"
DLG = "DLG"
class Machine(BaseModel):
name: str
status: Status
@@ -72,8 +62,15 @@ class Entity(EntityBase):
# define a custom getter function for roles
@validator("roles", pre=True)
def get_roles(cls, v: List[EntityRoles]) -> List[Role]:
return [x.role for x in v]
def get_roles(cls, v: List[sql_models.EntityRoles | Role]) -> List[Role]:
if (
isinstance(v, list)
and len(v) > 0
and isinstance(v[0], sql_models.EntityRoles)
):
return [x.role for x in v] # type: ignore
else:
return v # type: ignore
#########################
@@ -81,30 +78,50 @@ class Entity(EntityBase):
# Service #
# #
#########################
class ServiceUsageBase(BaseModel):
times_consumed: int = Field(..., example=2)
class ServiceUsageCreate(ServiceUsageBase):
consumer_entity_did: str = Field(..., example="did:sov:test:120")
class ServiceUsage(ServiceUsageCreate):
class Config:
orm_mode = True
class ServiceBase(BaseModel):
uuid: str = Field(..., example="8e285c0c-4e40-430a-a477-26b3b81e30df")
uuid: str = Field(..., example="bdd640fb-0667-1ad1-1c80-317fa3b1799d")
service_name: str = Field(..., example="Carlos Printing")
service_type: str = Field(..., example="3D Printing")
endpoint_url: str = Field(..., example="http://127.0.0.1:8000")
status: str = Field(..., example="unknown")
other: dict = Field(
..., example={"action": ["register", "deregister", "delete", "create"]}
other: dict = Field(..., example={"test": "test"})
entity_did: str = Field(..., example="did:sov:test:120")
status: dict = Field(..., example={"data": ["draft", "registered"]})
action: dict = Field(
...,
example={
"data": [
{"name": "register", "path": "/register"},
{"name": "deregister", "path": "/deregister"},
]
},
)
class ServiceCreate(ServiceBase):
entity_did: str = Field(..., example="did:sov:test:120")
usage: List[ServiceUsageCreate]
class Service(ServiceCreate):
entity: Entity
class Service(ServiceBase):
usage: List[ServiceUsage]
class Config:
orm_mode = True
class ServicesByName(BaseModel):
entity: Entity
services: List[Service]
class Config:

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

@@ -7,21 +7,121 @@ from sqlalchemy.sql.expression import true
from ..errors import ClanError
from . import schemas, sql_models
#########################
# #
# service #
# #
#########################
def create_service(db: Session, service: schemas.ServiceCreate) -> sql_models.Service:
db_service = sql_models.Service(**service.dict())
if get_entity_by_did(db, service.entity_did) is None:
raise ClanError(f"Entity with did '{service.entity_did}' not found")
if get_service_by_uuid(db, service.uuid) is not None:
raise ClanError(f"Service with uuid '{service.uuid}' already exists")
db_service = sql_models.Service(
uuid=service.uuid,
service_name=service.service_name,
service_type=service.service_type,
endpoint_url=service.endpoint_url,
status=service.status,
other=service.other,
entity_did=service.entity_did,
action=service.action,
)
db_usage = []
for usage in service.usage:
db_usage.append(
sql_models.ServiceUsage(
times_consumed=usage.times_consumed,
consumer_entity_did=usage.consumer_entity_did,
)
)
db_service.usage = db_usage
db.add(db_service)
db.commit()
db.refresh(db_service)
return db_service
def set_service_usage(
db: Session, service_uuid: str, usages: List[schemas.ServiceUsageCreate]
) -> sql_models.Service:
db_service = get_service_by_uuid(db, service_uuid)
if db_service is None:
raise ClanError(f"Service with uuid '{service_uuid}' not found")
db_usage = []
for usage in usages:
db_usage.append(
sql_models.ServiceUsage(
times_consumed=usage.times_consumed,
consumer_entity_did=usage.consumer_entity_did,
)
)
db_service.usage = db_usage
db.add(db_service)
db.commit()
db.refresh(db_service)
return db_service
def set_service(
db: Session, service_uuid: str, service: schemas.ServiceCreate
) -> sql_models.Service:
db_service = get_service_by_uuid(db, service_uuid)
if db_service is None:
raise ClanError(f"Service with uuid '{service_uuid}' not found")
db_service.service_name = service.service_name # type: ignore
db_service.service_type = service.service_type # type: ignore
db_service.endpoint_url = service.endpoint_url # type: ignore
db_service.status = service.status # type: ignore
db_service.other = service.other # type: ignore
db_service.entity_did = service.entity_did # type: ignore
db_service.action = service.action # type: ignore
db.add(db_service)
db.commit()
db.refresh(db_service)
return db_service
def add_service_usage(
db: Session, service_uuid: str, usage: schemas.ServiceUsageCreate
) -> sql_models.Service:
db_service = get_service_by_uuid(db, service_uuid)
if db_service is None:
raise ClanError(f"Service with uuid '{service_uuid}' not found")
db_service.usage.append(
sql_models.ServiceUsage(
times_consumed=usage.times_consumed,
consumer_entity_did=usage.consumer_entity_did,
)
)
db.add(db_service)
db.commit()
db.refresh(db_service)
return db_service
def increment_service_usage(
db: Session, service_uuid: str, consumer_entity_did: str
) -> sql_models.ServiceUsage:
db_service = get_service_by_uuid(db, service_uuid)
if db_service is None:
raise ClanError(f"Service with uuid '{service_uuid}' not found")
# TODO: Make a query for this
for usage in db_service.usage:
if usage.consumer_entity_did == consumer_entity_did:
usage.times_consumed += 1
break
db.add(db_service)
db.commit()
db.refresh(db_service)
return db_service
def get_service_by_uuid(db: Session, uuid: str) -> Optional[sql_models.Service]:
return db.query(sql_models.Service).filter(sql_models.Service.uuid == uuid).first()
def get_services(
db: Session, skip: int = 0, limit: int = 100
) -> List[sql_models.Service]:
@@ -65,6 +165,10 @@ def get_services_without_entity_id(
# #
#########################
def create_entity(db: Session, entity: schemas.EntityCreate) -> sql_models.Entity:
if get_entity_by_did(db, entity.did) is not None:
raise ClanError(f"Entity with did '{entity.did}' already exists")
if get_entity_by_name_or_did(db, entity.name) is not None:
raise ClanError(f"Entity with name '{entity.name}' already exists")
db_entity = sql_models.Entity(
did=entity.did,
name=entity.name,
@@ -142,7 +246,9 @@ def get_attached_entities(
# Returns same entity if setting didnt changed something
def set_stop_health_task(db: Session, entity_did: str, value: bool) -> None:
def set_stop_health_task(
db: Session, entity_did: str, value: bool
) -> sql_models.Entity:
db_entity = get_entity_by_did(db, entity_did)
if db_entity is None:
raise ClanError(f"Entity with did '{entity_did}' not found")
@@ -152,9 +258,13 @@ def set_stop_health_task(db: Session, entity_did: str, value: bool) -> None:
# save changes in db
db.add(db_entity)
db.commit()
db.refresh(db_entity)
return db_entity
def set_attached_by_entity_did(db: Session, entity_did: str, attached: bool) -> None:
def set_attached_by_entity_did(
db: Session, entity_did: str, attached: bool
) -> sql_models.Entity:
db_entity = get_entity_by_did(db, entity_did)
if db_entity is None:
raise ClanError(f"Entity with did '{entity_did}' not found")
@@ -164,6 +274,8 @@ def set_attached_by_entity_did(db: Session, entity_did: str, attached: bool) ->
# save changes in db
db.add(db_entity)
db.commit()
db.refresh(db_entity)
return db_entity
def delete_entity_by_did(db: Session, did: str) -> None:

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

@@ -1,7 +1,7 @@
from sqlalchemy import JSON, Boolean, Column, Enum, ForeignKey, Integer, String, Text
from sqlalchemy.orm import relationship
from .schemas import Role
from .db_types import Role
from .sql_db import Base
# Relationsship example
@@ -27,6 +27,7 @@ class Entity(Base):
## Relations ##
services = relationship("Service", back_populates="entity")
roles = relationship("EntityRoles", back_populates="entity")
consumes = relationship("ServiceUsage", back_populates="consumer_entity")
class EntityRoles(Base):
@@ -41,29 +42,41 @@ class EntityRoles(Base):
entity = relationship("Entity", back_populates="roles")
class ServiceAbstract(Base):
__abstract__ = True
class ServiceUsage(Base):
__tablename__ = "service_usage"
## Queryable body ##
id = Column(Integer, primary_key=True, autoincrement=True)
consumer_entity_did = Column(String, ForeignKey("entities.did"))
consumer_entity = relationship("Entity", back_populates="consumes")
times_consumed = Column(Integer, index=True, nullable=False)
service_uuid = Column(String, ForeignKey("services.uuid"))
service = relationship("Service", back_populates="usage")
class Service(Base):
__tablename__ = "services"
# Queryable body
uuid = Column(Text(length=36), primary_key=True, index=True)
service_name = Column(String, index=True)
service_type = Column(String, index=True)
endpoint_url = Column(String, index=True)
status = Column(String, index=True)
## Non queryable body ##
# In here we deposit: Action
other = Column(JSON)
class Service(ServiceAbstract):
__tablename__ = "services"
status = Column(JSON, index=True)
action = Column(JSON, index=True)
## Relations ##
# One entity can have many services
entity = relationship("Entity", back_populates="services")
entity_did = Column(String, ForeignKey("entities.did"))
usage = relationship("ServiceUsage", back_populates="service")
class Eventmessage(Base):
__tablename__ = "eventmessages"

3
pkgs/clan-cli/tests/openapi_client/__init__.py
View File

@@ -20,6 +20,7 @@ __version__ = "1.0.0"
from openapi_client.api.default_api import DefaultApi
from openapi_client.api.entities_api import EntitiesApi
from openapi_client.api.eventmessages_api import EventmessagesApi
from openapi_client.api.repositories_api import RepositoriesApi
from openapi_client.api.resolution_api import ResolutionApi
from openapi_client.api.services_api import ServicesApi
@@ -45,6 +46,8 @@ from openapi_client.models.resolution import Resolution
from openapi_client.models.role import Role
from openapi_client.models.service import Service
from openapi_client.models.service_create import ServiceCreate
from openapi_client.models.service_usage import ServiceUsage
from openapi_client.models.service_usage_create import ServiceUsageCreate
from openapi_client.models.status import Status
from openapi_client.models.validation_error import ValidationError
from openapi_client.models.validation_error_loc_inner import ValidationErrorLocInner

1
pkgs/clan-cli/tests/openapi_client/api/__init__.py
View File

@@ -4,6 +4,7 @@
from openapi_client.api.default_api import DefaultApi
from openapi_client.api.entities_api import EntitiesApi
from openapi_client.api.eventmessages_api import EventmessagesApi
from openapi_client.api.repositories_api import RepositoriesApi
from openapi_client.api.resolution_api import ResolutionApi
from openapi_client.api.services_api import ServicesApi

130
pkgs/clan-cli/tests/openapi_client/api/default_api.py
View File

@@ -170,6 +170,136 @@ class DefaultApi:
collection_formats=_collection_formats,
_request_auth=_params.get('_request_auth'))
@validate_arguments
def get_emulated_enpoints(self, **kwargs) -> str: # noqa: E501
"""Get Emulated Enpoints # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_emulated_enpoints(async_req=True)
>>> result = thread.get()
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _request_timeout: timeout setting for this request.
If one number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: str
"""
kwargs['_return_http_data_only'] = True
if '_preload_content' in kwargs:
message = "Error! Please call the get_emulated_enpoints_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
raise ValueError(message)
return self.get_emulated_enpoints_with_http_info(**kwargs) # noqa: E501
@validate_arguments
def get_emulated_enpoints_with_http_info(self, **kwargs) -> ApiResponse: # noqa: E501
"""Get Emulated Enpoints # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_emulated_enpoints_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the ApiResponse.data will
be set to none and raw_data will store the
HTTP response body without reading/decoding.
Default is True.
:type _preload_content: bool, optional
:param _return_http_data_only: response data instead of ApiResponse
object with status code, headers, etc
:type _return_http_data_only: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(str, status_code(int), headers(HTTPHeaderDict))
"""
_params = locals()
_all_params = [
]
_all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout',
'_request_auth',
'_content_type',
'_headers'
]
)
# validate the arguments
for _key, _val in _params['kwargs'].items():
if _key not in _all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method get_emulated_enpoints" % _key
)
_params[_key] = _val
del _params['kwargs']
_collection_formats = {}
# process the path parameters
_path_params = {}
# process the query parameters
_query_params = []
# process the header parameters
_header_params = dict(_params.get('_headers', {}))
# process the form parameters
_form_params = []
_files = {}
# process the body parameter
_body_params = None
# set the HTTP header `Accept`
_header_params['Accept'] = self.api_client.select_header_accept(
['text/html']) # noqa: E501
# authentication setting
_auth_settings = [] # noqa: E501
_response_types_map = {
'200': "str",
}
return self.api_client.call_api(
'/emulate', 'GET',
_path_params,
_query_params,
_header_params,
body=_body_params,
post_params=_form_params,
files=_files,
response_types_map=_response_types_map,
auth_settings=_auth_settings,
async_req=_params.get('async_req'),
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
_preload_content=_params.get('_preload_content', True),
_request_timeout=_params.get('_request_timeout'),
collection_formats=_collection_formats,
_request_auth=_params.get('_request_auth'))
@validate_arguments
def health(self, **kwargs) -> Machine: # noqa: E501
"""Health # noqa: E501

139
pkgs/clan-cli/tests/openapi_client/api/entities_api.py
View File

@@ -1074,145 +1074,6 @@ class EntitiesApi:
collection_formats=_collection_formats,
_request_auth=_params.get('_request_auth'))
@validate_arguments
def get_entity_by_name_or_did(self, entity_name_or_did : Optional[StrictStr] = None, **kwargs) -> Entity: # noqa: E501
"""Get Entity By Name Or Did # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_entity_by_name_or_did(entity_name_or_did, async_req=True)
>>> result = thread.get()
:param entity_name_or_did:
:type entity_name_or_did: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _request_timeout: timeout setting for this request.
If one number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: Entity
"""
kwargs['_return_http_data_only'] = True
if '_preload_content' in kwargs:
message = "Error! Please call the get_entity_by_name_or_did_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
raise ValueError(message)
return self.get_entity_by_name_or_did_with_http_info(entity_name_or_did, **kwargs) # noqa: E501
@validate_arguments
def get_entity_by_name_or_did_with_http_info(self, entity_name_or_did : Optional[StrictStr] = None, **kwargs) -> ApiResponse: # noqa: E501
"""Get Entity By Name Or Did # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_entity_by_name_or_did_with_http_info(entity_name_or_did, async_req=True)
>>> result = thread.get()
:param entity_name_or_did:
:type entity_name_or_did: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the ApiResponse.data will
be set to none and raw_data will store the
HTTP response body without reading/decoding.
Default is True.
:type _preload_content: bool, optional
:param _return_http_data_only: response data instead of ApiResponse
object with status code, headers, etc
:type _return_http_data_only: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(Entity, status_code(int), headers(HTTPHeaderDict))
"""
_params = locals()
_all_params = [
'entity_name_or_did'
]
_all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout',
'_request_auth',
'_content_type',
'_headers'
]
)
# validate the arguments
for _key, _val in _params['kwargs'].items():
if _key not in _all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method get_entity_by_name_or_did" % _key
)
_params[_key] = _val
del _params['kwargs']
_collection_formats = {}
# process the path parameters
_path_params = {}
# process the query parameters
_query_params = []
if _params.get('entity_name_or_did') is not None: # noqa: E501
_query_params.append(('entity_name_or_did', _params['entity_name_or_did']))
# process the header parameters
_header_params = dict(_params.get('_headers', {}))
# process the form parameters
_form_params = []
_files = {}
# process the body parameter
_body_params = None
# set the HTTP header `Accept`
_header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# authentication setting
_auth_settings = [] # noqa: E501
_response_types_map = {
'200': "Entity",
'422': "HTTPValidationError",
}
return self.api_client.call_api(
'/api/v1/entity_by_name_or_did', 'GET',
_path_params,
_query_params,
_header_params,
body=_body_params,
post_params=_form_params,
files=_files,
response_types_map=_response_types_map,
auth_settings=_auth_settings,
async_req=_params.get('async_req'),
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
_preload_content=_params.get('_preload_content', True),
_request_timeout=_params.get('_request_timeout'),
collection_formats=_collection_formats,
_request_auth=_params.get('_request_auth'))
@validate_arguments
def get_entity_by_roles(self, roles : conlist(Role), **kwargs) -> List[Entity]: # noqa: E501
"""Get Entity By Roles # noqa: E501

192
pkgs/clan-cli/tests/openapi_client/api/repositories_api.py Normal file
View File

@@ -0,0 +1,192 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
import re # noqa: F401
import io
import warnings
from pydantic import validate_arguments, ValidationError
from pydantic import StrictInt
from typing import List, Optional
from openapi_client.models.service import Service
from openapi_client.api_client import ApiClient
from openapi_client.api_response import ApiResponse
from openapi_client.exceptions import ( # noqa: F401
ApiTypeError,
ApiValueError
)
class RepositoriesApi:
"""NOTE: This class is auto generated by OpenAPI Generator
Ref: https://openapi-generator.tech
Do not edit the class manually.
"""
def __init__(self, api_client=None) -> None:
if api_client is None:
api_client = ApiClient.get_default()
self.api_client = api_client
@validate_arguments
def get_all_repositories(self, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> List[Service]: # noqa: E501
"""Get All Repositories # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_all_repositories(skip, limit, async_req=True)
>>> result = thread.get()
:param skip:
:type skip: int
:param limit:
:type limit: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _request_timeout: timeout setting for this request.
If one number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: List[Service]
"""
kwargs['_return_http_data_only'] = True
if '_preload_content' in kwargs:
message = "Error! Please call the get_all_repositories_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
raise ValueError(message)
return self.get_all_repositories_with_http_info(skip, limit, **kwargs) # noqa: E501
@validate_arguments
def get_all_repositories_with_http_info(self, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> ApiResponse: # noqa: E501
"""Get All Repositories # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_all_repositories_with_http_info(skip, limit, async_req=True)
>>> result = thread.get()
:param skip:
:type skip: int
:param limit:
:type limit: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the ApiResponse.data will
be set to none and raw_data will store the
HTTP response body without reading/decoding.
Default is True.
:type _preload_content: bool, optional
:param _return_http_data_only: response data instead of ApiResponse
object with status code, headers, etc
:type _return_http_data_only: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(List[Service], status_code(int), headers(HTTPHeaderDict))
"""
_params = locals()
_all_params = [
'skip',
'limit'
]
_all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout',
'_request_auth',
'_content_type',
'_headers'
]
)
# validate the arguments
for _key, _val in _params['kwargs'].items():
if _key not in _all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method get_all_repositories" % _key
)
_params[_key] = _val
del _params['kwargs']
_collection_formats = {}
# process the path parameters
_path_params = {}
# process the query parameters
_query_params = []
if _params.get('skip') is not None: # noqa: E501
_query_params.append(('skip', _params['skip']))
if _params.get('limit') is not None: # noqa: E501
_query_params.append(('limit', _params['limit']))
# process the header parameters
_header_params = dict(_params.get('_headers', {}))
# process the form parameters
_form_params = []
_files = {}
# process the body parameter
_body_params = None
# set the HTTP header `Accept`
_header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# authentication setting
_auth_settings = [] # noqa: E501
_response_types_map = {
'200': "List[Service]",
'422': "HTTPValidationError",
}
return self.api_client.call_api(
'/api/v1/repositories', 'GET',
_path_params,
_query_params,
_header_params,
body=_body_params,
post_params=_form_params,
files=_files,
response_types_map=_response_types_map,
auth_settings=_auth_settings,
async_req=_params.get('async_req'),
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
_preload_content=_params.get('_preload_content', True),
_request_timeout=_params.get('_request_timeout'),
collection_formats=_collection_formats,
_request_auth=_params.get('_request_auth'))

472
pkgs/clan-cli/tests/openapi_client/api/services_api.py
View File

@@ -24,6 +24,7 @@ from typing import Any, List, Optional, Dict
from openapi_client.models.service import Service
from openapi_client.models.service_create import ServiceCreate
from openapi_client.models.service_usage_create import ServiceUsageCreate
from openapi_client.api_client import ApiClient
from openapi_client.api_response import ApiResponse
@@ -45,6 +46,160 @@ class ServicesApi:
api_client = ApiClient.get_default()
self.api_client = api_client
@validate_arguments
def add_service_usage(self, service_usage_create : ServiceUsageCreate, service_uuid : Optional[StrictStr] = None, **kwargs) -> Service: # noqa: E501
"""Add Service Usage # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.add_service_usage(service_usage_create, service_uuid, async_req=True)
>>> result = thread.get()
:param service_usage_create: (required)
:type service_usage_create: ServiceUsageCreate
:param service_uuid:
:type service_uuid: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _request_timeout: timeout setting for this request.
If one number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: Service
"""
kwargs['_return_http_data_only'] = True
if '_preload_content' in kwargs:
message = "Error! Please call the add_service_usage_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
raise ValueError(message)
return self.add_service_usage_with_http_info(service_usage_create, service_uuid, **kwargs) # noqa: E501
@validate_arguments
def add_service_usage_with_http_info(self, service_usage_create : ServiceUsageCreate, service_uuid : Optional[StrictStr] = None, **kwargs) -> ApiResponse: # noqa: E501
"""Add Service Usage # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.add_service_usage_with_http_info(service_usage_create, service_uuid, async_req=True)
>>> result = thread.get()
:param service_usage_create: (required)
:type service_usage_create: ServiceUsageCreate
:param service_uuid:
:type service_uuid: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the ApiResponse.data will
be set to none and raw_data will store the
HTTP response body without reading/decoding.
Default is True.
:type _preload_content: bool, optional
:param _return_http_data_only: response data instead of ApiResponse
object with status code, headers, etc
:type _return_http_data_only: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(Service, status_code(int), headers(HTTPHeaderDict))
"""
_params = locals()
_all_params = [
'service_usage_create',
'service_uuid'
]
_all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout',
'_request_auth',
'_content_type',
'_headers'
]
)
# validate the arguments
for _key, _val in _params['kwargs'].items():
if _key not in _all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method add_service_usage" % _key
)
_params[_key] = _val
del _params['kwargs']
_collection_formats = {}
# process the path parameters
_path_params = {}
# process the query parameters
_query_params = []
if _params.get('service_uuid') is not None: # noqa: E501
_query_params.append(('service_uuid', _params['service_uuid']))
# process the header parameters
_header_params = dict(_params.get('_headers', {}))
# process the form parameters
_form_params = []
_files = {}
# process the body parameter
_body_params = None
if _params['service_usage_create'] is not None:
_body_params = _params['service_usage_create']
# set the HTTP header `Accept`
_header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# set the HTTP header `Content-Type`
_content_types_list = _params.get('_content_type',
self.api_client.select_header_content_type(
['application/json']))
if _content_types_list:
_header_params['Content-Type'] = _content_types_list
# authentication setting
_auth_settings = [] # noqa: E501
_response_types_map = {
'200': "Service",
'422': "HTTPValidationError",
}
return self.api_client.call_api(
'/api/v1/service_usage', 'POST',
_path_params,
_query_params,
_header_params,
body=_body_params,
post_params=_form_params,
files=_files,
response_types_map=_response_types_map,
auth_settings=_auth_settings,
async_req=_params.get('async_req'),
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
_preload_content=_params.get('_preload_content', True),
_request_timeout=_params.get('_request_timeout'),
collection_formats=_collection_formats,
_request_auth=_params.get('_request_auth'))
@validate_arguments
def create_service(self, service_create : ServiceCreate, **kwargs) -> Service: # noqa: E501
"""Create Service # noqa: E501
@@ -615,6 +770,161 @@ class ServicesApi:
'422': "HTTPValidationError",
}
return self.api_client.call_api(
'/api/v1/service_by_did', 'GET',
_path_params,
_query_params,
_header_params,
body=_body_params,
post_params=_form_params,
files=_files,
response_types_map=_response_types_map,
auth_settings=_auth_settings,
async_req=_params.get('async_req'),
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
_preload_content=_params.get('_preload_content', True),
_request_timeout=_params.get('_request_timeout'),
collection_formats=_collection_formats,
_request_auth=_params.get('_request_auth'))
@validate_arguments
def get_service_by_uuid(self, uuid : Optional[StrictStr] = None, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> Service: # noqa: E501
"""Get Service By Uuid # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_service_by_uuid(uuid, skip, limit, async_req=True)
>>> result = thread.get()
:param uuid:
:type uuid: str
:param skip:
:type skip: int
:param limit:
:type limit: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _request_timeout: timeout setting for this request.
If one number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: Service
"""
kwargs['_return_http_data_only'] = True
if '_preload_content' in kwargs:
message = "Error! Please call the get_service_by_uuid_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
raise ValueError(message)
return self.get_service_by_uuid_with_http_info(uuid, skip, limit, **kwargs) # noqa: E501
@validate_arguments
def get_service_by_uuid_with_http_info(self, uuid : Optional[StrictStr] = None, skip : Optional[StrictInt] = None, limit : Optional[StrictInt] = None, **kwargs) -> ApiResponse: # noqa: E501
"""Get Service By Uuid # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_service_by_uuid_with_http_info(uuid, skip, limit, async_req=True)
>>> result = thread.get()
:param uuid:
:type uuid: str
:param skip:
:type skip: int
:param limit:
:type limit: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the ApiResponse.data will
be set to none and raw_data will store the
HTTP response body without reading/decoding.
Default is True.
:type _preload_content: bool, optional
:param _return_http_data_only: response data instead of ApiResponse
object with status code, headers, etc
:type _return_http_data_only: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(Service, status_code(int), headers(HTTPHeaderDict))
"""
_params = locals()
_all_params = [
'uuid',
'skip',
'limit'
]
_all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout',
'_request_auth',
'_content_type',
'_headers'
]
)
# validate the arguments
for _key, _val in _params['kwargs'].items():
if _key not in _all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method get_service_by_uuid" % _key
)
_params[_key] = _val
del _params['kwargs']
_collection_formats = {}
# process the path parameters
_path_params = {}
# process the query parameters
_query_params = []
if _params.get('uuid') is not None: # noqa: E501
_query_params.append(('uuid', _params['uuid']))
if _params.get('skip') is not None: # noqa: E501
_query_params.append(('skip', _params['skip']))
if _params.get('limit') is not None: # noqa: E501
_query_params.append(('limit', _params['limit']))
# process the header parameters
_header_params = dict(_params.get('_headers', {}))
# process the form parameters
_form_params = []
_files = {}
# process the body parameter
_body_params = None
# set the HTTP header `Accept`
_header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# authentication setting
_auth_settings = [] # noqa: E501
_response_types_map = {
'200': "Service",
'422': "HTTPValidationError",
}
return self.api_client.call_api(
'/api/v1/service', 'GET',
_path_params,
@@ -786,3 +1096,165 @@ class ServicesApi:
_request_timeout=_params.get('_request_timeout'),
collection_formats=_collection_formats,
_request_auth=_params.get('_request_auth'))
@validate_arguments
def inc_service_usage(self, service_usage_create : ServiceUsageCreate, consumer_entity_did : Optional[StrictStr] = None, service_uuid : Optional[StrictStr] = None, **kwargs) -> Service: # noqa: E501
"""Inc Service Usage # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.inc_service_usage(service_usage_create, consumer_entity_did, service_uuid, async_req=True)
>>> result = thread.get()
:param service_usage_create: (required)
:type service_usage_create: ServiceUsageCreate
:param consumer_entity_did:
:type consumer_entity_did: str
:param service_uuid:
:type service_uuid: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _request_timeout: timeout setting for this request.
If one number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: Service
"""
kwargs['_return_http_data_only'] = True
if '_preload_content' in kwargs:
message = "Error! Please call the inc_service_usage_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data" # noqa: E501
raise ValueError(message)
return self.inc_service_usage_with_http_info(service_usage_create, consumer_entity_did, service_uuid, **kwargs) # noqa: E501
@validate_arguments
def inc_service_usage_with_http_info(self, service_usage_create : ServiceUsageCreate, consumer_entity_did : Optional[StrictStr] = None, service_uuid : Optional[StrictStr] = None, **kwargs) -> ApiResponse: # noqa: E501
"""Inc Service Usage # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.inc_service_usage_with_http_info(service_usage_create, consumer_entity_did, service_uuid, async_req=True)
>>> result = thread.get()
:param service_usage_create: (required)
:type service_usage_create: ServiceUsageCreate
:param consumer_entity_did:
:type consumer_entity_did: str
:param service_uuid:
:type service_uuid: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the ApiResponse.data will
be set to none and raw_data will store the
HTTP response body without reading/decoding.
Default is True.
:type _preload_content: bool, optional
:param _return_http_data_only: response data instead of ApiResponse
object with status code, headers, etc
:type _return_http_data_only: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _request_auth: set to override the auth_settings for an a single
request; this effectively ignores the authentication
in the spec for a single request.
:type _request_auth: dict, optional
:type _content_type: string, optional: force content-type for the request
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(Service, status_code(int), headers(HTTPHeaderDict))
"""
_params = locals()
_all_params = [
'service_usage_create',
'consumer_entity_did',
'service_uuid'
]
_all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout',
'_request_auth',
'_content_type',
'_headers'
]
)
# validate the arguments
for _key, _val in _params['kwargs'].items():
if _key not in _all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method inc_service_usage" % _key
)
_params[_key] = _val
del _params['kwargs']
_collection_formats = {}
# process the path parameters
_path_params = {}
# process the query parameters
_query_params = []
if _params.get('consumer_entity_did') is not None: # noqa: E501
_query_params.append(('consumer_entity_did', _params['consumer_entity_did']))
if _params.get('service_uuid') is not None: # noqa: E501
_query_params.append(('service_uuid', _params['service_uuid']))
# process the header parameters
_header_params = dict(_params.get('_headers', {}))
# process the form parameters
_form_params = []
_files = {}
# process the body parameter
_body_params = None
if _params['service_usage_create'] is not None:
_body_params = _params['service_usage_create']
# set the HTTP header `Accept`
_header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# set the HTTP header `Content-Type`
_content_types_list = _params.get('_content_type',
self.api_client.select_header_content_type(
['application/json']))
if _content_types_list:
_header_params['Content-Type'] = _content_types_list
# authentication setting
_auth_settings = [] # noqa: E501
_response_types_map = {
'200': "Service",
'422': "HTTPValidationError",
}
return self.api_client.call_api(
'/api/v1/inc_service_usage', 'PUT',
_path_params,
_query_params,
_header_params,
body=_body_params,
post_params=_form_params,
files=_files,
response_types_map=_response_types_map,
auth_settings=_auth_settings,
async_req=_params.get('async_req'),
_return_http_data_only=_params.get('_return_http_data_only'), # noqa: E501
_preload_content=_params.get('_preload_content', True),
_request_timeout=_params.get('_request_timeout'),
collection_formats=_collection_formats,
_request_auth=_params.get('_request_auth'))

121
pkgs/clan-cli/tests/openapi_client/docs/DefaultApi.md
View File

@@ -1,15 +1,16 @@
# openapi_client.DefaultApi
All URIs are relative to _http://localhost_
All URIs are relative to *http://localhost*
Method | HTTP request | Description
------------- | ------------- | -------------
[**get**](DefaultApi.md#get) | **GET** /ws2_example | Get
[**get_emulated_enpoints**](DefaultApi.md#get_emulated_enpoints) | **GET** /emulate | Get Emulated Enpoints
[**health**](DefaultApi.md#health) | **GET** /health | Health
[**root**](DefaultApi.md#root) | **GET** /{path_name} | Root
| Method | HTTP request | Description |
| ---------------------------------- | -------------------- | ----------- |
| [**get**](DefaultApi.md#get) | **GET** /ws2_example | Get |
| [**health**](DefaultApi.md#health) | **GET** /health | Health |
| [**root**](DefaultApi.md#root) | **GET** /{path_name} | Root |
# **get**
> get()
Get
@@ -42,8 +43,9 @@ with openapi_client.ApiClient(configuration) as api_client:
print("Exception when calling DefaultApi->get: %s\n" % e)
```
### Parameters
### Parameters
This endpoint does not need any parameter.
### Return type
@@ -56,19 +58,77 @@ No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
|-------------|-------------|------------------|
**200** | Successful Response | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **get_emulated_enpoints**
> str get_emulated_enpoints()
Get Emulated Enpoints
### Example
```python
import time
import os
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.DefaultApi(api_client)
try:
# Get Emulated Enpoints
api_response = api_instance.get_emulated_enpoints()
print("The response of DefaultApi->get_emulated_enpoints:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DefaultApi->get_emulated_enpoints: %s\n" % e)
```
### Parameters
This endpoint does not need any parameter.
### Return type
**str**
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: text/html
### HTTP response details
| Status code | Description | Response headers |
|-------------|-------------|------------------|
**200** | Successful Response | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **health**
> Machine health()
Health
@@ -104,8 +164,9 @@ with openapi_client.ApiClient(configuration) as api_client:
print("Exception when calling DefaultApi->health: %s\n" % e)
```
### Parameters
### Parameters
This endpoint does not need any parameter.
### Return type
@@ -118,19 +179,17 @@ No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
|-------------|-------------|------------------|
**200** | Successful Response | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **root**
> root(path_name)
Root
@@ -164,11 +223,13 @@ with openapi_client.ApiClient(configuration) as api_client:
print("Exception when calling DefaultApi->root: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| ------------- | ------- | ----------- | ----- |
| **path_name** | **str** | |
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**path_name** | **str**| |
### Return type
@@ -180,14 +241,14 @@ No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

295
pkgs/clan-cli/tests/openapi_client/docs/EntitiesApi.md
View File

@@ -1,22 +1,21 @@
# openapi_client.EntitiesApi
All URIs are relative to _http://localhost_
All URIs are relative to *http://localhost*
Method | HTTP request | Description
------------- | ------------- | -------------
[**attach_entity**](EntitiesApi.md#attach_entity) | **PUT** /api/v1/attach | Attach Entity
[**create_entity**](EntitiesApi.md#create_entity) | **POST** /api/v1/entity | Create Entity
[**delete_entity**](EntitiesApi.md#delete_entity) | **DELETE** /api/v1/entity | Delete Entity
[**detach_entity**](EntitiesApi.md#detach_entity) | **PUT** /api/v1/detach | Detach Entity
[**get_all_entities**](EntitiesApi.md#get_all_entities) | **GET** /api/v1/entities | Get All Entities
[**get_attached_entities**](EntitiesApi.md#get_attached_entities) | **GET** /api/v1/attached_entities | Get Attached Entities
[**get_entity_by_did**](EntitiesApi.md#get_entity_by_did) | **GET** /api/v1/entity | Get Entity By Did
[**get_entity_by_roles**](EntitiesApi.md#get_entity_by_roles) | **GET** /api/v1/entity_by_roles | Get Entity By Roles
[**is_attached**](EntitiesApi.md#is_attached) | **GET** /api/v1/is_attached | Is Attached
| Method | HTTP request | Description |
| ------------------------------------------------------------------------- | ------------------------------------- | ------------------------- |
| [**attach_entity**](EntitiesApi.md#attach_entity) | **PUT** /api/v1/attach | Attach Entity |
| [**create_entity**](EntitiesApi.md#create_entity) | **POST** /api/v1/entity | Create Entity |
| [**delete_entity**](EntitiesApi.md#delete_entity) | **DELETE** /api/v1/entity | Delete Entity |
| [**detach_entity**](EntitiesApi.md#detach_entity) | **PUT** /api/v1/detach | Detach Entity |
| [**get_all_entities**](EntitiesApi.md#get_all_entities) | **GET** /api/v1/entities | Get All Entities |
| [**get_attached_entities**](EntitiesApi.md#get_attached_entities) | **GET** /api/v1/attached_entities | Get Attached Entities |
| [**get_entity_by_did**](EntitiesApi.md#get_entity_by_did) | **GET** /api/v1/entity | Get Entity By Did |
| [**get_entity_by_name_or_did**](EntitiesApi.md#get_entity_by_name_or_did) | **GET** /api/v1/entity_by_name_or_did | Get Entity By Name Or Did |
| [**get_entity_by_roles**](EntitiesApi.md#get_entity_by_roles) | **GET** /api/v1/entity_by_roles | Get Entity By Roles |
| [**is_attached**](EntitiesApi.md#is_attached) | **GET** /api/v1/is_attached | Is Attached |
# **attach_entity**
> Dict[str, str] attach_entity(entity_did=entity_did, skip=skip, limit=limit)
Attach Entity
@@ -41,7 +40,7 @@ configuration = openapi_client.Configuration(
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.EntitiesApi(api_client)
entity_did = 'did:sov:test:1234' # str | (optional) (default to 'did:sov:test:1234')
entity_did = 'did:sov:test:120' # str | (optional) (default to 'did:sov:test:120')
skip = 0 # int | (optional) (default to 0)
limit = 100 # int | (optional) (default to 100)
@@ -54,13 +53,15 @@ with openapi_client.ApiClient(configuration) as api_client:
print("Exception when calling EntitiesApi->attach_entity: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| -------------- | ------- | ----------- | --------------------------------------------------- |
| **entity_did** | **str** | | [optional] [default to &#39;did:sov:test:1234&#39;] |
| **skip** | **int** | | [optional] [default to 0] |
| **limit** | **int** | | [optional] [default to 100] |
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**entity_did** | **str**| | [optional] [default to &#39;did:sov:test:120&#39;]
**skip** | **int**| | [optional] [default to 0]
**limit** | **int**| | [optional] [default to 100]
### Return type
@@ -72,20 +73,18 @@ No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **create_entity**
> Entity create_entity(entity_create)
Create Entity
@@ -123,11 +122,13 @@ with openapi_client.ApiClient(configuration) as api_client:
print("Exception when calling EntitiesApi->create_entity: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| ----------------- | ----------------------------------- | ----------- | ----- |
| **entity_create** | [**EntityCreate**](EntityCreate.md) | |
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**entity_create** | [**EntityCreate**](EntityCreate.md)| |
### Return type
@@ -139,20 +140,18 @@ No authorization required
### HTTP request headers
- **Content-Type**: application/json
- **Accept**: application/json
- **Content-Type**: application/json
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **delete_entity**
> Dict[str, str] delete_entity(entity_did=entity_did)
Delete Entity
@@ -177,7 +176,7 @@ configuration = openapi_client.Configuration(
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.EntitiesApi(api_client)
entity_did = 'did:sov:test:1234' # str | (optional) (default to 'did:sov:test:1234')
entity_did = 'did:sov:test:120' # str | (optional) (default to 'did:sov:test:120')
try:
# Delete Entity
@@ -188,11 +187,13 @@ with openapi_client.ApiClient(configuration) as api_client:
print("Exception when calling EntitiesApi->delete_entity: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| -------------- | ------- | ----------- | --------------------------------------------------- |
| **entity_did** | **str** | | [optional] [default to &#39;did:sov:test:1234&#39;] |
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**entity_did** | **str**| | [optional] [default to &#39;did:sov:test:120&#39;]
### Return type
@@ -204,20 +205,18 @@ No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **detach_entity**
> Dict[str, str] detach_entity(entity_did=entity_did, skip=skip, limit=limit)
Detach Entity
@@ -242,7 +241,7 @@ configuration = openapi_client.Configuration(
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.EntitiesApi(api_client)
entity_did = 'did:sov:test:1234' # str | (optional) (default to 'did:sov:test:1234')
entity_did = 'did:sov:test:120' # str | (optional) (default to 'did:sov:test:120')
skip = 0 # int | (optional) (default to 0)
limit = 100 # int | (optional) (default to 100)
@@ -255,13 +254,15 @@ with openapi_client.ApiClient(configuration) as api_client:
print("Exception when calling EntitiesApi->detach_entity: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| -------------- | ------- | ----------- | --------------------------------------------------- |
| **entity_did** | **str** | | [optional] [default to &#39;did:sov:test:1234&#39;] |
| **skip** | **int** | | [optional] [default to 0] |
| **limit** | **int** | | [optional] [default to 100] |
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**entity_did** | **str**| | [optional] [default to &#39;did:sov:test:120&#39;]
**skip** | **int**| | [optional] [default to 0]
**limit** | **int**| | [optional] [default to 100]
### Return type
@@ -273,20 +274,18 @@ No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **get_all_entities**
> List[Entity] get_all_entities(skip=skip, limit=limit)
Get All Entities
@@ -324,12 +323,14 @@ with openapi_client.ApiClient(configuration) as api_client:
print("Exception when calling EntitiesApi->get_all_entities: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| --------- | ------- | ----------- | --------------------------- |
| **skip** | **int** | | [optional] [default to 0] |
| **limit** | **int** | | [optional] [default to 100] |
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**skip** | **int**| | [optional] [default to 0]
**limit** | **int**| | [optional] [default to 100]
### Return type
@@ -341,20 +342,18 @@ No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **get_attached_entities**
> List[Entity] get_attached_entities(skip=skip, limit=limit)
Get Attached Entities
@@ -392,12 +391,14 @@ with openapi_client.ApiClient(configuration) as api_client:
print("Exception when calling EntitiesApi->get_attached_entities: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| --------- | ------- | ----------- | --------------------------- |
| **skip** | **int** | | [optional] [default to 0] |
| **limit** | **int** | | [optional] [default to 100] |
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**skip** | **int**| | [optional] [default to 0]
**limit** | **int**| | [optional] [default to 100]
### Return type
@@ -409,20 +410,18 @@ No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **get_entity_by_did**
> Entity get_entity_by_did(entity_did=entity_did)
Get Entity By Did
@@ -448,7 +447,7 @@ configuration = openapi_client.Configuration(
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.EntitiesApi(api_client)
entity_did = 'did:sov:test:1234' # str | (optional) (default to 'did:sov:test:1234')
entity_did = 'did:sov:test:120' # str | (optional) (default to 'did:sov:test:120')
try:
# Get Entity By Did
@@ -459,11 +458,13 @@ with openapi_client.ApiClient(configuration) as api_client:
print("Exception when calling EntitiesApi->get_entity_by_did: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| -------------- | ------- | ----------- | --------------------------------------------------- |
| **entity_did** | **str** | | [optional] [default to &#39;did:sov:test:1234&#39;] |
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**entity_did** | **str**| | [optional] [default to &#39;did:sov:test:120&#39;]
### Return type
@@ -475,86 +476,18 @@ No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **get_entity_by_name_or_did**
> Entity get_entity_by_name_or_did(entity_name_or_did=entity_name_or_did)
Get Entity By Name Or Did
### Example
```python
import time
import os
import openapi_client
from openapi_client.models.entity import Entity
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.EntitiesApi(api_client)
entity_name_or_did = 'C1' # str | (optional) (default to 'C1')
try:
# Get Entity By Name Or Did
api_response = api_instance.get_entity_by_name_or_did(entity_name_or_did=entity_name_or_did)
print("The response of EntitiesApi->get_entity_by_name_or_did:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling EntitiesApi->get_entity_by_name_or_did: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| ---------------------- | ------- | ----------- | ------------------------------------ |
| **entity_name_or_did** | **str** | | [optional] [default to &#39;C1&#39;] |
### Return type
[**Entity**](Entity.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **get_entity_by_roles**
> List[Entity] get_entity_by_roles(roles)
Get Entity By Roles
@@ -592,11 +525,13 @@ with openapi_client.ApiClient(configuration) as api_client:
print("Exception when calling EntitiesApi->get_entity_by_roles: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| --------- | ------------------------- | ----------- | ----- |
| **roles** | [**List[Role]**](Role.md) | |
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**roles** | [**List[Role]**](Role.md)| |
### Return type
@@ -608,20 +543,18 @@ No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **is_attached**
> Dict[str, str] is_attached(entity_did=entity_did)
Is Attached
@@ -646,7 +579,7 @@ configuration = openapi_client.Configuration(
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.EntitiesApi(api_client)
entity_did = 'did:sov:test:1234' # str | (optional) (default to 'did:sov:test:1234')
entity_did = 'did:sov:test:120' # str | (optional) (default to 'did:sov:test:120')
try:
# Is Attached
@@ -657,11 +590,13 @@ with openapi_client.ApiClient(configuration) as api_client:
print("Exception when calling EntitiesApi->is_attached: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| -------------- | ------- | ----------- | --------------------------------------------------- |
| **entity_did** | **str** | | [optional] [default to &#39;did:sov:test:1234&#39;] |
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**entity_did** | **str**| | [optional] [default to &#39;did:sov:test:120&#39;]
### Return type
@@ -673,14 +608,14 @@ No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

27
pkgs/clan-cli/tests/openapi_client/docs/Entity.md
View File

@@ -1,18 +1,18 @@
# Entity
## Properties
| Name | Type | Description | Notes |
| -------------------- | ------------------------- | ----------- | ----- |
| **did** | **str** | |
| **name** | **str** | |
| **ip** | **str** | |
| **network** | **str** | |
| **visible** | **bool** | |
| **other** | **object** | |
| **attached** | **bool** | |
| **stop_health_task** | **bool** | |
| **roles** | [**List[Role]**](Role.md) | |
## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**did** | **str** | |
**name** | **str** | |
**ip** | **str** | |
**network** | **str** | |
**visible** | **bool** | |
**other** | **object** | |
**attached** | **bool** | |
**stop_health_task** | **bool** | |
**roles** | [**List[Role]**](Role.md) | |
## Example
@@ -31,5 +31,6 @@ entity_dict = entity_instance.to_dict()
# create an instance of Entity from a dict
entity_form_dict = entity.from_dict(entity_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

23
pkgs/clan-cli/tests/openapi_client/docs/EntityCreate.md
View File

@@ -1,16 +1,16 @@
# EntityCreate
## Properties
| Name | Type | Description | Notes |
| ----------- | ------------------------- | ----------- | ----- |
| **did** | **str** | |
| **name** | **str** | |
| **ip** | **str** | |
| **network** | **str** | |
| **visible** | **bool** | |
| **other** | **object** | |
| **roles** | [**List[Role]**](Role.md) | |
## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**did** | **str** | |
**name** | **str** | |
**ip** | **str** | |
**network** | **str** | |
**visible** | **bool** | |
**other** | **object** | |
**roles** | [**List[Role]**](Role.md) | |
## Example
@@ -29,5 +29,6 @@ entity_create_dict = entity_create_instance.to_dict()
# create an instance of EntityCreate from a dict
entity_create_form_dict = entity_create.from_dict(entity_create_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

25
pkgs/clan-cli/tests/openapi_client/docs/Eventmessage.md
View File

@@ -1,17 +1,17 @@
# Eventmessage
## Properties
| Name | Type | Description | Notes |
| ------------- | ---------- | ----------- | ----- |
| **timestamp** | **int** | |
| **group** | **int** | |
| **group_id** | **int** | |
| **msg_type** | **int** | |
| **src_did** | **str** | |
| **des_did** | **str** | |
| **msg** | **object** | |
| **id** | **int** | |
## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**timestamp** | **int** | |
**group** | **int** | |
**group_id** | **int** | |
**msg_type** | **int** | |
**src_did** | **str** | |
**des_did** | **str** | |
**msg** | **object** | |
**id** | **int** | |
## Example
@@ -30,5 +30,6 @@ eventmessage_dict = eventmessage_instance.to_dict()
# create an instance of Eventmessage from a dict
eventmessage_form_dict = eventmessage.from_dict(eventmessage_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

23
pkgs/clan-cli/tests/openapi_client/docs/EventmessageCreate.md
View File

@@ -1,16 +1,16 @@
# EventmessageCreate
## Properties
| Name | Type | Description | Notes |
| ------------- | ---------- | ----------- | ----- |
| **timestamp** | **int** | |
| **group** | **int** | |
| **group_id** | **int** | |
| **msg_type** | **int** | |
| **src_did** | **str** | |
| **des_did** | **str** | |
| **msg** | **object** | |
## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**timestamp** | **int** | |
**group** | **int** | |
**group_id** | **int** | |
**msg_type** | **int** | |
**src_did** | **str** | |
**des_did** | **str** | |
**msg** | **object** | |
## Example
@@ -29,5 +29,6 @@ eventmessage_create_dict = eventmessage_create_instance.to_dict()
# create an instance of EventmessageCreate from a dict
eventmessage_create_form_dict = eventmessage_create.from_dict(eventmessage_create_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

54
pkgs/clan-cli/tests/openapi_client/docs/EventmessagesApi.md
View File

@@ -1,14 +1,14 @@
# openapi_client.EventmessagesApi
All URIs are relative to _http://localhost_
All URIs are relative to *http://localhost*
Method | HTTP request | Description
------------- | ------------- | -------------
[**create_eventmessage**](EventmessagesApi.md#create_eventmessage) | **POST** /api/v1/event_message | Create Eventmessage
[**get_all_eventmessages**](EventmessagesApi.md#get_all_eventmessages) | **GET** /api/v1/event_messages | Get All Eventmessages
| Method | HTTP request | Description |
| ---------------------------------------------------------------------- | ------------------------------ | --------------------- |
| [**create_eventmessage**](EventmessagesApi.md#create_eventmessage) | **POST** /api/v1/event_message | Create Eventmessage |
| [**get_all_eventmessages**](EventmessagesApi.md#get_all_eventmessages) | **GET** /api/v1/event_messages | Get All Eventmessages |
# **create_eventmessage**
> Eventmessage create_eventmessage(eventmessage_create)
Create Eventmessage
@@ -46,11 +46,13 @@ with openapi_client.ApiClient(configuration) as api_client:
print("Exception when calling EventmessagesApi->create_eventmessage: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| ----------------------- | ----------------------------------------------- | ----------- | ----- |
| **eventmessage_create** | [**EventmessageCreate**](EventmessageCreate.md) | |
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**eventmessage_create** | [**EventmessageCreate**](EventmessageCreate.md)| |
### Return type
@@ -62,20 +64,18 @@ No authorization required
### HTTP request headers
- **Content-Type**: application/json
- **Accept**: application/json
- **Content-Type**: application/json
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **get_all_eventmessages**
> List[Eventmessage] get_all_eventmessages(skip=skip, limit=limit)
Get All Eventmessages
@@ -113,12 +113,14 @@ with openapi_client.ApiClient(configuration) as api_client:
print("Exception when calling EventmessagesApi->get_all_eventmessages: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| --------- | ------- | ----------- | --------------------------- |
| **skip** | **int** | | [optional] [default to 0] |
| **limit** | **int** | | [optional] [default to 100] |
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**skip** | **int**| | [optional] [default to 0]
**limit** | **int**| | [optional] [default to 100]
### Return type
@@ -130,14 +132,14 @@ No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

11
pkgs/clan-cli/tests/openapi_client/docs/HTTPValidationError.md
View File

@@ -1,10 +1,10 @@
# HTTPValidationError
## Properties
| Name | Type | Description | Notes |
| ---------- | ----------------------------------------------- | ----------- | ---------- |
| **detail** | [**List[ValidationError]**](ValidationError.md) | | [optional] |
## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**detail** | [**List[ValidationError]**](ValidationError.md) | | [optional]
## Example
@@ -23,5 +23,6 @@ http_validation_error_dict = http_validation_error_instance.to_dict()
# create an instance of HTTPValidationError from a dict
http_validation_error_form_dict = http_validation_error.from_dict(http_validation_error_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

13
pkgs/clan-cli/tests/openapi_client/docs/Machine.md
View File

@@ -1,11 +1,11 @@
# Machine
## Properties
| Name | Type | Description | Notes |
| ---------- | ----------------------- | ----------- | ----- |
| **name** | **str** | |
| **status** | [**Status**](Status.md) | |
## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**name** | **str** | |
**status** | [**Status**](Status.md) | |
## Example
@@ -24,5 +24,6 @@ machine_dict = machine_instance.to_dict()
# create an instance of Machine from a dict
machine_form_dict = machine.from_dict(machine_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

77
pkgs/clan-cli/tests/openapi_client/docs/RepositoriesApi.md Normal file
View File

@@ -0,0 +1,77 @@
# openapi_client.RepositoriesApi
All URIs are relative to *http://localhost*
Method | HTTP request | Description
------------- | ------------- | -------------
[**get_all_repositories**](RepositoriesApi.md#get_all_repositories) | **GET** /api/v1/repositories | Get All Repositories
# **get_all_repositories**
> List[Service] get_all_repositories(skip=skip, limit=limit)
Get All Repositories
### Example
```python
import time
import os
import openapi_client
from openapi_client.models.service import Service
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.RepositoriesApi(api_client)
skip = 0 # int | (optional) (default to 0)
limit = 100 # int | (optional) (default to 100)
try:
# Get All Repositories
api_response = api_instance.get_all_repositories(skip=skip, limit=limit)
print("The response of RepositoriesApi->get_all_repositories:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling RepositoriesApi->get_all_repositories: %s\n" % e)
```
### Parameters
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**skip** | **int**| | [optional] [default to 0]
**limit** | **int**| | [optional] [default to 100]
### Return type
[**List[Service]**](Service.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

20
pkgs/clan-cli/tests/openapi_client/docs/Resolution.md
View File

@@ -1,15 +1,14 @@
# Resolution
## Properties
| Name | Type | Description | Notes |
| ------------------ | ------------ | ----------- | ----- |
| **requester_name** | **str** | |
| **requester_did** | **str** | |
| **resolved_did** | **str** | |
| **other** | **object** | |
| **timestamp** | **datetime** | |
| **id** | **int** | |
## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**requester_name** | **str** | |
**requester_did** | **str** | |
**resolved_did** | **str** | |
**other** | **object** | |
**timestamp** | **datetime** | |
## Example
@@ -28,5 +27,6 @@ resolution_dict = resolution_instance.to_dict()
# create an instance of Resolution from a dict
resolution_form_dict = resolution.from_dict(resolution_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

32
pkgs/clan-cli/tests/openapi_client/docs/ResolutionApi.md
View File

@@ -1,13 +1,13 @@
# openapi_client.ResolutionApi
All URIs are relative to _http://localhost_
All URIs are relative to *http://localhost*
Method | HTTP request | Description
------------- | ------------- | -------------
[**get_all_resolutions**](ResolutionApi.md#get_all_resolutions) | **GET** /api/v1/resolutions | Get All Resolutions
| Method | HTTP request | Description |
| --------------------------------------------------------------- | --------------------------- | ------------------- |
| [**get_all_resolutions**](ResolutionApi.md#get_all_resolutions) | **GET** /api/v1/resolutions | Get All Resolutions |
# **get_all_resolutions**
> List[Resolution] get_all_resolutions(skip=skip, limit=limit)
Get All Resolutions
@@ -45,12 +45,14 @@ with openapi_client.ApiClient(configuration) as api_client:
print("Exception when calling ResolutionApi->get_all_resolutions: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| --------- | ------- | ----------- | --------------------------- |
| **skip** | **int** | | [optional] [default to 0] |
| **limit** | **int** | | [optional] [default to 100] |
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**skip** | **int**| | [optional] [default to 0]
**limit** | **int**| | [optional] [default to 100]
### Return type
@@ -62,14 +64,14 @@ No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

7
pkgs/clan-cli/tests/openapi_client/docs/Role.md
View File

@@ -3,8 +3,9 @@
An enumeration.
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

26
pkgs/clan-cli/tests/openapi_client/docs/Service.md
View File

@@ -1,17 +1,18 @@
# Service
## Properties
| Name | Type | Description | Notes |
| ---------------- | ----------------------- | ----------- | ----- |
| **uuid** | **str** | |
| **service_name** | **str** | |
| **service_type** | **str** | |
| **endpoint_url** | **str** | |
| **status** | **str** | |
| **other** | **object** | |
| **entity_did** | **str** | |
| **entity** | [**Entity**](Entity.md) | |
## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**uuid** | **str** | |
**service_name** | **str** | |
**service_type** | **str** | |
**endpoint_url** | **str** | |
**other** | **object** | |
**entity_did** | **str** | |
**status** | **object** | |
**action** | **object** | |
**usage** | [**List[ServiceUsage]**](ServiceUsage.md) | |
## Example
@@ -30,5 +31,6 @@ service_dict = service_instance.to_dict()
# create an instance of Service from a dict
service_form_dict = service.from_dict(service_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

25
pkgs/clan-cli/tests/openapi_client/docs/ServiceCreate.md
View File

@@ -1,16 +1,18 @@
# ServiceCreate
## Properties
| Name | Type | Description | Notes |
| ---------------- | ---------- | ----------- | ----- |
| **uuid** | **str** | |
| **service_name** | **str** | |
| **service_type** | **str** | |
| **endpoint_url** | **str** | |
| **status** | **str** | |
| **other** | **object** | |
| **entity_did** | **str** | |
## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**uuid** | **str** | |
**service_name** | **str** | |
**service_type** | **str** | |
**endpoint_url** | **str** | |
**other** | **object** | |
**entity_did** | **str** | |
**status** | **object** | |
**action** | **object** | |
**usage** | [**List[ServiceUsageCreate]**](ServiceUsageCreate.md) | |
## Example
@@ -29,5 +31,6 @@ service_create_dict = service_create_instance.to_dict()
# create an instance of ServiceCreate from a dict
service_create_form_dict = service_create.from_dict(service_create_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

29
pkgs/clan-cli/tests/openapi_client/docs/ServiceUsage.md Normal file
View File

@@ -0,0 +1,29 @@
# ServiceUsage
## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**times_consumed** | **int** | |
**consumer_entity_did** | **str** | |
## Example
```python
from openapi_client.models.service_usage import ServiceUsage
# TODO update the JSON string below
json = "{}"
# create an instance of ServiceUsage from a JSON string
service_usage_instance = ServiceUsage.from_json(json)
# print the JSON string representation of the object
print ServiceUsage.to_json()
# convert the object into a dict
service_usage_dict = service_usage_instance.to_dict()
# create an instance of ServiceUsage from a dict
service_usage_form_dict = service_usage.from_dict(service_usage_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

29
pkgs/clan-cli/tests/openapi_client/docs/ServiceUsageCreate.md Normal file
View File

@@ -0,0 +1,29 @@
# ServiceUsageCreate
## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**times_consumed** | **int** | |
**consumer_entity_did** | **str** | |
## Example
```python
from openapi_client.models.service_usage_create import ServiceUsageCreate
# TODO update the JSON string below
json = "{}"
# create an instance of ServiceUsageCreate from a JSON string
service_usage_create_instance = ServiceUsageCreate.from_json(json)
# print the JSON string representation of the object
print ServiceUsageCreate.to_json()
# convert the object into a dict
service_usage_create_dict = service_usage_create_instance.to_dict()
# create an instance of ServiceUsageCreate from a dict
service_usage_create_form_dict = service_usage_create.from_dict(service_usage_create_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

347
pkgs/clan-cli/tests/openapi_client/docs/ServicesApi.md
View File

@@ -1,17 +1,89 @@
# openapi_client.ServicesApi
All URIs are relative to _http://localhost_
All URIs are relative to *http://localhost*
| Method | HTTP request | Description |
| ----------------------------------------------------------------------------- | --------------------------------------- | --------------------------- |
| [**create_service**](ServicesApi.md#create_service) | **POST** /api/v1/service | Create Service |
| [**delete_service**](ServicesApi.md#delete_service) | **DELETE** /api/v1/service | Delete Service |
| [**get_all_services**](ServicesApi.md#get_all_services) | **GET** /api/v1/services | Get All Services |
| [**get_service_by_did**](ServicesApi.md#get_service_by_did) | **GET** /api/v1/service | Get Service By Did |
| [**get_services_without_entity**](ServicesApi.md#get_services_without_entity) | **GET** /api/v1/services_without_entity | Get Services Without Entity |
Method | HTTP request | Description
------------- | ------------- | -------------
[**add_service_usage**](ServicesApi.md#add_service_usage) | **POST** /api/v1/service_usage | Add Service Usage
[**create_service**](ServicesApi.md#create_service) | **POST** /api/v1/service | Create Service
[**delete_service**](ServicesApi.md#delete_service) | **DELETE** /api/v1/service | Delete Service
[**get_all_services**](ServicesApi.md#get_all_services) | **GET** /api/v1/services | Get All Services
[**get_service_by_did**](ServicesApi.md#get_service_by_did) | **GET** /api/v1/service_by_did | Get Service By Did
[**get_service_by_uuid**](ServicesApi.md#get_service_by_uuid) | **GET** /api/v1/service | Get Service By Uuid
[**get_services_without_entity**](ServicesApi.md#get_services_without_entity) | **GET** /api/v1/services_without_entity | Get Services Without Entity
[**inc_service_usage**](ServicesApi.md#inc_service_usage) | **PUT** /api/v1/inc_service_usage | Inc Service Usage
# **add_service_usage**
> Service add_service_usage(service_usage_create, service_uuid=service_uuid)
Add Service Usage
### Example
```python
import time
import os
import openapi_client
from openapi_client.models.service import Service
from openapi_client.models.service_usage_create import ServiceUsageCreate
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.ServicesApi(api_client)
service_usage_create = openapi_client.ServiceUsageCreate() # ServiceUsageCreate |
service_uuid = 'bdd640fb-0667-1ad1-1c80-317fa3b1799d' # str | (optional) (default to 'bdd640fb-0667-1ad1-1c80-317fa3b1799d')
try:
# Add Service Usage
api_response = api_instance.add_service_usage(service_usage_create, service_uuid=service_uuid)
print("The response of ServicesApi->add_service_usage:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling ServicesApi->add_service_usage: %s\n" % e)
```
### Parameters
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**service_usage_create** | [**ServiceUsageCreate**](ServiceUsageCreate.md)| |
**service_uuid** | **str**| | [optional] [default to &#39;bdd640fb-0667-1ad1-1c80-317fa3b1799d&#39;]
### Return type
[**Service**](Service.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: application/json
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **create_service**
> Service create_service(service_create)
Create Service
@@ -49,11 +121,13 @@ with openapi_client.ApiClient(configuration) as api_client:
print("Exception when calling ServicesApi->create_service: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| ------------------ | ------------------------------------- | ----------- | ----- |
| **service_create** | [**ServiceCreate**](ServiceCreate.md) | |
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**service_create** | [**ServiceCreate**](ServiceCreate.md)| |
### Return type
@@ -65,20 +139,18 @@ No authorization required
### HTTP request headers
- **Content-Type**: application/json
- **Accept**: application/json
- **Content-Type**: application/json
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **delete_service**
> Dict[str, str] delete_service(entity_did=entity_did)
Delete Service
@@ -103,7 +175,7 @@ configuration = openapi_client.Configuration(
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.ServicesApi(api_client)
entity_did = 'did:sov:test:1234' # str | (optional) (default to 'did:sov:test:1234')
entity_did = 'did:sov:test:120' # str | (optional) (default to 'did:sov:test:120')
try:
# Delete Service
@@ -114,11 +186,13 @@ with openapi_client.ApiClient(configuration) as api_client:
print("Exception when calling ServicesApi->delete_service: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| -------------- | ------- | ----------- | --------------------------------------------------- |
| **entity_did** | **str** | | [optional] [default to &#39;did:sov:test:1234&#39;] |
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**entity_did** | **str**| | [optional] [default to &#39;did:sov:test:120&#39;]
### Return type
@@ -130,20 +204,18 @@ No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **get_all_services**
> List[Service] get_all_services(skip=skip, limit=limit)
Get All Services
@@ -181,12 +253,14 @@ with openapi_client.ApiClient(configuration) as api_client:
print("Exception when calling ServicesApi->get_all_services: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| --------- | ------- | ----------- | --------------------------- |
| **skip** | **int** | | [optional] [default to 0] |
| **limit** | **int** | | [optional] [default to 100] |
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**skip** | **int**| | [optional] [default to 0]
**limit** | **int**| | [optional] [default to 100]
### Return type
@@ -198,20 +272,18 @@ No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **get_service_by_did**
> List[Service] get_service_by_did(entity_did=entity_did, skip=skip, limit=limit)
Get Service By Did
@@ -237,7 +309,7 @@ configuration = openapi_client.Configuration(
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.ServicesApi(api_client)
entity_did = 'did:sov:test:1234' # str | (optional) (default to 'did:sov:test:1234')
entity_did = 'did:sov:test:120' # str | (optional) (default to 'did:sov:test:120')
skip = 0 # int | (optional) (default to 0)
limit = 100 # int | (optional) (default to 100)
@@ -250,13 +322,15 @@ with openapi_client.ApiClient(configuration) as api_client:
print("Exception when calling ServicesApi->get_service_by_did: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| -------------- | ------- | ----------- | --------------------------------------------------- |
| **entity_did** | **str** | | [optional] [default to &#39;did:sov:test:1234&#39;] |
| **skip** | **int** | | [optional] [default to 0] |
| **limit** | **int** | | [optional] [default to 100] |
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**entity_did** | **str**| | [optional] [default to &#39;did:sov:test:120&#39;]
**skip** | **int**| | [optional] [default to 0]
**limit** | **int**| | [optional] [default to 100]
### Return type
@@ -268,20 +342,88 @@ No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **get_service_by_uuid**
> Service get_service_by_uuid(uuid=uuid, skip=skip, limit=limit)
Get Service By Uuid
### Example
```python
import time
import os
import openapi_client
from openapi_client.models.service import Service
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.ServicesApi(api_client)
uuid = 'bdd640fb-0667-1ad1-1c80-317fa3b1799d' # str | (optional) (default to 'bdd640fb-0667-1ad1-1c80-317fa3b1799d')
skip = 0 # int | (optional) (default to 0)
limit = 100 # int | (optional) (default to 100)
try:
# Get Service By Uuid
api_response = api_instance.get_service_by_uuid(uuid=uuid, skip=skip, limit=limit)
print("The response of ServicesApi->get_service_by_uuid:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling ServicesApi->get_service_by_uuid: %s\n" % e)
```
### Parameters
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**uuid** | **str**| | [optional] [default to &#39;bdd640fb-0667-1ad1-1c80-317fa3b1799d&#39;]
**skip** | **int**| | [optional] [default to 0]
**limit** | **int**| | [optional] [default to 100]
### Return type
[**Service**](Service.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **get_services_without_entity**
> List[Service] get_services_without_entity(entity_did=entity_did, skip=skip, limit=limit)
Get Services Without Entity
@@ -307,7 +449,7 @@ configuration = openapi_client.Configuration(
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.ServicesApi(api_client)
entity_did = 'did:sov:test:1234' # str | (optional) (default to 'did:sov:test:1234')
entity_did = 'did:sov:test:120' # str | (optional) (default to 'did:sov:test:120')
skip = 0 # int | (optional) (default to 0)
limit = 100 # int | (optional) (default to 100)
@@ -320,13 +462,15 @@ with openapi_client.ApiClient(configuration) as api_client:
print("Exception when calling ServicesApi->get_services_without_entity: %s\n" % e)
```
### Parameters
| Name | Type | Description | Notes |
| -------------- | ------- | ----------- | --------------------------------------------------- |
| **entity_did** | **str** | | [optional] [default to &#39;did:sov:test:1234&#39;] |
| **skip** | **int** | | [optional] [default to 0] |
| **limit** | **int** | | [optional] [default to 100] |
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**entity_did** | **str**| | [optional] [default to &#39;did:sov:test:120&#39;]
**skip** | **int**| | [optional] [default to 0]
**limit** | **int**| | [optional] [default to 100]
### Return type
@@ -338,14 +482,85 @@ No authorization required
### HTTP request headers
- **Content-Type**: Not defined
- **Accept**: application/json
- **Content-Type**: Not defined
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
| ----------- | ------------------- | ---------------- |
| **200** | Successful Response | - |
| **422** | Validation Error | - |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
# **inc_service_usage**
> Service inc_service_usage(service_usage_create, consumer_entity_did=consumer_entity_did, service_uuid=service_uuid)
Inc Service Usage
### Example
```python
import time
import os
import openapi_client
from openapi_client.models.service import Service
from openapi_client.models.service_usage_create import ServiceUsageCreate
from openapi_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = openapi_client.Configuration(
host = "http://localhost"
)
# Enter a context with an instance of the API client
with openapi_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = openapi_client.ServicesApi(api_client)
service_usage_create = openapi_client.ServiceUsageCreate() # ServiceUsageCreate |
consumer_entity_did = 'did:sov:test:120' # str | (optional) (default to 'did:sov:test:120')
service_uuid = 'bdd640fb-0667-1ad1-1c80-317fa3b1799d' # str | (optional) (default to 'bdd640fb-0667-1ad1-1c80-317fa3b1799d')
try:
# Inc Service Usage
api_response = api_instance.inc_service_usage(service_usage_create, consumer_entity_did=consumer_entity_did, service_uuid=service_uuid)
print("The response of ServicesApi->inc_service_usage:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling ServicesApi->inc_service_usage: %s\n" % e)
```
### Parameters
Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
**service_usage_create** | [**ServiceUsageCreate**](ServiceUsageCreate.md)| |
**consumer_entity_did** | **str**| | [optional] [default to &#39;did:sov:test:120&#39;]
**service_uuid** | **str**| | [optional] [default to &#39;bdd640fb-0667-1ad1-1c80-317fa3b1799d&#39;]
### Return type
[**Service**](Service.md)
### Authorization
No authorization required
### HTTP request headers
- **Content-Type**: application/json
- **Accept**: application/json
### HTTP response details
| Status code | Description | Response headers |
|-------------|-------------|------------------|
**200** | Successful Response | - |
**422** | Validation Error | - |
[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

7
pkgs/clan-cli/tests/openapi_client/docs/Status.md
View File

@@ -3,8 +3,9 @@
An enumeration.
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

15
pkgs/clan-cli/tests/openapi_client/docs/ValidationError.md
View File

@@ -1,12 +1,12 @@
# ValidationError
## Properties
| Name | Type | Description | Notes |
| -------- | --------------------------------------------------------------- | ----------- | ----- |
| **loc** | [**List[ValidationErrorLocInner]**](ValidationErrorLocInner.md) | |
| **msg** | **str** | |
| **type** | **str** | |
## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**loc** | [**List[ValidationErrorLocInner]**](ValidationErrorLocInner.md) | |
**msg** | **str** | |
**type** | **str** | |
## Example
@@ -25,5 +25,6 @@ validation_error_dict = validation_error_instance.to_dict()
# create an instance of ValidationError from a dict
validation_error_form_dict = validation_error.from_dict(validation_error_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

9
pkgs/clan-cli/tests/openapi_client/docs/ValidationErrorLocInner.md
View File

@@ -1,9 +1,9 @@
# ValidationErrorLocInner
## Properties
| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
## Example
@@ -22,5 +22,6 @@ validation_error_loc_inner_dict = validation_error_loc_inner_instance.to_dict()
# create an instance of ValidationErrorLocInner from a dict
validation_error_loc_inner_form_dict = validation_error_loc_inner.from_dict(validation_error_loc_inner_dict)
```
[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

2
pkgs/clan-cli/tests/openapi_client/models/__init__.py
View File

@@ -24,6 +24,8 @@ from openapi_client.models.resolution import Resolution
from openapi_client.models.role import Role
from openapi_client.models.service import Service
from openapi_client.models.service_create import ServiceCreate
from openapi_client.models.service_usage import ServiceUsage
from openapi_client.models.service_usage_create import ServiceUsageCreate
from openapi_client.models.status import Status
from openapi_client.models.validation_error import ValidationError
from openapi_client.models.validation_error_loc_inner import ValidationErrorLocInner

8
pkgs/clan-cli/tests/openapi_client/models/resolution.py
View File

@@ -19,7 +19,7 @@ import json
from datetime import datetime
from typing import Any, Dict
from pydantic import BaseModel, Field, StrictInt, StrictStr
from pydantic import BaseModel, Field, StrictStr
class Resolution(BaseModel):
"""
@@ -30,8 +30,7 @@ class Resolution(BaseModel):
resolved_did: StrictStr = Field(...)
other: Dict[str, Any] = Field(...)
timestamp: datetime = Field(...)
id: StrictInt = Field(...)
__properties = ["requester_name", "requester_did", "resolved_did", "other", "timestamp", "id"]
__properties = ["requester_name", "requester_did", "resolved_did", "other", "timestamp"]
class Config:
"""Pydantic configuration"""
@@ -73,8 +72,7 @@ class Resolution(BaseModel):
"requester_did": obj.get("requester_did"),
"resolved_did": obj.get("resolved_did"),
"other": obj.get("other"),
"timestamp": obj.get("timestamp"),
"id": obj.get("id")
"timestamp": obj.get("timestamp")
})
return _obj

28
pkgs/clan-cli/tests/openapi_client/models/service.py
View File

@@ -18,9 +18,9 @@ import re # noqa: F401
import json
from typing import Any, Dict
from pydantic import BaseModel, Field, StrictStr
from openapi_client.models.entity import Entity
from typing import Any, Dict, List
from pydantic import BaseModel, Field, StrictStr, conlist
from openapi_client.models.service_usage import ServiceUsage
class Service(BaseModel):
"""
@@ -30,11 +30,12 @@ class Service(BaseModel):
service_name: StrictStr = Field(...)
service_type: StrictStr = Field(...)
endpoint_url: StrictStr = Field(...)
status: StrictStr = Field(...)
other: Dict[str, Any] = Field(...)
entity_did: StrictStr = Field(...)
entity: Entity = Field(...)
__properties = ["uuid", "service_name", "service_type", "endpoint_url", "status", "other", "entity_did", "entity"]
status: Dict[str, Any] = Field(...)
action: Dict[str, Any] = Field(...)
usage: conlist(ServiceUsage) = Field(...)
__properties = ["uuid", "service_name", "service_type", "endpoint_url", "other", "entity_did", "status", "action", "usage"]
class Config:
"""Pydantic configuration"""
@@ -60,9 +61,13 @@ class Service(BaseModel):
exclude={
},
exclude_none=True)
# override the default output from pydantic by calling `to_dict()` of entity
if self.entity:
_dict['entity'] = self.entity.to_dict()
# override the default output from pydantic by calling `to_dict()` of each item in usage (list)
_items = []
if self.usage:
for _item in self.usage:
if _item:
_items.append(_item.to_dict())
_dict['usage'] = _items
return _dict
@classmethod
@@ -79,10 +84,11 @@ class Service(BaseModel):
"service_name": obj.get("service_name"),
"service_type": obj.get("service_type"),
"endpoint_url": obj.get("endpoint_url"),
"status": obj.get("status"),
"other": obj.get("other"),
"entity_did": obj.get("entity_did"),
"entity": Entity.from_dict(obj.get("entity")) if obj.get("entity") is not None else None
"status": obj.get("status"),
"action": obj.get("action"),
"usage": [ServiceUsage.from_dict(_item) for _item in obj.get("usage")] if obj.get("usage") is not None else None
})
return _obj

24
pkgs/clan-cli/tests/openapi_client/models/service_create.py
View File

@@ -18,8 +18,9 @@ import re # noqa: F401
import json
from typing import Any, Dict
from pydantic import BaseModel, Field, StrictStr
from typing import Any, Dict, List
from pydantic import BaseModel, Field, StrictStr, conlist
from openapi_client.models.service_usage_create import ServiceUsageCreate
class ServiceCreate(BaseModel):
"""
@@ -29,10 +30,12 @@ class ServiceCreate(BaseModel):
service_name: StrictStr = Field(...)
service_type: StrictStr = Field(...)
endpoint_url: StrictStr = Field(...)
status: StrictStr = Field(...)
other: Dict[str, Any] = Field(...)
entity_did: StrictStr = Field(...)
__properties = ["uuid", "service_name", "service_type", "endpoint_url", "status", "other", "entity_did"]
status: Dict[str, Any] = Field(...)
action: Dict[str, Any] = Field(...)
usage: conlist(ServiceUsageCreate) = Field(...)
__properties = ["uuid", "service_name", "service_type", "endpoint_url", "other", "entity_did", "status", "action", "usage"]
class Config:
"""Pydantic configuration"""
@@ -58,6 +61,13 @@ class ServiceCreate(BaseModel):
exclude={
},
exclude_none=True)
# override the default output from pydantic by calling `to_dict()` of each item in usage (list)
_items = []
if self.usage:
for _item in self.usage:
if _item:
_items.append(_item.to_dict())
_dict['usage'] = _items
return _dict
@classmethod
@@ -74,9 +84,11 @@ class ServiceCreate(BaseModel):
"service_name": obj.get("service_name"),
"service_type": obj.get("service_type"),
"endpoint_url": obj.get("endpoint_url"),
"status": obj.get("status"),
"other": obj.get("other"),
"entity_did": obj.get("entity_did")
"entity_did": obj.get("entity_did"),
"status": obj.get("status"),
"action": obj.get("action"),
"usage": [ServiceUsageCreate.from_dict(_item) for _item in obj.get("usage")] if obj.get("usage") is not None else None
})
return _obj

73
pkgs/clan-cli/tests/openapi_client/models/service_usage.py Normal file
View File

@@ -0,0 +1,73 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
from __future__ import annotations
import pprint
import re # noqa: F401
import json
from pydantic import BaseModel, Field, StrictInt, StrictStr
class ServiceUsage(BaseModel):
"""
ServiceUsage
"""
times_consumed: StrictInt = Field(...)
consumer_entity_did: StrictStr = Field(...)
__properties = ["times_consumed", "consumer_entity_did"]
class Config:
"""Pydantic configuration"""
allow_population_by_field_name = True
validate_assignment = True
def to_str(self) -> str:
"""Returns the string representation of the model using alias"""
return pprint.pformat(self.dict(by_alias=True))
def to_json(self) -> str:
"""Returns the JSON representation of the model using alias"""
return json.dumps(self.to_dict())
@classmethod
def from_json(cls, json_str: str) -> ServiceUsage:
"""Create an instance of ServiceUsage from a JSON string"""
return cls.from_dict(json.loads(json_str))
def to_dict(self):
"""Returns the dictionary representation of the model using alias"""
_dict = self.dict(by_alias=True,
exclude={
},
exclude_none=True)
return _dict
@classmethod
def from_dict(cls, obj: dict) -> ServiceUsage:
"""Create an instance of ServiceUsage from a dict"""
if obj is None:
return None
if not isinstance(obj, dict):
return ServiceUsage.parse_obj(obj)
_obj = ServiceUsage.parse_obj({
"times_consumed": obj.get("times_consumed"),
"consumer_entity_did": obj.get("consumer_entity_did")
})
return _obj

73
pkgs/clan-cli/tests/openapi_client/models/service_usage_create.py Normal file
View File

@@ -0,0 +1,73 @@
# coding: utf-8
"""
FastAPI
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
The version of the OpenAPI document: 0.1.0
Generated by OpenAPI Generator (https://openapi-generator.tech)
Do not edit the class manually.
""" # noqa: E501
from __future__ import annotations
import pprint
import re # noqa: F401
import json
from pydantic import BaseModel, Field, StrictInt, StrictStr
class ServiceUsageCreate(BaseModel):
"""
ServiceUsageCreate
"""
times_consumed: StrictInt = Field(...)
consumer_entity_did: StrictStr = Field(...)
__properties = ["times_consumed", "consumer_entity_did"]
class Config:
"""Pydantic configuration"""
allow_population_by_field_name = True
validate_assignment = True
def to_str(self) -> str:
"""Returns the string representation of the model using alias"""
return pprint.pformat(self.dict(by_alias=True))
def to_json(self) -> str:
"""Returns the JSON representation of the model using alias"""
return json.dumps(self.to_dict())
@classmethod
def from_json(cls, json_str: str) -> ServiceUsageCreate:
"""Create an instance of ServiceUsageCreate from a JSON string"""
return cls.from_dict(json.loads(json_str))
def to_dict(self):
"""Returns the dictionary representation of the model using alias"""
_dict = self.dict(by_alias=True,
exclude={
},
exclude_none=True)
return _dict
@classmethod
def from_dict(cls, obj: dict) -> ServiceUsageCreate:
"""Create an instance of ServiceUsageCreate from a dict"""
if obj is None:
return None
if not isinstance(obj, dict):
return ServiceUsageCreate.parse_obj(obj)
_obj = ServiceUsageCreate.parse_obj({
"times_consumed": obj.get("times_consumed"),
"consumer_entity_did": obj.get("consumer_entity_did")
})
return _obj

26
pkgs/clan-cli/tests/test_db_api.py
View File

@@ -26,7 +26,7 @@ random.seed(42)
host = config.host
port_dlg = config.port_dlg
port_ap = config.port_ap
port_client_base = config.port_client_base
port_client_base = config._port_client_base
num_uuids = 100
uuids = [str(uuid.UUID(int=random.getrandbits(128))) for i in range(num_uuids)]
@@ -38,7 +38,7 @@ def test_health(api_client: ApiClient) -> None:
assert res.status == Status.ONLINE
def create_entities(num: int = 10, role: str = "entity") -> list[EntityCreate]:
def create_entities(num: int = 5, role: str = "entity") -> list[EntityCreate]:
res = []
for i in range(num):
en = EntityCreate(
@@ -79,10 +79,23 @@ def create_service(idx: int, entity: Entity) -> ServiceCreate:
uuid=uuids[idx],
service_name=f"Carlos Printing{idx}",
service_type="3D Printing",
endpoint_url=f"{entity.ip}/v1/print_daemon{idx}",
status="unknown",
other={"action": ["register", "deregister", "delete", "create"]},
endpoint_url=f"http://{entity.ip}/v1/print_daemon{idx}",
status={"data": ["draft", "registered"]},
other={},
action={
"data": [
{
"name": "register",
"endpoint": f"http://{entity.ip}/v1/print_daemon{idx}/register",
},
{
"name": "deregister",
"endpoint": f"http://{entity.ip}/v1/print_daemon{idx}/deregister",
},
]
},
entity_did=entity.did,
usage=[{"times_consumed": 2, "consumer_entity_did": "did:sov:test:120"}],
)
return se
@@ -101,8 +114,7 @@ def test_create_services(api_client: ApiClient) -> None:
sapi = ServicesApi(api_client=api_client)
eapi = EntitiesApi(api_client=api_client)
for midx, entity in enumerate(eapi.get_all_entities()):
for idx in range(4):
service_obj = create_service(idx + 4 * midx, entity)
service_obj = create_service(midx, entity)
service = sapi.create_service(service_obj)
assert service.uuid == service_obj.uuid

4
pkgs/ui/nix/ui-assets.nix
View File

@@ -1,5 +1,5 @@
{ fetchzip }:
fetchzip {
url = "https://gitea.gchq.icu/api/packages/IoSL/generic/IoSL-service-aware-frontend/04h6w20fgq1zd4qzqm1rqkyk1s3mxnra1088icdrshsdm29x81xa/assets.tar.gz";
sha256 = "04h6w20fgq1zd4qzqm1rqkyk1s3mxnra1088icdrshsdm29x81xa";
url = "https://gitea.gchq.icu/api/packages/IoSL/generic/IoSL-service-aware-frontend/0pbv23wd89x487ik4hbxgyghqvj95cb42sq44vzki3yghfdc5miw/assets.tar.gz";
sha256 = "0pbv23wd89x487ik4hbxgyghqvj95cb42sq44vzki3yghfdc5miw";
}

49
pkgs/ui/src/components/error_boundary.tsx Normal file
View File

@@ -0,0 +1,49 @@
import React from "react";
interface Props {
children: React.ReactNode;
}
interface State {
hasError: boolean;
}
class ErrorBoundary extends React.Component<Props, State> {
constructor(props: Props) {
super(props);
// Define a state variable to track whether is an error or not
this.state = { hasError: false };
}
static getDerivedStateFromError(error: Error): State {
console.error(error);
// Update state so the next render will show the fallback UI
return { hasError: true };
}
componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void {
// You can use your own error logging service here
console.log({ error, errorInfo });
}
render(): React.ReactNode {
// Check if the error is thrown
if (this.state.hasError) {
// You can render any custom fallback UI
return (
<div>
<h2>Oops, there is an error!</h2>
<button
type="button"
onClick={() => this.setState({ hasError: false })}
>
Try again?
</button>
</div>
);
}
// Return children components in case of no error
return this.props.children;
}
}
export default ErrorBoundary;

12
pkgs/ui/src/components/sidebar/index.tsx
View File

@@ -45,6 +45,18 @@ const menuEntityEntries: MenuEntry[] = [
to: "/client/C2",
disabled: false,
},
{
icon: <PersonIcon />,
label: "C3",
to: "/client/C3",
disabled: false,
},
{
icon: <PersonIcon />,
label: "C4",
to: "/client/C4",
disabled: false,
},
];
const menuEntries: MenuEntry[] = [

7
pkgs/ui/src/components/table/index.tsx
View File

@@ -10,6 +10,7 @@ import { NoDataOverlay } from "@/components/noDataOverlay";
import { StyledTableCell, StyledTableRow } from "./style";
import { ICustomTable, CustomTableConfiguration } from "@/types";
import { Checkbox, Skeleton } from "@mui/material";
import ErrorBoundary from "@/components/error_boundary";
const CustomTable = ({ configuration, data, loading, tkey }: ICustomTable) => {
if (loading)
@@ -35,11 +36,15 @@ const CustomTable = ({ configuration, data, loading, tkey }: ICustomTable) => {
// cover use case if we want to render a component
if (render) renderedValue = render(value);
if (typeof renderedValue === "object" && render === undefined) {
console.warn("Missing render function for column " + cellKey);
}
return (
<ErrorBoundary>
<StyledTableCell key={cellKey} align="left">
{renderedValue}
</StyledTableCell>
</ErrorBoundary>
);
};

17
pkgs/ui/src/config/client_1/index.tsx
View File

@@ -54,19 +54,28 @@ export const ServiceTableConfig = [
{
key: "status",
label: "Status",
render: (value: any) => {
let renderedValue: any = "";
if (Array.isArray(value.data)) {
renderedValue = value.data.join(", ");
} else {
console.error("Status is not an array", value);
}
return renderedValue;
},
},
{
key: "other",
key: "action",
label: "Action",
render: (value: any) => {
let renderedValue: any = "";
console.log("value", value.data);
if (typeof value === "object")
renderedValue = (
<>
{value.action.map((actionType: string) => (
{value.data.map((actionType: any) => (
<>
<code>{actionType}</code>
<br />
<Button>{actionType.name}</Button>
</>
))}
</>

77
pkgs/ui/src/config/client_2/index.tsx
View File

@@ -1,77 +0,0 @@
import { Button } from "@mui/material";
export const Client2ConsumerTableConfig = [
{
key: "service_name",
label: "Service name",
},
{
key: "service_type",
label: "Service Type",
},
{
key: "endpoint_url",
label: "End Point",
render: () => {
return (
<Button disabled variant="outlined">
Consume
</Button>
);
},
},
// {
// key: "entity",
// label: "Entity",
// },
{
key: "entity_did",
label: "Entity DID",
},
// {
// key: "network",
// label: "Network",
// },
];
export const Client2ProducerTableConfig = [
{
key: "service_name",
label: "Service name",
},
{
key: "service_type",
label: "Service Type",
},
{
key: "endpoint_url",
label: "End Point",
},
{
key: "entity_did",
label: "Entity DID",
},
{
key: "status",
label: "Status",
},
{
key: "other",
label: "Action",
render: (value: any) => {
let renderedValue: any = "";
if (typeof value === "object")
renderedValue = (
<>
{value.action.map((actionType: string) => (
<>
<code>{actionType}</code>
<br />
</>
))}
</>
);
return renderedValue;
},
},
];