Merge pull request #32 from didx-xyz/YOMA-257/extra_admin_APIs

Complete coverage of ACA-Py Swagger API

Author: wip-abramson

aries_cloudcontroller/aries_controller_base.py

@@ -19,6 +19,7 @@
 from .controllers.oob import OOBController
 from .controllers.action_menu import ActionMenuController
 from .controllers.revocation import RevocationController
+from .controllers.didexchange import DidExchangeController
 
 import logging
 
@@ -82,6 +83,8 @@ def __post_init__(self):
 
         self.definitions = DefinitionsController(self.admin_url, self.client_session)
 
+        self.didexchange = DidExchangeController(self.admin_url, self.client_session)
+
         self.issuer = IssuerController(
             self.admin_url,
             self.client_session,
@@ -155,7 +158,7 @@ def add_listener(self, listener):
             "topic":"topicname" key-value pairs
         """
         try:
-            pub_topic_path = listener['topic']
+            pub_topic_path = listener["topic"]
             logger.INFO("Subscribing too: " + pub_topic_path)
             pub.subscribe(listener["handler"], pub_topic_path)
             logger.debug("Lister added for topic : ", pub_topic_path)

aries_cloudcontroller/controllers/connections.py

@@ -160,6 +160,10 @@ async def accept_request(self, connection_id: str, my_endpoint: str = None):
             # TODO create proper error classes
             raise Exception("The connection is not in the request state")
 
+    async def get_remote_endpoints(self, connection_id: str):
+        response = await self.admin_GET(f"/connections/{connection_id}/endpoints")
+        return response
+
     async def establish_inbound(self, connection_id: str, router_conn_id: str):
         response = await self.admin_POST(
             f"/connections/{connection_id}/establish-inbound/{router_conn_id}"
@@ -231,3 +235,31 @@ async def is_active(self, connection_id):
             logger.error(f"Connection {connection_id} not active")
             raise Exception("Connection must be active to send a credential")
         return
+
+    async def get_connection_metadata(self, connection_id: str, key: str = None):
+        if key:
+            response = await self.admin_GET(
+                f"/connections/{connection_id}/metadata?key={key}"
+            )
+        else:
+            response = await self.admin_GET(f"/connections/{connection_id}/metadata")
+        return response
+
+    async def set_connection_metadata(self, connection_id: str, metadata: dict = None):
+        if metadata:
+            metadata = {"metadata": metadata}
+            response = await self.admin_POST(
+                f"/connections/{connection_id}/metadata", data=metadata
+            )
+        else:
+            response = await self.admin_POST(f"/connections/{connection_id}/metadata")
+        return response
+
+    async def start_introduction(
+        self, connection_id: str, target_connection_id: str, message: str = None
+    ):
+        route = f"/connections/{connection_id}/start-introduction?target_connection_id={target_connection_id}"
+        if message:
+            route += f"&message={message}"
+        response = self.admin_POST(route)
+        return response

aries_cloudcontroller/controllers/didexchange.py

@@ -0,0 +1,77 @@
+from .base import BaseController
+from aiohttp import ClientSession
+import logging
+
+logger = logging.getLogger("aries_controller.didexchange")
+
+
+class DidExchangeController(BaseController):
+    def __init__(self, admin_url: str, client_session: ClientSession):
+        super().__init__(admin_url, client_session)
+
+    async def create_request_against_invite(
+        self,
+        their_pub_id: str,
+        mediation_id: str = None,
+        my_endpoint: str = None,
+        my_label: str = None,
+    ):
+        params = {}
+        if mediation_id:
+            params["mediation_id"] = mediation_id
+        if my_endpoint:
+            params["my_endpoint"] = my_endpoint
+        if my_label:
+            params["my_label"] = my_label
+        response = self.admin_POST(f"/didexchange/create-request", params=params)
+        return response
+
+    async def receive_request_against_invite(
+        self,
+        body: {} = None,
+        alias: str = None,
+        auto_accept: bool = None,
+        mediation_id: str = None,
+        my_endpoint: str = None,
+    ):
+        params = {}
+        if alias:
+            params["alias"] = alias
+        if auto_accept:
+            params["auto_accept"] = auto_accept
+        if mediation_id:
+            params["mediation_id"] = mediation_id
+        if my_endpoint:
+            params["my_endpoint"] = my_endpoint
+        if body:
+            response = self.admin_POST(
+                f"/didexchange/receive-request", body=body, params=params
+            )
+        else:
+            response = self.admin_POST(f"/didexchange/receive-request", params=params)
+        return response
+
+    async def accept_invitation(
+        self, connection_id: str, my_endpoint: str = None, my_label: str = None
+    ):
+        params = {}
+        if my_endpoint:
+            params["my_endpoint"] = my_endpoint
+        if my_label:
+            params["my_label"] = my_label
+        response = self.admin_POST(
+            f"/didexchange/{connection_id}/accept-invitation", params=params
+        )
+        return response
+
+    async def accept_stored_invite(
+        self, connection_id: str, mediation_id: str = None, my_endpoint: str = None
+    ):
+        params = {}
+        if mediation_id:
+            params["mediation_id"] = mediation_id
+        if my_endpoint:
+            params["my_endpoint"] = my_endpoint
+        response = self.admin_POST(
+            f"/didexchange/{connection_id}/accept-request", params=params
+        )

aries_cloudcontroller/controllers/issuer_v2.py

@@ -0,0 +1,204 @@
+from .base import BaseController
+from aiohttp import ClientSession
+import logging
+from ..helpers.utils import extract_did, get_schema_details
+
+logger = logging.getLogger("aries_controller.issuer2")
+
+CRED_PREVIEW = (
+    "did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/issue-credential/2.0/credential-preview"
+)
+
+
+class IssuerV2Controller(BaseController):
+    def __init__(
+        self,
+        admin_url: str,
+        client_session: ClientSession,
+        connection_controller,
+        wallet_controller,
+        definition_controller,
+    ):
+        super().__init__(admin_url, client_session)
+        self.base_url = "/issue-credential-2.0"
+        self.connections = connection_controller
+        self.wallet = wallet_controller
+        self.definitions = definition_controller
+
+    # Fetch all credential exchange records
+    async def get_records(
+        self,
+        connection_id: str = None,
+        role: str = None,
+        state: str = None,
+        thread_id: str = None,
+    ):
+        params = {}
+        if connection_id:
+            params["connection_id"] = connection_id
+        if role in ["issuer", "holder"]:
+            params["role"] = role
+        if state in [
+            "proposal-sent",
+            "proposal-received",
+            "offer-sent",
+            "offer-received",
+            "request-sent",
+            "request-received",
+            "credential-issued",
+            "credential-received",
+            "done",
+        ]:
+            params["state"] = state
+        if thread_id:
+            params["thread_id"] = thread_id
+        return await self.admin_GET(f"{self.base_url}/records", params=params)
+
+    async def get_record_by_id(self, cred_ex_id):
+        return await self.admin_GET(f"{self.base_url}/records/{cred_ex_id}")
+
+    async def create_credential(self, body):
+        return await self.admin_POST(f"{self.base_url}/create", json_data=body)
+
+    # Send holder a credential, automating the entire flow
+    async def send_credential(
+        self,
+        connection_id,
+        schema_id,
+        cred_def_id,
+        attributes,
+        comment: str = "",
+        auto_remove: bool = True,
+        trace: bool = False,
+    ):
+
+        body = await self.create_credential_body(
+            connection_id,
+            schema_id,
+            cred_def_id,
+            attributes,
+            comment,
+            auto_remove,
+            trace,
+        )
+        return await self.admin_POST(f"{self.base_url}/send", json_data=body)
+
+    # Send Issuer a credential proposal
+    async def send_proposal(
+        self,
+        connection_id,
+        schema_id,
+        cred_def_id,
+        attributes,
+        comment: str = "",
+        auto_remove: bool = True,
+        trace: bool = False,
+    ):
+
+        body = await self.create_credential_body(
+            connection_id,
+            schema_id,
+            cred_def_id,
+            attributes,
+            comment,
+            auto_remove,
+            trace,
+        )
+        return await self.admin_POST(f"{self.base_url}/send-proposal", json_data=body)
+
+    async def send_offer(
+        self,
+        connection_id,
+        cred_def_id,
+        attributes,
+        comment: str = "",
+        auto_issue: bool = True,
+        auto_remove: bool = True,
+        trace: bool = False,
+    ):
+        await self.connections.is_active(connection_id)
+        offer_body = {
+            "cred_def_id": cred_def_id,
+            "auto_remove": auto_remove,
+            "trace": trace,
+            "comment": comment,
+            "auto_issue": auto_issue,
+            "credential_preview": {"@type": CRED_PREVIEW, "attributes": attributes},
+            "connection_id": connection_id,
+        }
+        return await self.admin_POST(
+            f"{self.base_url}/send-offer", json_data=offer_body
+        )
+
+    # Send holder a credential offer in reference to a proposal with preview
+    async def send_offer_for_record(self, cred_ex_id):
+        return await self.admin_POST(f"{self.base_url}/records/{cred_ex_id}/send-offer")
+
+    # Send issuer a credential request
+    async def send_request_for_record(self, cred_ex_id):
+        return await self.admin_POST(
+            f"{self.base_url}/records/{cred_ex_id}/send-request"
+        )
+
+    # Send holder a credential
+    async def issue_credential(self, cred_ex_id: str, comment: str = None):
+        body = {}
+        if comment:
+            body = {
+                "comment": comment,
+            }
+        return await self.admin_POST(
+            f"{self.base_url}/records/{cred_ex_id}/issue", json_data=body
+        )
+
+    # Store a received credential
+    async def store_credential(self, cred_ex_id: str, credential_id: str = None):
+        body = {}
+        if credential_id:
+            body["credential_id"] = credential_id
+        return await self.admin_POST(
+            f"{self.base_url}/records/{cred_ex_id}/store", json_data=body
+        )
+
+    # Remove an existing credential exchange record
+    async def remove_record(self, cred_ex_id):
+        return await self.admin_DELETE(f"{self.base_url}/records/{cred_ex_id}")
+
+    # Send a problem report for a credential exchange
+    async def problem_report(self, cred_ex_id, explanation: str):
+        body = {"explain_ltxt": explanation}
+
+        return await self.admin_POST(
+            f"{self.base_url}/records/{cred_ex_id}/problem-report", json_data=body
+        )
+
+    # Used for both send and send-proposal bodies
+    async def create_credential_body(
+        self,
+        connection_id,
+        schema_id,
+        cred_def_id,
+        attributes,
+        comment: str = "",
+        auto_remove: bool = True,
+        trace: bool = False,
+    ):
+        # raises error if connection not active
+        await self.connections.is_active(connection_id)
+
+        schema_details = get_schema_details(schema_id)
+
+        issuer_did = extract_did(cred_def_id)
+
+        body = {
+            "issuer_did": issuer_did,
+            "auto_remove": auto_remove,
+            "credential_proposal": {"@type": CRED_PREVIEW, "attributes": attributes},
+            "connection_id": connection_id,
+            "trace": trace,
+            "comment": comment,
+            "cred_def_id": cred_def_id,
+        }
+
+        credential_body = {**body, **schema_details}
+        return credential_body

aries_cloudcontroller/controllers/ledger.py

@@ -37,4 +37,5 @@ async def get_taa(self):
     async def accept_taa(self, data):
         return await self.admin_POST(f"{self.base_url}/taa/accept", json_data=data)
 
-    # TODO PATCH rotate key pair
+    async def rotate_pub_key_pair(self):
+        return await self.admin_PATCH(f"{self.base_url}/rotate-public-did-keypair")

aries_cloudcontroller/controllers/server.py

@@ -31,4 +31,5 @@ async def get_features(self, query: str = None):
 
         return await self.admin_GET("/features", params=params)
 
-    ## TODO implement shutdown. Should this be a POST?
+    async def shutdown(self):
+        return await self.admin_GET("/shutdown")

aries_cloudcontroller/controllers/wallet.py

@@ -16,6 +16,11 @@ async def get_dids(self):
     async def create_did(self):
         return await self.admin_POST(f"{self.base_url}/did/create")
 
+    async def rotate_pub_key_pair(self, did: str):
+        return await self.admin_PATCH(
+            f"{self.base_url}/did/local/rotate-keypair?did={did}"
+        )
+
     async def get_public_did(self):
         return await self.admin_GET(f"{self.base_url}/did/public")
 
@@ -32,5 +37,3 @@ async def set_did_endpoint(self, did, endpoint, endpoint_type):
         return await self.admin_POST(
             f"{self.base_url}/set-did-endpoint", json_data=body
         )
-
-    ## TODO Patch rotate-keypair