prow-authority 3.6.3

package/src/v1/routes/organizations/users-router.ts

@@ -0,0 +1,139 @@
+import { Request, Response, Router } from 'express';
+import httpcodes, { StatusCodes } from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+import { LicenseLimitNames } from '../../../helpers/authority';
+import publicOrganizationController from '../../controllers/organizations/public-organization-controller';
+import authorityMiddleware from '../../middlewares/authority-middleware';
+import { Environment } from '../../types/auth/organization-token-types';
+import organizationMiddleware from '../../middlewares/organizations/organization-middleware';
+
+class UsersRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly inviteUser = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.inviteUser(req[`environment`], req.body);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly getMe = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.getMe(req[`environment`] as Environment);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly updateMe = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.updateMe(req[`environment`] as Environment, req.body);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly getOwner = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.getOwner(req[`environment`] as Environment);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly getUsers = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.getUsers(req[`environment`] as Environment, { all: req.query[`all`] === `true` });
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly updateUser = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.updateUser(req[`environment`] as Environment, req.params[`uuid`], req.body);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly deleteUser = async (req: Request, res: Response) => {
+    try {
+      await publicOrganizationController.deleteUser(req[`environment`] as Environment, req.params[`uuid`]);
+      res.status(StatusCodes.NO_CONTENT).json();
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly invite = async (req: Request, res: Response) => {
+    try {
+      await publicOrganizationController.sendInvitation(req[`environment`] as Environment, req.params[`uuid`]);
+      res.status(StatusCodes.NO_CONTENT).json();
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly init = () => {
+    this.router.get(`/me`, this.getMe);
+    this.router.patch(`/me`, this.updateMe);
+    this.router.get(`/owner`, this.getOwner);
+    this.router.get(``, this.getUsers);
+
+    // only licensed access to users
+    this.router.use(organizationMiddleware.admin, organizationMiddleware.active, authorityMiddleware.licensed);
+
+    this.router.post(``, authorityMiddleware.quota({ name: LicenseLimitNames.Seats, count: +1 }), this.inviteUser);
+    this.router.post(`/:uuid/invite`, this.invite);
+    this.router.patch(`/:uuid`, this.updateUser);
+    this.router.delete(`/:uuid`, authorityMiddleware.quota({ name: LicenseLimitNames.Seats, count: -1 }), this.deleteUser);
+  };
+}
+
+const usersRouter = (new UsersRouter()).router;
+export default usersRouter;

package/src/v1/routes/policies/public-policy-router.ts

@@ -0,0 +1,50 @@
+import { Request, Response, Router } from 'express';
+import httpcodes from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+import publicPolicyController from '../../controllers/policies/public-policy-controller';
+
+class PublicPolicyRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  // get all active policies (public endpoint)
+  private readonly getActivePolicies = async (req: Request, res: Response) => {
+    try {
+      const response = await publicPolicyController.list();
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  // get a specific policy by id (public endpoint)
+  private readonly getPolicyById = async (req: Request, res: Response) => {
+    try {
+      const response = await publicPolicyController.get(req.params[`uuid`]);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly init = () => {
+    // public endpoints
+    this.router.get(`/`, this.getActivePolicies);
+    this.router.get(`/:uuid`, this.getPolicyById);
+  };
+}
+
+const publicPolicyRouter = (new PublicPolicyRouter()).router;
+export default publicPolicyRouter;

package/src/v1/routes/services/public-service-router.ts

@@ -0,0 +1,89 @@
+import { Request, Response, Router } from 'express';
+import httpcodes from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+import publicServiceController from '../../controllers/services/public-service-controller';
+
+class PublicServiceRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly services = async (req: Request, res: Response) => {
+    try {
+      const response = await publicServiceController.services();
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly licenses = async (req: Request, res: Response) => {
+    try {
+      const response = await publicServiceController.licenses(req.params[`serviceUUID`], req.body);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly license = async (req: Request, res: Response) => {
+    try {
+      const response = await publicServiceController.license(req.params[`serviceUUID`], req.params[`licenseUUID`]);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly powerUps = async (req: Request, res: Response) => {
+    try {
+      const response = await publicServiceController.powerUps(req.params[`serviceUUID`], req.body);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly powerUp = async (req: Request, res: Response) => {
+    try {
+      const response = await publicServiceController.powerUp(req.params[`serviceUUID`], req.params[`licenseUUID`]);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly init = () => {
+    this.router.get(`/`, this.services);
+    this.router.post(`/:serviceUUID/licenses`, this.licenses);
+    this.router.get(`/:serviceUUID/licenses/:licenseUUID`, this.license);
+    this.router.post(`/:serviceUUID/power-ups`, this.powerUps);
+    this.router.get(`/:serviceUUID/power-ups/:licenseUUID`, this.powerUp);
+  };
+}
+
+const publicServiceRouter = (new PublicServiceRouter()).router;
+export default publicServiceRouter;

package/src/v1/routes/services/service-router.ts

@@ -0,0 +1,197 @@
+import { Request, Response, Router } from 'express';
+import httpcodes, { StatusCodes } from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+import serviceController from '../../controllers/services/service-controller';
+import organizationTokenMiddleware from '../../middlewares/auth/organization-token-middleware';
+import serviceTokenMiddleware from '../../middlewares/auth/service-token-middleware';
+import { Environment } from '../../types/auth/organization-token-types';
+import { ServiceEnvironment } from '../../types/services/service-types';
+
+class ServiceRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly token = async (req: Request, res: Response) => {
+    try {
+      await serviceTokenMiddleware.licenses(req[`service`], (req[`environment`] as Environment).organization);
+      res.json(req[`environment`]);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly service = async (req: Request, res: Response) => {
+    try {
+      res.json(req[`service`]);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly authorize = async (req: Request, res: Response) => {
+    try {
+      const response = await serviceController.authorize((req[`service-environment`] as ServiceEnvironment));
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly organization = async (req: Request, res: Response) => {
+    try {
+      const response = await serviceController.getOrganization((req[`service-environment`] as ServiceEnvironment));
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly organizationByUUID = async (req: Request, res: Response) => {
+    try {
+      const response = await serviceController.getOrganizationByUUID(req.params[`uuid`]);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly userByUUID = async (req: Request, res: Response) => {
+    try {
+      const response = await serviceController.getUserByUUID(req.params[`uuid`]);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly licenses = async (req: Request, res: Response) => {
+    try {
+      const response = await serviceController.getLicenses((req[`service-environment`] as ServiceEnvironment));
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly getQuota = async (req: Request, res: Response) => {
+    try {
+      const response = await serviceController.getQuota((req[`service-environment`] as ServiceEnvironment), req.query);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly checkQuota = async (req: Request, res: Response) => {
+    try {
+      await serviceController.checkQuota((req[`service-environment`] as ServiceEnvironment));
+      res.status(StatusCodes.NO_CONTENT).json();
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly validateQuotaUsage = async (req: Request, res: Response) => {
+    try {
+      const response = await serviceController.validateQuotaUsage((req[`service-environment`] as ServiceEnvironment), req.body);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly registerQuotaUsage = async (req: Request, res: Response) => {
+    try {
+      await serviceController.registerQuotaUsage((req[`service-environment`] as ServiceEnvironment), req.body);
+      res.status(StatusCodes.NO_CONTENT).json();
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly sendNotification = async (req: Request, res: Response) => {
+    try {
+      const response = await serviceController.sendNotification((req[`service-environment`] as ServiceEnvironment), req.body);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly init = () => {
+    this.router.use(serviceTokenMiddleware.validate);
+
+    this.router.get(`/`, this.service);
+    this.router.get(`/token`, organizationTokenMiddleware.exists, organizationTokenMiddleware.validate, this.token);
+
+    this.router.get(`/organizations/:uuid`, this.organizationByUUID);
+    this.router.get(`/users/:uuid`, this.userByUUID);
+
+    this.router.use(serviceTokenMiddleware.organization);
+    this.router.post(`/authorize`, this.authorize);
+    this.router.get(`/organization`, this.organization);
+    this.router.get(`/licenses`, this.licenses);
+
+    this.router.get(`/quota`, this.getQuota);
+    this.router.patch(`/quota`, this.checkQuota);
+    this.router.post(`/quota/valid`, this.validateQuotaUsage);
+    this.router.post(`/quota`, this.registerQuotaUsage);
+
+    this.router.post(`/notifications/send`, this.sendNotification);
+  };
+}
+
+const serviceRouter = (new ServiceRouter()).router;
+export default serviceRouter;

package/src/v1/routes/users/public-user-router.ts

@@ -0,0 +1,230 @@
+import { Request, Response, Router } from 'express';
+import httpcodes, { StatusCodes } from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+import publicUserController from '../../controllers/users/public-user-controller';
+import identityTokenMiddleware from '../../middlewares/auth/identity-token-middleware';
+import authorityMiddleware from '../../middlewares/authority-middleware';
+import userMiddleware from '../../middlewares/users/user-middleware';
+import { CommunicationType, User } from '../../types/admin/user-types';
+
+class PublicUserRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly register = async (req: Request, res: Response) => {
+    try {
+      const response = await publicUserController.register(req.body, `confirmation` in req.query);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly authority = async (req: Request, res: Response) => {
+    try {
+      const response = await publicUserController.authority(req.params[`uuid`]);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly get = async (req: Request, res: Response) => {
+    try {
+      const response = await publicUserController.get(req[`user`] as User);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly update = async (req: Request, res: Response) => {
+    try {
+      const response = await publicUserController.update((req[`user`] as User), req.body);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly delete = async (req: Request, res: Response) => {
+    try {
+      await publicUserController.delete((req[`user`] as User));
+      res.status(StatusCodes.NO_CONTENT).json();
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly information = async (req: Request, res: Response) => {
+    try {
+      const response = await publicUserController.getInformation((req[`user`] as User));
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly confirm = async (req: Request, res: Response) => {
+    try {
+      const response = await publicUserController.confirm(req[`user`], req.body);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly requestConfirmation = async (req: Request, res: Response) => {
+    try {
+      await publicUserController.requestConfirmation(req[`user`]);
+      res.status(StatusCodes.NO_CONTENT).json();
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly organizations = async (req: Request, res: Response) => {
+    try {
+      const response = await publicUserController.organizations(req[`user`]);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly invite = async (req: Request, res: Response) => {
+    try {
+      await publicUserController.invite(req[`user`], req.params[`uuid`], req.body);
+      res.status(StatusCodes.NO_CONTENT).json();
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly leave = async (req: Request, res: Response) => {
+    try {
+      await publicUserController.leave(req[`user`], req.params[`uuid`]);
+      res.status(StatusCodes.NO_CONTENT).json();
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  // policy-related endpoints
+  private readonly getPendingUserPolicies = async (req: Request, res: Response) => {
+    try {
+      const response = await publicUserController.getPendingUserPolicies(req[`user`] as User);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly acceptPolicies = async (req: Request, res: Response) => {
+    try {
+      await publicUserController.acceptPolicies(req[`user`] as User, req.body);
+      res.status(StatusCodes.NO_CONTENT).json();
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  // communications endpoints
+  private readonly unsubscribeByToken = async (req: Request, res: Response) => {
+    try {
+      await publicUserController.unsubscribeByUuid(req.params[`uuid`], req.params[`type`] as CommunicationType);
+      res.status(httpcodes.NO_CONTENT).send();
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly init = () => {
+
+    this.router.post(`/`, this.register);
+    this.router.delete(`/communications/:type/unsubscribe/:uuid`, this.unsubscribeByToken);
+
+    this.router.get(`/authority/:uuid`, authorityMiddleware.service, this.authority);
+
+    this.router.use(identityTokenMiddleware.exists, identityTokenMiddleware.validate);
+    this.router.get(`/`, this.get);
+    this.router.patch(`/`, this.update);
+    this.router.delete(`/`, this.delete);
+
+    this.router.get(`/information`, this.information);
+
+    this.router.post(`/confirm`, userMiddleware.pending, this.confirm);
+    this.router.patch(`/confirm`, userMiddleware.pending, this.requestConfirmation);
+
+    this.router.use(userMiddleware.active);
+    this.router.get(`/organizations`, this.organizations);
+    this.router.post(`/organizations/:uuid/invite`, this.invite);
+    this.router.delete(`/organizations/:uuid`, this.leave);
+
+    this.router.get(`/policies`, this.getPendingUserPolicies);
+    this.router.post(`/policies`, this.acceptPolicies);
+  };
+}
+
+const publicUserRouter = (new PublicUserRouter()).router;
+export default publicUserRouter;