@verii/endpoints-organizations-registrar 1.0.0-pre.1752076816

package/src/entities/organizations/adapters/init-organization-registrar-emails.js

@@ -0,0 +1,215 @@
+/*
+ * Copyright 2025 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 { map } = require('lodash/fp');
+const { buildPublicServices } = require('../../organization-services/domains');
+
+const whichNet = ({ nodeEnv }) => {
+  switch (nodeEnv) {
+    case 'development':
+    case 'test':
+      return 'LocalDevNet';
+    case 'dev':
+      return 'DevNet';
+    case 'staging':
+      return 'TestNet';
+    case 'production':
+      return 'MainNet';
+    default:
+      return '';
+  }
+};
+const initOrganizationRegistrarEmails = (config) => {
+  return {
+    emailToNewOrgForServicesActivated: ({
+      organization,
+      activatedServiceIds = [],
+      emails,
+    }) => {
+      return {
+        subject: `Velocity Services Activated on ${whichNet(config)}`,
+        message: `Congratulations!
+<br>
+<br>
+You are being contacted because you are the admin of ${
+          organization.profile.name
+        } on Velocity Network ${whichNet(
+          config
+        )} and your services were just activated!
+<br>
+<br>
+You can now access your organization’s Payments and Rewards Hub account on ${whichNet(
+          config
+        )}. 
+To do so, please go <a href="${config.tokenWalletBaseUrl}/o/${
+          organization.didDoc.id
+        }">here</a> and log in with your Velocity Network Registrar admin credentials.  
+Please confirm that you were able to successfully log in.
+<br>
+<br>
+Your DID is registered on the Velocity Network ${whichNet(config)} as ${
+          organization.didDoc.id
+        }.
+<br>
+<br>
+The following services have been activated for you on Velocity Network ${whichNet(
+          config
+        )}:
+<br>
+<br>
+${JSON.stringify(activatedServiceIds, null, 2)}
+<br>
+<br>
+If you have any questions or problems, please reply to this email.
+<br>
+<br>
+Regards,
+<br>
+<br>
+The Velocity Network Registrar
+`,
+        sender: config.registrarSupportEmail,
+        recipients: emails,
+        replyTo: config.registrarSupportEmail,
+        html: true,
+      };
+    },
+    emailToRegisteredOrgForServicesActivated: ({
+      organization,
+      activatedServiceIds = [],
+      emails,
+    }) => ({
+      subject: `Velocity Services Activated on ${whichNet(config)}`,
+      message: `
+Hello,
+
+You are being contacted because you are the admin of ${
+        organization.profile.name
+      } on Velocity Network ${whichNet(
+        config
+      )} and a new service has just been added to your organization. 
+
+The following services have been activated for you on Velocity Network ${whichNet(
+        config
+      )}:
+
+${JSON.stringify(activatedServiceIds, null, 2)}
+
+If you have any questions or problems, please reply to this email.
+
+Regards,
+
+The Velocity Network Registrar`,
+      sender: config.registrarSupportEmail,
+      recipients: emails,
+      replyTo: config.registrarSupportEmail,
+    }),
+    emailToSupportForOrgRegisteredAndServicesNeedActivation: (
+      { organization, addedServices = [] },
+      context
+    ) => ({
+      subject: `${config.nodeEnv.toUpperCase()}: Velocity Services Activation Required`,
+      message: `Hello,
+The organization: "${organization.profile.name}" with did "${
+        organization.didDoc.id
+      }" has registered.  
+        
+Their full profile looks like this:
+${JSON.stringify(organization.profile, null, 2)}
+
+Their requested services are:
+${JSON.stringify(addedServices, null, 2)}
+
+userAgent: ${context.headers['user-agent']}
+
+Check in Zoho and trigger the API endpoint everything is kosher.
+
+Regards,
+BYTER-9000!
+`,
+      sender: config.noReplyEmail,
+      recipients: [config.registrarSupportEmail],
+    }),
+    emailToSupportForServicesAddedAndNeedActivation: (
+      { organization, addedServices = [] },
+      context
+    ) => ({
+      subject: `${config.nodeEnv.toUpperCase()}: Velocity Services Activation Required`,
+      message: `Hello,
+The following service(s) have been added to "${
+        organization.profile.name
+      }" with did "${organization.didDoc.id}":
+
+${JSON.stringify(buildPublicServices(addedServices), null, 2)}
+
+userAgent: ${context.headers['user-agent']}
+
+Check in Zoho and trigger the API endpoint everything is kosher.
+
+Regards,
+BYTER-9000!
+`,
+      sender: config.noReplyEmail,
+      recipients: [config.registrarSupportEmail],
+    }),
+    emailToCAOsForServicesActivation: ({
+      organization,
+      activatedService,
+      emails,
+    }) => ({
+      subject: `${organization.profile.name} service is now active`,
+      message: `${organization.profile.name} has had the following service activated on the Velocity Network™:
+
+${activatedService.type} on the agent ${activatedService.id} at ${activatedService.serviceEndpoint}  
+
+The service is now able to be used on the Velocity Network™.
+`,
+      sender: config.registrarSupportEmail,
+      recipients: emails,
+      replyTo: config.registrarSupportEmail,
+    }),
+    emailToGroupForInvitationAccepted: ({
+      organization,
+      services,
+      emails,
+    }) => ({
+      subject: `${config.nodeEnv.toUpperCase()}: ${
+        organization.profile.name
+      } has accepted your invitation`,
+      /* eslint-disable max-len */
+      message: `
+${
+  organization.profile.name
+} has accepted your invitation to join the Velocity Network™. The following  service(s) has been registered:
+
+${map(
+  (service) =>
+    `${service.type} on the agent ${service.caoService.id} at ${service.caoService.serviceEndpoint}`,
+  services
+).join(' \n')}
+
+The service is still inactive. The foundation staff are reviewing the application and will activate the services on  in the next 72 hours. Upon successful review you will receive confirmation by email.
+    `,
+      /* eslint-enable */
+      sender: config.registrarSupportEmail,
+      recipients: emails,
+      replyTo: config.registrarSupportEmail,
+    }),
+  };
+};
+
+module.exports = { initOrganizationRegistrarEmails };

