prow-authority 3.6.3

package/src/v1/routes/admin/payment-method-router.ts

@@ -0,0 +1,89 @@
+import { Request, Router, Response } from 'express';
+import paymentMethodController from '../../controllers/admin/payment-method-controller';
+import httpcodes from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+
+class PaymentMethodRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly get = async (req: Request, res: Response) => {
+    try {
+      const response = await paymentMethodController.get(parseInt(req.params[`id`], 10));
+      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 list = async (req: Request, res: Response) => {
+    try {
+      const response = await paymentMethodController.list(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 add = async (req: Request, res: Response) => {
+    try {
+      const response = await paymentMethodController.add(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 update = async (req: Request, res: Response) => {
+    try {
+      const response = await paymentMethodController.update(parseInt(req.params[`id`], 10), 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 {
+      const response = await paymentMethodController.delete(parseInt(req.params[`id`], 10));
+      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(`/:id`, this.get);
+    this.router.post(`/list`, this.list);
+    this.router.post(`/`, this.add);
+    this.router.put(`/:id`, this.update);
+    this.router.delete(`/:id`, this.delete);
+  };
+}
+
+const paymentMethodRouter = (new PaymentMethodRouter()).router;
+export default paymentMethodRouter;

package/src/v1/routes/admin/policy-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 policyController from '../../controllers/admin/policy-controller';
+
+class PolicyRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly get = async (req: Request, res: Response) => {
+    try {
+      const response = await policyController.get(parseInt(req.params.id, 10));
+      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 list = async (req: Request, res: Response) => {
+    try {
+      const response = await policyController.list(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 add = async (req: Request, res: Response) => {
+    try {
+      const response = await policyController.add(req.body);
+      res.status(httpcodes.CREATED).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 policyController.update(parseInt(req.params.id, 10), 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 {
+      const response = await policyController.delete(parseInt(req.params.id, 10));
+      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(`/:id`, this.get);
+    this.router.post(`/list`, this.list);
+    this.router.post(`/`, this.add);
+    this.router.put(`/:id`, this.update);
+    this.router.delete(`/:id`, this.delete);
+  };
+}
+
+const policyRouter = (new PolicyRouter()).router;
+export default policyRouter;

package/src/v1/routes/admin/policy-version-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 policyVersionController from '../../controllers/admin/policy-version-controller';
+
+class PolicyVersionRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly get = async (req: Request, res: Response) => {
+    try {
+      const response = await policyVersionController.get(parseInt(req.params.id, 10));
+      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 list = async (req: Request, res: Response) => {
+    try {
+      const response = await policyVersionController.list(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 add = async (req: Request, res: Response) => {
+    try {
+      const response = await policyVersionController.add(req.body);
+      res.status(httpcodes.CREATED).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 policyVersionController.update(parseInt(req.params.id, 10), 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 {
+      const response = await policyVersionController.delete(parseInt(req.params.id, 10));
+      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(`/:id`, this.get);
+    this.router.post(`/list`, this.list);
+    this.router.post(`/`, this.add);
+    this.router.put(`/:id`, this.update);
+    this.router.delete(`/:id`, this.delete);
+  };
+}
+
+const policyVersionRouter = (new PolicyVersionRouter()).router;
+export default policyVersionRouter;

package/src/v1/routes/admin/schedule-router.ts

@@ -0,0 +1,75 @@
+import { Request, Router, Response } from 'express';
+import scheduleController from '../../controllers/admin/schedule-controller';
+import httpcodes, { StatusCodes } from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+
+class ScheduleRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly limits = async (req: Request, res: Response) => {
+    try {
+      await scheduleController.limits();
+      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 licenseChangeFallback = async (req: Request, res: Response) => {
+    try {
+      await scheduleController.licenseChangeFallback();
+      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 billingCycles = async (req: Request, res: Response) => {
+    try {
+      await scheduleController.billingCycles();
+      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 invoices = async (req: Request, res: Response) => {
+    try {
+      await scheduleController.invoices();
+      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.post(`/limits`, this.limits);
+    this.router.post(`/licenses`, this.licenseChangeFallback);
+    this.router.post(`/billing-cycles`, this.billingCycles);
+    this.router.post(`/invoices`, this.invoices);
+  };
+}
+
+const scheduleRouter = (new ScheduleRouter()).router;
+export default scheduleRouter;

package/src/v1/routes/admin/service-notification-router.ts

@@ -0,0 +1,98 @@
+import { Request, Router, Response } from 'express';
+import serviceNotificationController from '../../controllers/admin/service-notification-controller';
+import httpcodes from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+
+class ServiceNotificationRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly get = async (req: Request, res: Response) => {
+    try {
+      const response = await serviceNotificationController.get(parseInt(req.params[`id`], 10));
+      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 list = async (req: Request, res: Response) => {
+    try {
+      const response = await serviceNotificationController.list(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 add = async (req: Request, res: Response) => {
+    try {
+      if (Array.isArray(req.body)) {
+        const results: any[] = [];
+        for (const item of req.body) {
+          const r = await serviceNotificationController.add(item);
+          results.push(r);
+        }
+        res.json(results);
+      } else {
+        const response = await serviceNotificationController.add(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 update = async (req: Request, res: Response) => {
+    try {
+      const response = await serviceNotificationController.update(parseInt(req.params[`id`], 10), 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 {
+      const response = await serviceNotificationController.delete(parseInt(req.params[`id`], 10));
+      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(`/:id`, this.get);
+    this.router.post(`/list`, this.list);
+    this.router.post(`/`, this.add);
+    this.router.put(`/:id`, this.update);
+    this.router.delete(`/:id`, this.delete);
+  };
+}
+
+const serviceNotificationRouter = (new ServiceNotificationRouter()).router;
+export default serviceNotificationRouter;

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

@@ -0,0 +1,89 @@
+import { Request, Router, Response } from 'express';
+import serviceController from '../../controllers/admin/service-controller';
+import httpcodes from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+
+class ServiceRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly get = async (req: Request, res: Response) => {
+    try {
+      const response = await serviceController.get(parseInt(req.params[`id`], 10));
+      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 list = async (req: Request, res: Response) => {
+    try {
+      const response = await serviceController.list(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 add = async (req: Request, res: Response) => {
+    try {
+      const response = await serviceController.add(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 update = async (req: Request, res: Response) => {
+    try {
+      const response = await serviceController.update(parseInt(req.params[`id`], 10), 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 {
+      const response = await serviceController.delete(parseInt(req.params[`id`], 10));
+      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(`/:id`, this.get);
+    this.router.post(`/list`, this.list);
+    this.router.post(`/`, this.add);
+    this.router.put(`/:id`, this.update);
+    this.router.delete(`/:id`, this.delete);
+  };
+}
+
+const serviceRouter = (new ServiceRouter()).router;
+export default serviceRouter;

package/src/v1/routes/admin/user-organization-router.ts

@@ -0,0 +1,89 @@
+import { Request, Router, Response } from 'express';
+import userOrganizationController from '../../controllers/admin/user-organization-controller';
+import httpcodes from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+
+class UserOrganizationRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly get = async (req: Request, res: Response) => {
+    try {
+      const response = await userOrganizationController.get(parseInt(req.params[`id`], 10));
+      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 list = async (req: Request, res: Response) => {
+    try {
+      const response = await userOrganizationController.list(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 add = async (req: Request, res: Response) => {
+    try {
+      const response = await userOrganizationController.add(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 update = async (req: Request, res: Response) => {
+    try {
+      const response = await userOrganizationController.update(parseInt(req.params[`id`], 10), 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 {
+      const response = await userOrganizationController.delete(parseInt(req.params[`id`], 10));
+      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(`/:id`, this.get);
+    this.router.post(`/list`, this.list);
+    this.router.post(`/`, this.add);
+    this.router.put(`/:id`, this.update);
+    this.router.delete(`/:id`, this.delete);
+  };
+}
+
+const userOrganizationRouter = (new UserOrganizationRouter()).router;
+export default userOrganizationRouter;