prow-authority 3.6.3

package/src/v1/routes/admin/billing-cycle-router.ts

@@ -0,0 +1,89 @@
+import { Request, Router, Response } from 'express';
+import billingCycleController from '../../controllers/admin/billing-cycle-controller';
+import httpcodes from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+
+class BillingCycleRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly get = async (req: Request, res: Response) => {
+    try {
+      const response = await billingCycleController.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 billingCycleController.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 billingCycleController.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 billingCycleController.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 billingCycleController.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 billingCycleRouter = (new BillingCycleRouter()).router;
+export default billingCycleRouter;

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

@@ -0,0 +1,89 @@
+import { Request, Router, Response } from 'express';
+import invoiceController from '../../controllers/admin/invoice-controller';
+import httpcodes from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+
+class InvoiceRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly get = async (req: Request, res: Response) => {
+    try {
+      const response = await invoiceController.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 invoiceController.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 invoiceController.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 invoiceController.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 invoiceController.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 invoiceRouter = (new InvoiceRouter()).router;
+export default invoiceRouter;

package/src/v1/routes/admin/license-limit-router.ts

@@ -0,0 +1,89 @@
+import { Request, Router, Response } from 'express';
+import licenseLimitController from '../../controllers/admin/license-limit-controller';
+import httpcodes from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+
+class LicenseLimitRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly get = async (req: Request, res: Response) => {
+    try {
+      const response = await licenseLimitController.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 licenseLimitController.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 licenseLimitController.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 licenseLimitController.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 licenseLimitController.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 licenseLimitRouter = (new LicenseLimitRouter()).router;
+export default licenseLimitRouter;

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

@@ -0,0 +1,89 @@
+import { Request, Router, Response } from 'express';
+import licenseController from '../../controllers/admin/license-controller';
+import httpcodes from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+
+class LicenseRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly get = async (req: Request, res: Response) => {
+    try {
+      const response = await licenseController.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 licenseController.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 licenseController.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 licenseController.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 licenseController.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 licenseRouter = (new LicenseRouter()).router;
+export default licenseRouter;

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

@@ -0,0 +1,61 @@
+import { Request, Response, Router } from 'express';
+import httpcodes from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+import notificationController from '../../controllers/admin/notification-controller';
+
+class NotificationRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly confirmation = async (req: Request, res: Response) => {
+    try {
+      const response = await notificationController.confirmation(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 password = async (req: Request, res: Response) => {
+    try {
+      const response = await notificationController.password(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 otp = async (req: Request, res: Response) => {
+    try {
+      const response = await notificationController.otp(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.post(`/:id/confirmation`, this.confirmation);
+    this.router.post(`/:id/password`, this.password);
+    this.router.post(`/:id/otp`, this.otp);
+  };
+}
+
+const notificationRouter = (new NotificationRouter()).router;
+export default notificationRouter;

package/src/v1/routes/admin/organization-license-limit-router.ts

@@ -0,0 +1,89 @@
+import { Request, Router, Response } from 'express';
+import organizationLicenseLimitController from '../../controllers/admin/organization-license-limit-controller';
+import httpcodes from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+
+class OrganizationLicenseLimitRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly get = async (req: Request, res: Response) => {
+    try {
+      const response = await organizationLicenseLimitController.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 organizationLicenseLimitController.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 organizationLicenseLimitController.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 organizationLicenseLimitController.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 organizationLicenseLimitController.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 organizationLicenseLimitRouter = (new OrganizationLicenseLimitRouter()).router;
+export default organizationLicenseLimitRouter;

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

@@ -0,0 +1,89 @@
+import { Request, Router, Response } from 'express';
+import organizationLicenseController from '../../controllers/admin/organization-license-controller';
+import httpcodes from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+
+class OrganizationLicenseRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly get = async (req: Request, res: Response) => {
+    try {
+      const response = await organizationLicenseController.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 organizationLicenseController.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 organizationLicenseController.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 organizationLicenseController.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 organizationLicenseController.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 organizationLicenseRouter = (new OrganizationLicenseRouter()).router;
+export default organizationLicenseRouter;

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

@@ -0,0 +1,89 @@
+import { Request, Router, Response } from 'express';
+import organizationController from '../../controllers/admin/organization-controller';
+import httpcodes from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+
+class OrganizationRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly get = async (req: Request, res: Response) => {
+    try {
+      const response = await organizationController.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 organizationController.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 organizationController.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 organizationController.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 organizationController.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 organizationRouter = (new OrganizationRouter()).router;
+export default organizationRouter;