package/src/entities/organizations/adapters/init-send-activation-emails-to-caos.js

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2025 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 { map, isEmpty } = require('lodash/fp');
+const { initAuth0Provisioner } = require('../../oauth');
+const {
+  selectActivatedServices,
+} = require('../../organization-services/domains');
+const {
+  initOrganizationRegistrarEmails,
+} = require('./init-organization-registrar-emails');
+
+const initSendActivationEmailsToCAOs = (initCtx) => {
+  const { sendEmail, config, sendError } = initCtx;
+  const { emailToCAOsForServicesActivation } =
+    initOrganizationRegistrarEmails(config);
+
+  const { getUsersByIds } = initAuth0Provisioner(config);
+
+  return async (
+    organization,
+    services,
+    serviceIds = [],
+    caoServiceRefs,
+    context
+  ) => {
+    const { repos, log } = context;
+
+    const activatedServices = selectActivatedServices(serviceIds, services);
+
+    const emailRequests = map(async (service) => {
+      const caoOrganization =
+        caoServiceRefs?.[service.serviceEndpoint]?.caoOrganization;
+      if (isEmpty(caoOrganization)) {
+        return;
+      }
+
+      const group = await repos.groups.findGroupByDid(
+        caoOrganization.didDoc.id
+      );
+      if (isEmpty(group?.clientAdminIds)) {
+        return;
+      }
+
+      const emails = map(
+        'email',
+        await getUsersByIds({ userIds: group?.clientAdminIds })
+      );
+
+      try {
+        await sendEmail(
+          emailToCAOsForServicesActivation(
+            {
+              organization,
+              activatedService: service,
+              emails,
+            },
+            context
+          )
+        );
+      } catch (e) {
+        sendError(e, { message: e.message });
+        log.warn(
+          `Unable to send email for organization ${organization?.didDoc?.id} service ${service?.id}`
+        );
+      }
+    }, activatedServices);
+
+    await Promise.all(emailRequests);
+  };
+};
+
+module.exports = {
+  initSendActivationEmailsToCAOs,
+};

