issue license WIP

src/components/AgentAuthority/ColumnLeft/ColumnLeftWrap/ColumnLeftWrap.js

@@ -5,6 +5,37 @@
  */
 
 export default function ColumnLeftWrap() {
+  // const setStoreDataFn = (resData) => {
+  //   setRecords(() => {
+  //     const verifiedProofs = resData.filter(
+  //       (record) => record.state === 'done'
+  //     )
+  //     const presentations = resData.filter(
+  //       (record) => record.state === 'presentation-received'
+  //     )
+  //     verifiedProofs.forEach((verified) => {
+  //       const presentation = verified.by_format.pres.indy.requested_proof
+  //       // console.log(presentation)
+  //       // startFetchHandlerCredOffer(
+  //       //   origin,
+  //       //   verified.connection_id,
+  //       //   licenseCredDefId,
+  //       //   presentation.revealed_attrs['0_id_uuid'].raw,
+  //       //   presentation.revealed_attrs['0_type_uuid'].raw,
+  //       //   'expiry',
+  //       //   setStatusIssueCred,
+  //       //   setDataIssueCred
+  //       // )
+  //     })
+  //     return resData
+  //   })
+  // }
+  //const intervalIdFetch = startGetRecordsHandler(origin, setStoreDataFn)
+  // if (statusRecordEvents !== 'started') clearInterval(intervalIdFetch)
+  // return function clear() {
+  //   return clearInterval(intervalIdFetch)
+  //}
+
   return (
     <>
       <div className="col-md-6">

src/components/AgentAuthority/ContentWrap/ContentWrap.js

@@ -6,9 +6,16 @@
 import ColumnLeftWrap from '../ColumnLeft/ColumnLeftWrap'
 import ColumnRightWrap from '../ColumnRight/ColumnRightWrap'
 
+import ProofRequest from '../RequestProof'
+import Verify from '../Verify'
+import IssueLicense from '../IssueLicense'
+
 export default function ContentWrap({ origin }) {
   return (
     <>
+      <ProofRequest origin={origin} />
+      <Verify origin={origin} />
+      <IssueLicense origin={origin} />
       <ColumnLeftWrap origin={origin} />
       <ColumnRightWrap origin={origin} />
     </>

src/components/AgentAuthority/IssueLicense/IssueLicense.js

@@ -0,0 +1,60 @@
+/**
+ * Listens for verified presentation proofs and issues a license
+ */
+import { useEffect, useState } from 'react'
+import LicenseCredDef from '../LicenseCredDef'
+import useGetLoopedPresentProofRecords from '../../../interface/hooks/use-get-looped-present-proof-records'
+import usePostIssueCredentialSendOffer from '../../../interface/hooks/use-post-issue-credential-send-offer'
+import Error from '../../Common/Misc/Error'
+
+export default function IssueLicense({ origin }) {
+  const [licenseCredDefId, setLicenseCredDefId] = useState('')
+  const [statusRecords, errorRecords, startGetRecordsHandler] =
+    useGetLoopedPresentProofRecords()
+  const [errorIssueCred, startFetchHandlerCredOffer] =
+    usePostIssueCredentialSendOffer()
+
+  useEffect(() => {
+    const sendCredOffers = (verifiedProofs) => {
+      verifiedProofs.forEach((verified) => {
+        const presentation = verified.by_format.pres.indy.requested_proof
+        console.log(presentation.predicates['0_expiration_dateint_GE_uui'])
+        startFetchHandlerCredOffer(
+          origin,
+          verified.connection_id,
+          licenseCredDefId,
+          presentation.revealed_attrs['0_id_uuid'].raw,
+          presentation.revealed_attrs['0_type_uuid'].raw,
+          'expiry',
+          () => {},
+          () => {}
+        )
+      })
+    }
+    const intervalIdFetch = startGetRecordsHandler(
+      origin,
+      'done',
+      sendCredOffers
+    )
+    if (statusRecords !== 'started') clearInterval(intervalIdFetch)
+    return function clear() {
+      return clearInterval(intervalIdFetch)
+    }
+  }, [
+    origin,
+    statusRecords,
+    startFetchHandlerCredOffer,
+    startGetRecordsHandler,
+    licenseCredDefId,
+  ])
+
+  return (
+    <>
+      <LicenseCredDef
+        origin={origin}
+        setLicenseCredDefId={setLicenseCredDefId}
+      />
+      <Error errors={[errorIssueCred, errorRecords]} />
+    </>
+  )
+}

src/components/AgentAuthority/IssueLicense/index.js

@@ -0,0 +1 @@
+export { default } from './IssueLicense'

src/components/AgentAuthority/LicenseCredDef/LicenseCredDef.js

@@ -0,0 +1,51 @@
+/**
+ * Get or create the credential definitions for the
+ * license issued by the authority
+ */
+import { useEffect } from 'react'
+
+import { AUTHORITY_LABEL, LICENSE_SCHEMA_NAME } from '../../../utils/env.js'
+import useGetCredDefinitionsCreated from '../../../interface/hooks/use-get-cred-definitions-created'
+import usePostSchemas from '../../../interface/hooks/use-post-schemas'
+import usePostCredentialDefinitions from '../../../interface/hooks/use-post-credential-definitions'
+import Error from '../../Common/Misc/Error'
+
+export default function LicenseCredDef({ origin, setLicenseCredDefId }) {
+  const [errorDefinitionsCreated, startFetchHandlerDefinitionsCreated] =
+    useGetCredDefinitionsCreated()
+
+  const [errorPostSchema, startPostSchema] = usePostSchemas()
+  const [errorPostCredDefs, startPostCredDef] = usePostCredentialDefinitions()
+
+  useEffect(() => {
+    startFetchHandlerDefinitionsCreated(origin, (credDefIds) => {
+      const licenseCredDefId = credDefIds.find((credDefId) =>
+        credDefId.includes(LICENSE_SCHEMA_NAME)
+      )
+      if (licenseCredDefId) {
+        setLicenseCredDefId(licenseCredDefId)
+      } else {
+        startPostSchema(origin, LICENSE_SCHEMA_NAME, (schemaId) => {
+          startPostCredDef(
+            origin,
+            schemaId,
+            AUTHORITY_LABEL,
+            setLicenseCredDefId
+          )
+        })
+      }
+    })
+  }, [
+    origin,
+    startFetchHandlerDefinitionsCreated,
+    startPostSchema,
+    startPostCredDef,
+    setLicenseCredDefId,
+  ])
+
+  return (
+    <Error
+      errors={[errorDefinitionsCreated, errorPostSchema, errorPostCredDefs]}
+    />
+  )
+}

src/components/AgentAuthority/LicenseCredDef/index.js

@@ -0,0 +1 @@
+export { default } from './LicenseCredDef'

src/components/AgentAuthority/RequestProof/RequestProof.js

@@ -0,0 +1,57 @@
+/**
+ * Listens for presentation proof proposals and sends requests in response, then deletes the original proposal
+ */
+import { useEffect } from 'react'
+import useGetLoopedPresentProofRecords from '../../../interface/hooks/use-get-looped-present-proof-records'
+import useDeleteRecord from '../../../interface/hooks/use-delete-record'
+import usePostPresentProofSendRequest from '../../../interface/hooks/use-post-present-proof-send-request'
+import Error from '../../Common/Misc/Error'
+
+export default function RequestProof({ origin }) {
+  const [statusRecords, errorRecords, startGetRecordsHandler] =
+    useGetLoopedPresentProofRecords()
+  const [errorRequest, startFetchHandlerRequest] =
+    usePostPresentProofSendRequest()
+  const [errorDelete, startDeleteHandler] = useDeleteRecord()
+
+  useEffect(() => {
+    const sendRequests = (proposals) => {
+      console.log(proposals)
+      proposals.forEach((proposal) => {
+        startFetchHandlerRequest({
+          origin,
+          comment: proposal.pres_proposal.comment,
+          connectionId: proposal.connection_id,
+          proposal: proposal.by_format.pres_proposal.indy,
+          validity: new Date().toISOString().split('T')[0],
+          setStatus: () => {},
+          setStoreData: () => {
+            startDeleteHandler(
+              origin,
+              proposal.pres_ex_id,
+              () => {},
+              () => {}
+            )
+          },
+        })
+      })
+    }
+    const intervalIdFetch = startGetRecordsHandler(
+      origin,
+      'proposal-received',
+      sendRequests
+    )
+    if (statusRecords !== 'started') clearInterval(intervalIdFetch)
+    return function clear() {
+      return clearInterval(intervalIdFetch)
+    }
+  }, [
+    origin,
+    statusRecords,
+    startFetchHandlerRequest,
+    startGetRecordsHandler,
+    startDeleteHandler,
+  ])
+
+  return <Error errors={[errorRecords, errorRequest, errorDelete]} />
+}

src/components/AgentAuthority/RequestProof/index.js

@@ -0,0 +1 @@
+export { default } from './RequestProof'

src/components/AgentAuthority/Verify/Verify.js

@@ -0,0 +1,38 @@
+/**
+ * Listens for presentation proofs and verifies them
+ */
+import { useEffect } from 'react'
+import useGetLoopedPresentProofRecords from '../../../interface/hooks/use-get-looped-present-proof-records'
+import usePostPresentProofRecordsVerifyPresentation from '../../../interface/hooks/use-post-present-proof-records-verify-presentation'
+import Error from '../../Common/Misc/Error'
+
+export default function Verify({ origin }) {
+  const [statusRecords, errorRecords, startGetRecordsHandler] =
+    useGetLoopedPresentProofRecords()
+  const [errorVerify, startFetchHandlerVerify] =
+    usePostPresentProofRecordsVerifyPresentation()
+
+  useEffect(() => {
+    const sendVerifications = (presentations) => {
+      presentations.forEach((presentation) => {
+        startFetchHandlerVerify(
+          origin,
+          presentation.pres_ex_id,
+          () => {},
+          () => {}
+        )
+      })
+    }
+    const intervalIdFetch = startGetRecordsHandler(
+      origin,
+      'presentation-received',
+      sendVerifications
+    )
+    if (statusRecords !== 'started') clearInterval(intervalIdFetch)
+    return function clear() {
+      return clearInterval(intervalIdFetch)
+    }
+  }, [origin, statusRecords, startFetchHandlerVerify, startGetRecordsHandler])
+
+  return <Error errors={[errorRecords, errorVerify]} />
+}

src/components/AgentAuthority/Verify/index.js

@@ -0,0 +1 @@
+export { default } from './Verify'

src/components/Common/Misc/Error/Error.js

@@ -0,0 +1,23 @@
+export default function Error({ errors }) {
+  return (
+    <>
+      <div
+        className={`${
+          errors.some((error) => error != undefined) ? 'd-block' : 'd-none'
+        }`}
+        style={{
+          position: 'fixed',
+          width: '10%',
+          height: '10%',
+          inset: '0px',
+          backgroundColor: 'rgba(0, 0, 0, 0.5)',
+          zIndex: 100,
+        }}
+      >
+        <div className="text-light m-2 p-2">
+          <small>{errors.toString()}</small>
+        </div>
+      </div>
+    </>
+  )
+}

src/components/Common/Misc/Error/index.js

@@ -0,0 +1 @@
+export { default } from './Error'

src/interface/hooks/use-delete-record.js

@@ -0,0 +1,26 @@
+/**
+ * It returns a function that can be used to delete a connection.
+ */
+import { useCallback, useState } from 'react'
+import del from '../api/helpers/del'
+
+export default function useDeleteRecord() {
+  const path = '/present-proof-2.0/records/'
+  const transformData = (retrievedData) => retrievedData
+  const [error, setError] = useState(null)
+  const onStartFetch = useCallback(
+    (origin, presExId, setStatus, setStoreData) => {
+      del(
+        origin,
+        path + presExId,
+        {},
+        setStatus,
+        setError,
+        setStoreData,
+        transformData
+      )
+    },
+    []
+  )
+  return [error, onStartFetch]
+}

src/interface/hooks/use-get-cred-definitions-created.js

@@ -0,0 +1,19 @@
+/**
+ * This function returns a function that, will fetch the credential
+ * definitions created by the user
+ */
+import { useCallback, useState } from 'react'
+import get from '../api/helpers/get'
+
+export default function useGetCredDefinitionsCreated() {
+  const path = '/credential-definitions/created'
+  const transformData = (retrievedData) =>
+    retrievedData.credential_definition_ids
+
+  const [error, setError] = useState(null)
+
+  const onStartFetch = useCallback((fetchOrigin, setStoreData) => {
+    get(fetchOrigin, path, {}, () => {}, setError, setStoreData, transformData)
+  }, [])
+  return [error, onStartFetch]
+}

src/interface/hooks/use-get-looped-present-proof-records.js

@@ -0,0 +1,28 @@
+/**
+ * This function returns continuously the present proof records
+ */
+import { useCallback, useState } from 'react'
+import getLooped from '../api/helpers/get-looped'
+export default function useGetLoopedPresentProofRecords() {
+  const path = '/present-proof-2.0/records'
+  const transformData = (retData) => retData.results
+  const statusOptions = ['started', 'error', 'stopped']
+  const [status, setStatus] = useState(statusOptions[0])
+  const [error, setError] = useState(null)
+  const onStartFetch = useCallback((origin, state = null, setStoreData) => {
+    const params = state ? `state=${state}` : {}
+    const intervalId = setInterval(() => {
+      getLooped(
+        origin,
+        path,
+        params,
+        setStatus,
+        setError,
+        setStoreData,
+        transformData
+      )
+    }, 3000)
+    return intervalId
+  }, [])
+  return [status, error, onStartFetch]
+}