@verii/server-credentialagent 1.0.0-pre.1752076816

package/src/controllers/operator/tenants/_tenantId/controller-v0.8.js

@@ -0,0 +1,221 @@
+/**
+ * Copyright 2023 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const {
+  flatMap,
+  flow,
+  isEmpty,
+  map,
+  uniq,
+  omitBy,
+  isNil,
+} = require('lodash/fp');
+const newError = require('http-errors');
+const {
+  resolveDid,
+  getOrganizationVerifiedProfile,
+} = require('@verii/common-fetchers');
+
+const {
+  buildServiceIds,
+  extractService,
+  validateServiceIds,
+  buildCleanPiiFilter,
+} = require('../../../../entities');
+
+const tenantController = async (fastify) => {
+  const getOrgServiceTypes = (didDoc, serviceIds) => {
+    const services = map(
+      (serviceId) => extractService(serviceId)(didDoc),
+      serviceIds
+    );
+
+    const serviceTypes = flow(map('type'), uniq)(services);
+    const credentialTypes = flatMap('credentialTypes', services);
+    return { serviceTypes, credentialTypes };
+  };
+
+  const getOrgInfo = async (tenantDid, didDoc, serviceIds, context) => {
+    const { credentialSubject: orgProfile } =
+      await getOrganizationVerifiedProfile(tenantDid, context);
+    const { name, logo } = orgProfile;
+
+    const { serviceTypes, credentialTypes } = getOrgServiceTypes(
+      didDoc,
+      serviceIds
+    );
+
+    return {
+      name,
+      logo,
+      services: serviceTypes,
+      credentialTypesIssued: credentialTypes,
+    };
+  };
+
+  fastify.put(
+    '/',
+    {
+      schema: fastify.autoSchema({
+        body: {
+          $ref: 'https://velocitycareerlabs.io/modify-tenant-v0.8.schema.json',
+        },
+        response: {
+          200: {
+            $ref: 'immutable-entity#',
+          },
+        },
+      }),
+    },
+    async (req) => {
+      const { tenant, body } = req;
+      const { serviceIds, webhookUrl, webhookAuth } = body;
+      const didDoc = await resolveDid(tenant.did, req);
+
+      if (isEmpty(didDoc)) {
+        throw new newError.NotFound(
+          `Organization with DID "${didDoc.id}" was not found on the blockchain`
+        );
+      }
+
+      validateServiceIds(didDoc, serviceIds);
+
+      const updatedTenant = omitBy(isNil, {
+        ...tenant,
+        serviceIds,
+        webhookUrl,
+        webhookAuth,
+      });
+
+      return req.repos.tenants.update(tenant._id, updatedTenant);
+    }
+  );
+
+  fastify.get(
+    '/',
+    {
+      schema: fastify.autoSchema({
+        query: {
+          type: 'object',
+          properties: {
+            fullProfile: { type: 'boolean' },
+          },
+        },
+        response: {
+          200: {
+            $ref: 'https://velocitycareerlabs.io/tenant-v0.8.schema.json#',
+          },
+        },
+      }),
+    },
+    async (req) => {
+      const { tenant } = req;
+      return {
+        ...tenant,
+        serviceIds: buildServiceIds(tenant),
+        ...(req.query.fullProfile
+          ? await getOrgInfo(
+              tenant.did,
+              await resolveDid(tenant.did, req),
+              buildServiceIds(tenant),
+              req
+            )
+          : {}),
+      };
+    }
+  );
+
+  fastify.delete(
+    '/',
+    {
+      schema: fastify.autoSchema({
+        response: {
+          204: { type: 'null', description: 'No Content' },
+        },
+      }),
+    },
+    async ({ repos, tenant }, reply) => {
+      await repos.disclosures.collection().deleteMany({ tenantId: tenant._id });
+      await repos.exchanges.collection().deleteMany({ tenantId: tenant._id });
+      await repos.vendorUserIdMappings
+        .collection()
+        .deleteMany({ tenantId: tenant._id });
+      await repos.revocationListAllocations.collection().deleteMany({
+        tenantId: tenant._id,
+      });
+      await repos.offers.collection().deleteMany({ 'issuer.id': tenant.did });
+
+      await repos.tenants.delUsingFilter({ filter: { did: tenant.did } });
+
+      await repos.groups.deleteTenant(tenant.did);
+
+      reply.code(204);
+    }
+  );
+
+  fastify.post(
+    '/offers/clean_pii',
+    {
+      schema: fastify.autoSchema({
+        body: {
+          type: 'object',
+          properties: {
+            filter: {
+              type: 'object',
+              properties: {
+                vendorUserId: {
+                  type: 'string',
+                },
+                disclosureId: {
+                  type: 'string',
+                },
+                createdBefore: {
+                  type: 'string',
+                  format: 'date-time',
+                },
+                finalized: {
+                  type: 'boolean',
+                  default: false,
+                },
+              },
+            },
+          },
+        },
+        response: {
+          200: {
+            type: 'object',
+            properties: {
+              numCleaned: {
+                type: 'number',
+              },
+            },
+            required: ['numCleaned'],
+          },
+        },
+      }),
+    },
+    async (req) => {
+      const { repos, body } = req;
+      const filter = buildCleanPiiFilter(body?.filter);
+      const numCleaned = await repos.offers.cleanPii(filter);
+      return {
+        numCleaned,
+      };
+    }
+  );
+};
+
+module.exports = tenantController;

package/src/controllers/operator/tenants/_tenantId/disclosures/_id/autohooks.js

@@ -0,0 +1,30 @@
+/**
+ * Copyright 2023 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const { disclosureLoaderPlugin } = require('../../../../../../plugins');
+
+module.exports = async (fastify) => {
+  fastify.register(disclosureLoaderPlugin).autoSchemaPreset({
+    params: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', minLength: 1 },
+        ...fastify.currentAutoSchemaPreset.params.properties,
+      },
+      required: ['id', ...fastify.currentAutoSchemaPreset.params.required],
+    },
+  });
+};

package/src/controllers/operator/tenants/_tenantId/disclosures/_id/controller-v0.8.js

@@ -0,0 +1,271 @@
+/**
+ * Copyright 2023 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const { ObjectId } = require('mongodb');
+const qr = require('qr-image');
+const newError = require('http-errors');
+const { getOrganizationVerifiedProfile } = require('@verii/common-fetchers');
+const {
+  buildDisclosureRequestDeepLink,
+  velocityProtocolUriToHttpUri,
+  setTenantDefaultIssuingDisclosure,
+  validateDisclosure,
+  parseBodyToDisclosure,
+} = require('../../../../../../entities');
+
+const operatorDisclosuresController = async (fastify) => {
+  const specificParams = {
+    type: 'object',
+    properties: {
+      id: { type: 'string', minLength: 1 },
+      ...fastify.currentAutoSchemaPreset.params.properties,
+    },
+  };
+
+  const qrCodeQueryString = {
+    type: 'object',
+    properties: { vendorOriginContext: { type: 'string' } },
+  };
+
+  fastify.get(
+    '/',
+    {
+      schema: fastify.autoSchema({
+        params: specificParams,
+        response: {
+          200: {
+            $ref: 'https://velocitycareerlabs.io/agent-disclosure-v0.8.schema.json#',
+          },
+        },
+      }),
+    },
+    async ({ repos, params: { id } }) => repos.disclosures.findById(id)
+  );
+
+  fastify.put(
+    '/',
+    {
+      schema: fastify.autoSchema({
+        params: specificParams,
+        body: {
+          $ref: 'https://velocitycareerlabs.io/update-agent-disclosure.schema.json#',
+        },
+        response: {
+          200: {
+            $ref: 'https://velocitycareerlabs.io/agent-disclosure-v0.8.schema.json#',
+          },
+        },
+      }),
+    },
+    async (req) => {
+      const {
+        repos,
+        body,
+        tenant,
+        params: { id },
+      } = req;
+      const { setIssuingDefault } = body;
+      const disclosure = parseBodyToDisclosure(body, req);
+      const verifiedProfile = await getOrganizationVerifiedProfile(
+        tenant.did,
+        req
+      );
+      validateDisclosure(disclosure, verifiedProfile, setIssuingDefault, req);
+      const updatedDisclosure = await repos.disclosures.updateDisclosure({
+        id,
+        body: disclosure,
+      });
+      await setTenantDefaultIssuingDisclosure(
+        {
+          disclosure: updatedDisclosure,
+          setIssuingDefault,
+        },
+        req
+      );
+      return updatedDisclosure;
+    }
+  );
+
+  fastify.delete(
+    '/',
+    {
+      schema: fastify.autoSchema({
+        params: specificParams,
+        response: {
+          204: { type: 'null', description: 'No Content' },
+          400: {
+            $ref: 'error#',
+          },
+        },
+      }),
+    },
+    async (req, reply) => {
+      const {
+        repos,
+        params: { id },
+      } = req;
+      const [tenant, feed] = await Promise.all([
+        repos.tenants.findOne({
+          filter: {
+            defaultIssuingDisclosureId: new ObjectId(id),
+          },
+        }),
+        repos.feeds.findOne({
+          filter: {
+            disclosureId: new ObjectId(id),
+          },
+        }),
+      ]);
+
+      if (tenant != null) {
+        throw newError(400, 'Disclosure cannot be deleted', {
+          errorCode: 'default_disclosure_cannot_be_deleted',
+        });
+      }
+
+      if (feed != null) {
+        throw newError(400, 'Disclosure cannot be deleted', {
+          errorCode: 'disclosure_with_feeds_cannot_be_deleted',
+        });
+      }
+
+      await repos.disclosures.del(id);
+      reply.code(204);
+    }
+  );
+
+  fastify.get(
+    '/deep-link',
+    {
+      schema: fastify.autoSchema({
+        params: specificParams,
+        querystring: {
+          type: 'object',
+          properties: {
+            vendorOriginContext: { type: 'string' },
+          },
+        },
+        response: {
+          200: {
+            type: 'object',
+            properties: { deepLink: { type: 'string' } },
+            required: ['deepLink'],
+          },
+        },
+      }),
+    },
+    async (req) => {
+      const { query } = req;
+      const disclosureDeepLink = await handleDeepLinkRequest(
+        {
+          disclosureId: req.params.id,
+          vendorOriginContext: query.vendorOriginContext,
+        },
+        req
+      );
+      const httpProtocolDeepLink = velocityProtocolUriToHttpUri(
+        disclosureDeepLink,
+        req
+      );
+      return { deepLink: httpProtocolDeepLink };
+    }
+  );
+
+  fastify.get(
+    '/qrcode.png',
+    {
+      schema: fastify.autoSchema({
+        params: specificParams,
+        querystring: qrCodeQueryString,
+        response: {
+          200: {
+            description: 'qr code image response',
+            content: {
+              'image/png': { schema: { type: 'string', format: 'binary' } },
+            },
+          },
+        },
+      }),
+    },
+    async (req, reply) => {
+      const {
+        params: { id },
+        query: { vendorOriginContext },
+      } = req;
+
+      const uri = await handleDeepLinkRequest(
+        { disclosureId: id, vendorOriginContext },
+        req
+      );
+
+      const qrCodeBuffer = qr.imageSync(uri, {
+        ec_level: 'H',
+        type: 'png',
+      });
+
+      return reply.type('image/png').send(qrCodeBuffer);
+    }
+  );
+  fastify.get(
+    '/qrcode.uri',
+    {
+      schema: fastify.autoSchema({
+        params: specificParams,
+        querystring: qrCodeQueryString,
+        response: {
+          200: {
+            description: 'qr code deep link',
+            content: {
+              'text/plain': { schema: { type: 'string', format: 'uri' } },
+            },
+          },
+        },
+      }),
+    },
+    async (req, reply) => {
+      const {
+        params: { id },
+        query: { vendorOriginContext },
+      } = req;
+
+      const uri = await handleDeepLinkRequest(
+        { disclosureId: id, vendorOriginContext },
+        req
+      );
+
+      return reply.type('text/plain').send(uri);
+    }
+  );
+};
+
+const handleDeepLinkRequest = async (
+  { disclosureId, vendorOriginContext },
+  context
+) => {
+  const { repos } = context;
+  // load disclosure to make sure it exists
+  const disclosure = await repos.disclosures.findById(disclosureId, {
+    _id: 1,
+    vendorEndpoint: 1,
+  });
+  return buildDisclosureRequestDeepLink(
+    disclosure,
+    vendorOriginContext,
+    context
+  );
+};
+
+module.exports = operatorDisclosuresController;

package/src/controllers/operator/tenants/_tenantId/disclosures/_id/feeds/autohooks.js

@@ -0,0 +1,45 @@
+/**
+ * Copyright 2023 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const fp = require('fastify-plugin');
+const newError = require('http-errors');
+
+const {
+  addFeedSchema,
+  modifyFeedSchema,
+  feedSchema,
+  modifyFeedUpdateBodySchema,
+} = require('./schemas');
+
+const assertDisclosureFeedPlugin = (fastify, options, next) => {
+  fastify.addHook('preHandler', async (req) => {
+    if (req.disclosure?.feed !== true) {
+      throw newError(400, 'Disclosure feed must be true', {
+        errorCode: 'disclosure_feed_not_true',
+      });
+    }
+  });
+  next();
+};
+
+module.exports = async (fastify) =>
+  fastify
+    .register(fp(assertDisclosureFeedPlugin))
+    .addSchema(modifyFeedSchema)
+    .addSchema(feedSchema)
+    .addSchema(modifyFeedUpdateBodySchema)
+    .addSchema(addFeedSchema)
+    .autoSchemaPreset({ tags: ['feeds'] });