package/src/entities/organizations/adapters/send-email-invitation-accepted-to-inviter.js

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2025 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 { map, isEmpty, compact, flow } = require('lodash/fp');
+const { initAuth0Provisioner } = require('../../oauth');
+const {
+  initOrganizationRegistrarEmails,
+} = require('./init-organization-registrar-emails');
+
+const mergeCaoServices = async (addedServices, caoServiceRefs) => {
+  return flow(
+    map((service) => {
+      const caoService = caoServiceRefs[service.serviceEndpoint]?.caoService;
+      return isEmpty(caoService) ? null : { ...service, caoService };
+    }),
+    compact
+  )(addedServices);
+};
+
+const initSendEmailInvitationAcceptedToInviter = (fastify) => {
+  const { sendEmail } = fastify;
+  const { getUsersByIds } = initAuth0Provisioner(fastify.config);
+  const { emailToGroupForInvitationAccepted } = initOrganizationRegistrarEmails(
+    fastify.config
+  );
+
+  return async (data, context) => {
+    const { repos } = context;
+    const { invitation, organization, addedServices, caoServiceRefs } = data;
+    if (isEmpty(invitation)) {
+      return;
+    }
+
+    const services = await mergeCaoServices(addedServices, caoServiceRefs);
+    if (isEmpty(services)) {
+      return;
+    }
+
+    const group = await repos.groups.findGroupByDid(invitation.inviterDid);
+    if (isEmpty(group?.clientAdminIds)) {
+      return;
+    }
+    const emails = map(
+      'email',
+      await getUsersByIds({ userIds: group.clientAdminIds })
+    );
+
+    await sendEmail(
+      emailToGroupForInvitationAccepted({ organization, services, emails })
+    );
+  };
+};
+
+module.exports = {
+  initSendEmailInvitationAcceptedToInviter,
+};

package/src/entities/organizations/adapters/send-email-notifications.js

