prow-authority 3.6.3

package/src/v1/controllers/users/public-user-controller.ts

@@ -0,0 +1,471 @@
+import { Date2, Formats } from "@beseif-solutions/utility-functions/dist/utils/date-utils";
+import { Requester } from "@beseif-solutions/utility-functions/dist/utils/http-utils";
+import { DeepPartial } from "@beseif-solutions/utility-functions/dist/utils/typing-utils";
+import { Schema, Validator } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+import _ from "lodash";
+import APIError, { StatusCodes } from "../../../helpers/api-error";
+import { informationResponseSchema } from "../../schemas/admin/service-schemas";
+import { confirmSchema } from "../../schemas/auth/auth-schemas";
+import { acceptPoliciesSchema, registerUserSchema, updateUserSchema } from "../../schemas/users/public-user-schemas";
+import { OrganizationStatus } from "../../types/admin/organization-types";
+import { Policy } from "../../types/admin/policy-types";
+import { UserOrganization, UserOrganizationRole } from "../../types/admin/user-organization-types";
+import { CommunicationType, User, UTM } from "../../types/admin/user-types";
+import { Environment } from "../../types/auth/organization-token-types";
+import { TempCodeType } from "../../types/auth/otp-types";
+import { AcceptPolicies, PublicPolicy } from "../../types/policies/public-policy-types";
+import { PublicServiceInformation } from "../../types/services/public-service-types";
+import { PublicAccess, PublicUser, PublicUserOrganization } from "../../types/users/public-user-types";
+import notificationController from "../admin/notification-controller";
+import organizationController from "../admin/organization-controller";
+import policyController from "../admin/policy-controller";
+import serviceController from "../admin/service-controller";
+import userController from "../admin/user-controller";
+import userOrganizationController from "../admin/user-organization-controller";
+import userPolicyController from "../admin/user-policy-controller";
+import tempCodeController from "../auth/temp-code-controller";
+import publicOrganizationController from "../organizations/public-organization-controller";
+import publicPolicyController from "../policies/public-policy-controller";
+import publicServiceController from "../services/public-service-controller";
+import { Resource } from "@beseif-solutions/prow-authority-for-services";
+import authority, { MemberAdded, NotificationEventNames, ResourceModelName, omnipotentAccess } from "../../../helpers/authority";
+import nconf from "../../../helpers/config";
+
+type Register = Omit<PublicUser, `uuid` | `status` | `created_date` | `modified_date` | `password`> & { password: string, utm?: UTM, referrer?: string };
+type Update = DeepPartial<Register>;
+
+class PublicUserCtrl {
+
+  public readonly register = async (data: Register, confirmation: boolean): Promise<PublicUser> => {
+    try {
+      Validator.validate(registerUserSchema, data);
+      let user = (await userController.list({ email: data.email }, { password: true, timestamp: true }))[0];
+
+      if (!user) {
+        // create user
+        user = (await userController.add(data, { password: false, timestamp: true }))[0];
+      } else if (user.status === `pending` || !user.password) {
+        // "create" when status is pending
+        // - Social Sign Up
+        // - Invitation from organization
+        user = (await userController.update(user.id, data, { password: false, timestamp: true }))[0];
+      } else {
+        // user already exists
+        throw new APIError({
+          code: StatusCodes.CONFLICT,
+          detail: `User with email ${data.email} already exists.`,
+        });
+      }
+
+      // accept all current policies on registration
+      await this.acceptPolicies(user);
+
+      if (confirmation) {
+        // send confirmation
+        await this.requestConfirmation(user);
+      }
+
+      const [response] = await this.parseUser([user]);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly get = async (user: User): Promise<PublicUser> => {
+    try {
+      const [response] = await this.parseUser([user]);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly update = async (user: User, data: Update): Promise<PublicUser> => {
+    try {
+      Validator.validate(updateUserSchema, data);
+      const updated = await userController.update(user.id, data, { password: false, timestamp: true });
+      const [response] = await this.parseUser(updated);
+      return response;
+    } catch (e) { throw e; }
+
+  };
+
+  public readonly delete = async (user: User): Promise<void> => {
+    try {
+      // check user organization accesses
+      const accesses = await userOrganizationController.list({ user: user.id, enabled: true });
+
+      const owner = accesses.filter((access) => access.role === UserOrganizationRole.Owner);
+      if (owner.length > 0) {
+        throw new APIError({
+          code: StatusCodes.BAD_REQUEST,
+          detail: `This user is the owner of ${owner.length} organization${owner.length === 1 ? `` : `s`}. Please remove ${owner.length === 1 ? `it` : `them`} or change the ownership before deleting the user.`,
+        });
+      }
+
+      const organizations = await organizationController.list({ id: { in: accesses.map((a) => a.organization) } });
+      for (const organization of organizations) {
+        // delete user access
+        const access = accesses.find((a) => a.organization === organization.id);
+        if (!access) { continue; }
+
+        const env = {
+          organization: organization,
+          user: user,
+          access: access,
+          license: null,
+        };
+
+        // delete user from organization
+        await publicOrganizationController.deleteUser(env, user.uuid);
+      }
+
+      await userController.delete(user.id);
+
+      await this.deleteInformation(user);
+    } catch (e) { throw e; }
+  };
+
+  // authority endpoint: user resources
+  public readonly authority = async (userUUID: string): Promise<Resource<ResourceModelName>[]> => {
+    try {
+      const user = (await userController.list({ uuid: userUUID }, { password: false }))[0];
+      if (!user) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `No user ${userUUID} found.`,
+        });
+      }
+
+      const access = await userOrganizationController.count({ user: user.id, enabled: true });
+      const response: Resource<ResourceModelName>[] = [
+        {
+          type: `shared`,
+          model: `organization.organization`,
+          count: access.count,
+        },
+      ];
+
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  // information over services
+  public readonly getInformation = async (user: User): Promise<PublicServiceInformation[]> => {
+    try {
+      const services = await serviceController.list({ enabled: true });
+
+      const response: PublicServiceInformation[] = _.compact(await Promise.all(services.map(async (service) => {
+        try {
+          let information: any[] = [];
+          if (service.internal.host && service.internal.user?.information) {
+            information = await Requester.get(`${service.internal.user?.information}/${user.uuid}`, {
+              baseURL: service.internal.host,
+              headers: {
+                "x-service-uuid": service.uuid,
+                "x-service-token": service.token,
+              },
+            });
+            Validator.validate(informationResponseSchema, information);
+          }
+
+          return {
+            service: (await publicServiceController.parseServices([service]))[0],
+            information: information,
+          };
+        } catch (e) { return null; }
+      })));
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  private readonly deleteInformation = async (user: User): Promise<void> => {
+    try {
+      const services = await serviceController.list({ enabled: true });
+
+      await Promise.all(services.map(async (service) => {
+        try {
+          if (service.internal.host && service.internal.user?.deleted) {
+            await Requester.delete(`${service.internal.user?.deleted}/${user.uuid}`, {
+              baseURL: service.internal.host,
+              headers: {
+                "x-service-uuid": service.uuid,
+                "x-service-token": service.token,
+              },
+            });
+          }
+        } catch (e) {
+          // TODO: what to do when error?
+        }
+      }));
+    } catch (e) { throw e; }
+  };
+
+  // confirmation process
+  public readonly requestConfirmation = async (user: User): Promise<void> => {
+    try {
+      await notificationController.confirmation(user.id);
+    } catch (e) { throw e; }
+  };
+
+  public readonly confirm = async (user: User, data: { code: string }): Promise<PublicUser> => {
+    try {
+      Validator.validate(confirmSchema, data);
+      await tempCodeController.validate(TempCodeType.Confirmation, user, data.code);
+
+      await userController.activate(user.id, { password: false });
+
+      const updated = await userController.get(user.id, { password: false, timestamp: true });
+      const [response] = await this.parseUser(updated);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  // organizations
+  public readonly organizations = async (user: User): Promise<PublicUserOrganization[]> => {
+    try {
+      const accesses = await userOrganizationController.list({ user: user.id, enabled: true });
+      const organizations = await organizationController.list(
+        user.omnipotent ? {} : { id: { in: accesses.map((a) => a.organization) } },
+        { timestamp: true },
+      );
+
+      const response: PublicUserOrganization[] = [];
+      for (const o of organizations) {
+        const access = accesses.find((a) => a.organization === o.id) || (user.omnipotent ? omnipotentAccess(user, o) : null);
+        if (!access) { continue; }
+
+        const env: Environment = {
+          user: user,
+          access: access,
+          organization: o,
+          license: null,
+        };
+
+        response.push({
+          organization: (await publicOrganizationController.parse(env, [o]))[0],
+          access: (await this.parseAccess([access], { userCache: [user] }))[0],
+        });
+      }
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly invite = async (user: User, organizationUUID: string, data: { code: string, accept: boolean }): Promise<void> => {
+    try {
+      Validator.validate(Schema.object({ code: Schema.requiredString(), accept: Schema.requiredBool() }), data);
+
+      const organization = (await organizationController.list({ uuid: organizationUUID, status: { is: OrganizationStatus.Blocked, inverse: true } }))[0];
+      if (!organization) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `No organization ${organizationUUID} found.`,
+        });
+      }
+
+      const access = (await userOrganizationController.list({
+        user: user.id,
+        organization: organization.id,
+        invite: data.code,
+        enabled: true,
+      }))[0];
+      if (!access) {
+        throw new APIError({
+          code: StatusCodes.BAD_REQUEST,
+          detail: `Invalid invite code for organization ${organizationUUID}.`,
+        });
+      }
+
+      if (data.accept) {
+        await userOrganizationController.update(access.id, { invite: null });
+
+        await authority.notify<MemberAdded>(organization.uuid, {
+          event: NotificationEventNames.MemberAdded,
+          data: {
+            user: user,
+            role: access.role,
+            organization: organization,
+            cta: {
+              members: nconf.get(`SERVICES:NOTIFICATIONS:CTAS:ORG_MEMBERS`),
+              preferences: nconf.get(`SERVICES:NOTIFICATIONS:CTAS:USER_PREF_LIST`),
+            },
+          },
+        });
+      } else {
+        await publicOrganizationController.deleteUser({
+          organization: organization,
+          user: user,
+          access: access,
+          license: null,
+        }, user.uuid);
+      }
+    } catch (e) { throw e; }
+  };
+
+  public readonly leave = async (user: User, organizationUUID: string): Promise<void> => {
+    try {
+      const organization = (await organizationController.list({ uuid: organizationUUID, status: { is: OrganizationStatus.Blocked, inverse: true } }))[0];
+      if (!organization) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `No organization ${organizationUUID} found.`,
+        });
+      }
+
+      const access = (await userOrganizationController.list({
+        user: user.id,
+        organization: organization.id,
+        enabled: true,
+      }))[0];
+      if (!access) {
+        throw new APIError({
+          code: StatusCodes.BAD_REQUEST,
+          detail: `Invalid invite code for organization ${organizationUUID}.`,
+        });
+      }
+
+      await publicOrganizationController.deleteUser({
+        organization: organization,
+        user: user,
+        access: access,
+        license: null,
+      }, user.uuid);
+    } catch (e) { throw e; }
+  };
+
+  // policy-related methods
+  public readonly getPendingUserPolicies = async (user: User): Promise<PublicPolicy[]> => {
+    try {
+      const policies = await policyController.list({});
+
+      const pendingPolicies: Policy[] = [];
+      for (const policy of policies) {
+        const latestVersion = await publicPolicyController.getLatestVersion(policy.id);
+        if (!latestVersion) { continue; }
+
+        const userAcceptance = (await userPolicyController.list({
+          user: user.id,
+          policy: policy.id,
+          version: latestVersion.id,
+        }))[0];
+
+        if (!userAcceptance) { pendingPolicies.push(policy); }
+      }
+
+      return publicPolicyController.parsePolicies(pendingPolicies);
+    } catch (e) { throw e; }
+  };
+
+  public readonly acceptPolicies = async (user: User, data: AcceptPolicies = {}): Promise<void> => {
+    try {
+      Validator.validate(acceptPoliciesSchema, data);
+
+      const policies = await policyController.list({
+        ...data.uuids ? { uuid: { in: data.uuids } } : {},
+      });
+
+      for (const policy of policies) {
+        const version = await publicPolicyController.getLatestVersion(policy.id);
+        if (!version) { continue; }
+
+        // check if user already has this policy version accepted
+        const existing = (await userPolicyController.list({
+          user: user.id,
+          policy: policy.id,
+          version: version.id,
+        }))[0];
+
+        if (!existing) {
+          await userPolicyController.add({
+            user: user.id,
+            policy: policy.id,
+            version: version.id,
+            metadata: {},
+            internal: {},
+          });
+        }
+      }
+    } catch (e) { throw e; }
+  };
+
+  public readonly parseUser = async (records: User[]): Promise<PublicUser[]> => {
+    try {
+      const response: PublicUser[] = [];
+
+      for (const record of records) {
+        const p: PublicUser = {
+          uuid: record.uuid,
+          email: record.email,
+          password: record.password ? true : false,
+          properties: record.properties,
+          preferences: record.preferences,
+          omnipotent: record.omnipotent ? true : undefined, // don't expose omnipotent flag if false
+          created_date: new Date2(record.created_date).format(Formats.ISO),
+          modified_date: new Date2(record.modified_date).format(Formats.ISO),
+          status: record.status,
+          metadata: record.metadata,
+        };
+        response.push(p);
+      }
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly parseAccess = async (records: UserOrganization[], options: { userCache?: User[], preferences?: boolean } = {}): Promise<PublicAccess[]> => {
+    try {
+      const missingUserIDs = _.compact(
+        _.uniq(records.map((r) => r.invited_by)
+          .filter((id) => !(options.userCache || []).some((u) => u.id === id))));
+      const users = [
+        ...options.userCache || [],
+        ...missingUserIDs.length ? await userController.list({ id: { in: missingUserIDs } }, { password: false, timestamp: true }) : [],
+      ];
+
+      const response: PublicAccess[] = [];
+      for (const record of records) {
+        const invitedBy = users.find((u) => u.id === record.invited_by);
+        const p: PublicAccess = {
+          invite: record.invite,
+          invited_by: invitedBy ? (await this.parseUser([invitedBy]))[0] : null,
+          role: record.role,
+          created_date: new Date2(record.created_date).format(Formats.ISO),
+          modified_date: new Date2(record.modified_date).format(Formats.ISO),
+          enabled: record.enabled ? true : false,
+          ...(options.preferences ? { preferences: record.preferences } : {}),
+          metadata: record.metadata,
+        };
+        response.push(p);
+      }
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  // communications
+  public readonly unsubscribeByUuid = async (uuid: string, type: CommunicationType): Promise<void> => {
+    try {
+      const validTypes: CommunicationType[] = [CommunicationType.Commercial, CommunicationType.Newsletter];
+      if (!validTypes.includes(type)) {
+        throw new APIError({
+          code: StatusCodes.BAD_REQUEST,
+          detail: `Invalid communication type. Valid types are: ${validTypes.join(`, `)}`,
+        });
+      }
+
+      const user = (await userController.list({ uuid: uuid }, { password: false }))[0];
+      if (!user) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `User not found`,
+        });
+      }
+
+      await userController.update(user.id, {
+        preferences: {
+          communications: {
+            [type]: false,
+          },
+        },
+      }, { password: false });
+    } catch (e) { throw e; }
+  };
+}
+
+const publicUserController = new PublicUserCtrl();
+export default publicUserController;

package/src/v1/daos/@deprecated auth-dao.ts

@@ -0,0 +1,173 @@
+// import { newUUIDv4 } from "@beseif-solutions/utility-functions/dist/utils/string-utils";
+
+// // session
+// export type UserLogin = {
+//   id: number,
+//   username: string,
+//   password: string,
+//   sign: string,
+//   webhook: string,
+// };
+
+
+// const userLogins: UserLogin[] = [];
+
+// // static
+// export type AppLogin = {
+//   id: number,
+//   token: string,
+//   user: number,
+// };
+
+// const appLogins: AppLogin[] = [
+
+// ];
+
+// // oauth
+// export type OAuthClient = {
+//   id: string,
+//   secret: string,
+//   name: string,
+//   image: string,
+//   redirects: string[],
+// };
+
+// const oauthClients: OAuthClient[] = [
+
+// ];
+
+// export const SCOPES = [`*`, `user`, `crm:orders`, `crm:clients`];
+
+// export type OAuthSession = {
+//   token: string,
+//   client_id: OAuthClient[`id`],
+//   redirect_uri: string,
+//   scope: string,
+//   user?: UserLogin[`id`],
+// };
+
+// let oauthSessions: OAuthSession[] = [];
+
+// export type OAuthCode = {
+//   code: string,
+//   session: OAuthSession[`token`],
+// };
+
+// let oauthCodes: OAuthCode[] = [];
+
+// export type OAuthLogin = {
+//   id: string,
+// };
+
+// let oauthLogins: OAuthLogin[] = [];
+
+// class AuthDao {
+//   // session
+//   public readonly findUserLoginByUsername = async (username: string): Promise<UserLogin> =>
+//     userLogins.find(user => user.username === username);
+
+//   public readonly findUserLoginById = async (id: number): Promise<UserLogin> =>
+//     userLogins.find(user => user.id === id);
+
+//   // static
+//   public readonly findAppLoginById = async (id: number): Promise<AppLogin> =>
+//     appLogins.find(app => app.id === id);
+
+//   // oauth
+//   public readonly findOAuthClientById = async (id: string): Promise<OAuthClient> =>
+//     oauthClients.find(client => client.id === id);
+
+//   public readonly findOAuthSessionByToken = async (token: string): Promise<OAuthSession> =>
+//     oauthSessions.find(session => session.token === token);
+
+//   public readonly addOAuthSession = async (data: Omit<OAuthSession, `token`>): Promise<OAuthSession> => {
+//     try {
+//       const token = newUUIDv4();
+
+//       const session: OAuthSession = {
+//         ...data,
+//         token: token,
+//       };
+
+//       oauthSessions.push(session);
+//       return session;
+//     } catch (e) { throw e; }
+//   };
+
+//   public readonly updateOAuthSession = async (token: string, data: Partial<Omit<OAuthSession, `token`>>): Promise<OAuthSession> => {
+//     try {
+//       const id = oauthSessions.findIndex(session => session.token === token);
+//       if (id < 0) { throw new Error(`No OAuth session found`); }
+
+//       const updated = {
+//         ...oauthSessions[id],
+//         ...data,
+//       };
+
+//       oauthSessions[id] = updated;
+//       return updated;
+//     } catch (e) { throw e; }
+//   };
+
+//   public readonly deleteOAuthSessionByToken = async (token: string): Promise<void> => {
+//     oauthSessions = oauthSessions.filter(session => session.token !== token);
+//   };
+
+//   public readonly findOAuthCodeByCode = async (code: string): Promise<OAuthCode> =>
+//     oauthCodes.find(codes => codes.code === code);
+
+//   public readonly addOAuthCode = async (data: Omit<OAuthCode, `code`>): Promise<OAuthCode> => {
+//     try {
+//       const code = newUUIDv4();
+
+//       const session: OAuthCode = {
+//         ...data,
+//         code: code,
+//       };
+
+//       oauthCodes.push(session);
+//       return session;
+//     } catch (e) { throw e; }
+//   };
+
+//   public readonly updateOAuthCode = async (code: string, data: Partial<Omit<OAuthCode, `code`>>): Promise<OAuthCode> => {
+//     try {
+//       const id = oauthCodes.findIndex(session => session.code === code);
+//       if (id < 0) { throw new Error(`No OAuth session found`); }
+
+//       const updated = {
+//         ...oauthCodes[id],
+//         ...data,
+//       };
+
+//       oauthCodes[id] = updated;
+//       return updated;
+//     } catch (e) { throw e; }
+//   };
+
+//   public readonly deleteOAuthCodeByCode = async (code: string): Promise<void> => {
+//     oauthCodes = oauthCodes.filter(codes => codes.code !== code);
+//   };
+
+//   public readonly findOAuthLoginById = async (id: string): Promise<OAuthLogin> =>
+//     oauthLogins.find(logins => logins.id === id);
+
+//   public readonly addOAuthLogin = async (data: OAuthLogin): Promise<OAuthLogin> => {
+//     try {
+//       const session: OAuthLogin = {
+//         ...data,
+//       };
+
+//       oauthLogins.push(session);
+//       return session;
+//     } catch (e) { throw e; }
+//   };
+
+//   public readonly deleteOAuthLoginById = async (id: string): Promise<void> => {
+//     oauthLogins = oauthLogins.filter(logins => logins.id !== id);
+//   };
+
+// }
+
+// const authDao = new AuthDao();
+// export default authDao;