@@ -0,0 +1,212 @@
+/*
+ * Copyright 2025 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 { isEmpty, omitBy, isNil, map } = require('lodash/fp');
+const { optional } = require('@verii/common-functions');
+const { initAuth0Provisioner } = require('../../oauth');
+const { parseProfileToCsv, ServiceTypeLabels } = require('../domains');
+const {
+  initOrganizationRegistrarEmails,
+} = require('./init-organization-registrar-emails');
+
+const initSendEmailNotifications = (initCtx) => {
+  const { config } = initCtx;
+  const {
+    emailToNewOrgForServicesActivated,
+    emailToSupportForOrgRegisteredAndServicesNeedActivation,
+    emailToSupportForServicesAddedAndNeedActivation,
+    emailToRegisteredOrgForServicesActivated,
+  } = initOrganizationRegistrarEmails(config);
+  const { getUsersByIds } = initAuth0Provisioner(config);
+
+  const shouldSendEmailForServicesActivated = (
+    activatedServiceIds,
+    userEmails
+  ) => {
+    return activatedServiceIds.length > 0 && !isEmpty(userEmails);
+  };
+
+  const shouldSendEmailForServicesNeedActivation = (
+    addedServices,
+    activatedServiceIds
+  ) => {
+    return (
+      addedServices.length > 0 &&
+      activatedServiceIds.length !== addedServices.length
+    );
+  };
+
+  const sendServiceNotification = async (
+    {
+      organization,
+      userEmails,
+      addedServices = [],
+      activatedServiceIds = [],
+      isCreateOrganization = false,
+    },
+    ctx
+  ) => {
+    const emailToServiceNeedActivation = isCreateOrganization
+      ? emailToSupportForOrgRegisteredAndServicesNeedActivation
+      : emailToSupportForServicesAddedAndNeedActivation;
+
+    const emailForServicesActivated = isCreateOrganization
+      ? emailToNewOrgForServicesActivated
+      : emailToRegisteredOrgForServicesActivated;
+
+    if (shouldSendEmailForServicesActivated(activatedServiceIds, userEmails)) {
+      await initCtx.sendEmail(
+        emailForServicesActivated({
+          organization,
+          activatedServiceIds,
+          emails: userEmails,
+        })
+      );
+    } else if (
+      shouldSendEmailForServicesNeedActivation(
+        addedServices,
+        activatedServiceIds
+      )
+    ) {
+      await initCtx.sendEmail(
+        emailToServiceNeedActivation(
+          {
+            organization,
+            addedServices,
+          },
+          ctx
+        )
+      );
+    }
+  };
+
+  const sendServiceNotificationToGroup = async (
+    {
+      organization,
+      addedServices,
+      activatedServiceIds,
+      isCreateOrganization = false,
+    },
+    ctx
+  ) => {
+    const { repos, user, log } = ctx;
+    const group = await repos.groups.findGroupByUserIdAndDid(
+      user.sub,
+      organization.didDoc.id
+    );
+    if (!group) {
+      const message = 'There was no group for organization';
+      log.info(
+        {
+          did: organization.didDoc.id,
+          user: user.sub,
+        },
+        message
+      );
+      return;
+    }
+
+    const { clientAdminIds } = group;
+    const userEmails = map(
+      'email',
+      await getUsersByIds({ userIds: clientAdminIds })
+    );
+
+    await sendServiceNotification(
+      omitBy(isNil, {
+        organization,
+        userEmails,
+        addedServices,
+        activatedServiceIds,
+        isCreateOrganization,
+      }),
+      ctx
+    );
+  };
+
+  const sendOrganizationCreatedNotification = async (
+    { organization },
+    context
+  ) => {
+    const csvFile = await parseProfileToCsv(organization.profile);
+    await initCtx.sendEmail({
+      subject: await context.renderTemplate(
+        'support-organization-created-subject',
+        {
+          organization,
+        }
+      ),
+      message: await context.renderTemplate(
+        'support-organization-created-body',
+        {
+          organization,
+        }
+      ),
+      sender: config.noReplyEmail,
+      ccs: config.organizationCreationEmailCcList,
+      recipients: [config.registrarSupportEmail],
+      attachment: csvFile,
+      attachmentName: 'organization.csv',
+      contentType: 'text/csv',
+    });
+  };
+
+  const sendEmailToSignatoryForOrganizationApproval = async (
+    { organization, authCode, isReminder = false },
+    context
+  ) => {
+    const invitation = await optional(
+      () => context.repos.invitations.findById(organization.invitationId),
+      [organization.invitationId]
+    );
+    const inviterOrganization = invitation?.inviterDid
+      ? await context.repos.organizations.findOneByDid(invitation.inviterDid)
+      : null;
+    const html = await context.renderTemplate('signatory-approval-email-body', {
+      organization,
+      inviterOrganization,
+      authCode,
+      ServiceTypeLabels,
+      config,
+    });
+    await initCtx.sendEmail({
+      subject: `${isReminder ? 'Reminder: ' : ''}${
+        inviterOrganization?.profile?.name ??
+        `${organization.profile.adminGivenName} ${organization.profile.adminFamilyName}`
+      } is requesting your approval to register ${
+        organization.profile.name
+      } on the Velocity Network`,
+      message: html,
+      sender: config.registrarSupportEmail,
+      recipients: [organization.profile.signatoryEmail],
+      bccs: [config.signatoryVnfEmail],
+      replyTo: config.registrarSupportEmail,
+      html: true,
+    });
+  };
+
+  return {
+    sendServiceNotification,
+    sendServiceNotificationToGroup,
+    sendOrganizationCreatedNotification,
+    sendEmailToSignatoryForOrganizationApproval,
+  };
+};
+
+module.exports = {
+  initSendEmailNotifications,
+};

package/src/entities/organizations/domains/build-custodied-did-web.js

@@ -0,0 +1,12 @@
+const { uriToDidWeb } = require('@verii/did-web');
+
+const buildCustodiedDidWeb = (profile, { config: { custodiedDidWebHost } }) => {
+  const profileUrl = new URL(profile.website);
+  const url = new URL(custodiedDidWebHost);
+  url.pathname = `/d/${profileUrl.hostname}`;
+  return uriToDidWeb(url.href);
+};
+
+module.exports = {
+  buildCustodiedDidWeb,
+};

package/src/entities/organizations/domains/build-full-organization-response.js

@@ -0,0 +1,40 @@
+const { mapWithIndex } = require('@verii/common-functions');
+const { mapKeyResponse } = require('../../organization-keys');
+
+const buildProfileResponse = (organization, includeTimestamps = false) => {
+  const profile = {
+    ...organization.profile,
+    description: organization.profile.description || '',
+    id: organization.didDoc.id,
+    verifiableCredentialJwt: organization.verifiableCredentialJwt,
+  };
+  if (includeTimestamps) {
+    profile.updatedAt = organization.updatedAt;
+    profile.createdAt = organization.createdAt;
+  }
+
+  return profile;
+};
+const buildFullOrganizationResponse = ({
+  organization,
+  services,
+  profile,
+  keys,
+  keyPairs,
+  ...rest
+}) => ({
+  id: organization.didDoc.id,
+  didDoc: organization.didDoc,
+  ids: organization.ids,
+  activatedServiceIds: organization.activatedServiceIds,
+  custodied: !organization.didNotCustodied,
+  profile: profile ?? buildProfileResponse(organization),
+  services: services ?? organization.services,
+  keys: keys != null ? buildOutgoingKeys(keys, keyPairs) : organization.keys,
+  ...rest,
+});
+
+const buildOutgoingKeys = (keys, keyPairs) =>
+  mapWithIndex((key, i) => mapKeyResponse(key, keyPairs[i]), keys);
+
+module.exports = { buildFullOrganizationResponse, buildProfileResponse };