prow-authority 3.6.3

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

@@ -0,0 +1,227 @@
+import { NextFunction, Request, Response, Router } from 'express';
+import { billing } from '../../middlewares/static/static-middleware';
+import httpcodes from 'http-status-codes';
+import billingController from '../../controllers/billing/billing-controller';
+import APIError from '../../../helpers/api-error';
+import organizationController from '../../controllers/admin/organization-controller';
+import { Organization, OrganizationStatus } from '../../types/admin/organization-types';
+
+class BillingRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly test_asOrganization = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const organizationUUID = (req.query[`organization`] as string || ``).trim();
+      if (!organizationUUID) { throw new Error(`Missing or invalid 'organization' query parameter`); }
+
+      // validate organization
+      const org = (await organizationController.list({ uuid: organizationUUID, status: { is: OrganizationStatus.Blocked, inverse: true } }))[0];
+      if (!org) { throw new Error(`Invalid 'organization' query parameter value: unknown organization`); }
+
+      (req[`organization`] as Organization) = org;
+
+      next();
+    } catch (e) {
+      console.log(e);
+      res.status(httpcodes.UNAUTHORIZED).json({ error: e.message || e });
+    }
+  };
+
+  private readonly test_generateCycle = async (req: Request, res: Response) => {
+    try {
+      const response = await billingController.generateCycle((req[`organization`] as Organization), 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 test_generateInvoice = async (req: Request, res: Response) => {
+    try {
+      const response = await billingController.generateLicensesInvoice((req[`organization`] as Organization), 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 getInvoices = async (req: Request, res: Response) => {
+    try {
+      const response = await billingController.getInvoices(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 updateInvoice = async (req: Request, res: Response) => {
+    try {
+      const response = await billingController.updateInvoice(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 invoiceEmitted = async (req: Request, res: Response) => {
+    try {
+      const response = await billingController.invoiceEmitted(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 invoicePaid = async (req: Request, res: Response) => {
+    try {
+      const response = await billingController.invoicePaid(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 getAccountingSeats = async (req: Request, res: Response) => {
+    try {
+      const response = await billingController.getAccountingSeats(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 accountingSeatDone = async (req: Request, res: Response) => {
+    try {
+      const response = await billingController.accountingSeatDone(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 blockOrganization = async (req: Request, res: Response) => {
+    try {
+      const response = await billingController.blockOrganization(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 unblockOrganization = async (req: Request, res: Response) => {
+    try {
+      const response = await billingController.unblockOrganization(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 organizationAccountingData = async (req: Request, res: Response) => {
+    try {
+      const response = await billingController.organizationAccountingData(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 organizationPaymentData = async (req: Request, res: Response) => {
+    try {
+      const response = await billingController.organizationPaymentData(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 check = async (req: Request, res: Response) => {
+    try {
+      const response = { valid: true };
+      res.json(response);
+    } catch (e) {
+      res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+    }
+  };
+
+  private readonly init = () => {
+    this.router.use(billing);
+
+    this.router.get(`/check`, this.check);
+
+    this.router.post(`/invoices`, this.getInvoices);
+    this.router.post(`/invoices/:uuid/emitted`, this.invoiceEmitted);
+    this.router.post(`/invoices/:uuid/paid`, this.invoicePaid);
+    this.router.patch(`/invoices/:uuid`, this.updateInvoice);
+
+    this.router.post(`/accounting-seats`, this.getAccountingSeats);
+    this.router.post(`/accounting-seats/:uuid/done`, this.accountingSeatDone);
+
+    this.router.patch(`/organizations/:uuid/block`, this.blockOrganization);
+    this.router.patch(`/organizations/:uuid/unblock`, this.unblockOrganization);
+    this.router.get(`/organizations/:uuid/accounting`, this.organizationAccountingData);
+    this.router.get(`/organizations/:uuid/payment`, this.organizationPaymentData);
+
+    // for testing purposes
+    this.router.use(this.test_asOrganization);
+    this.router.post(`/cycles/generate`, this.test_generateCycle);
+    this.router.post(`/invoices/generate`, this.test_generateInvoice);
+  };
+}
+
+const billingRouter = (new BillingRouter()).router;
+export default billingRouter;

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

@@ -0,0 +1,48 @@
+import { Request, Response, Router } from 'express';
+import httpcodes from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+import publicOrganizationController from '../../controllers/organizations/public-organization-controller';
+import { Environment } from '../../types/auth/organization-token-types';
+
+class InvoiceRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly listInvoices = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.listInvoices(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 getInvoicePDF = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.getInvoicePDF(req[`environment`] as Environment, 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 = () => {
+    this.router.post(`/list`, this.listInvoices);
+    this.router.get(`/:uuid`, this.getInvoicePDF);
+  };
+}
+
+const invoiceRouter = (new InvoiceRouter()).router;
+export default invoiceRouter;

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

@@ -0,0 +1,104 @@
+import { Request, Response, Router } from 'express';
+import httpcodes from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+import publicOrganizationController from '../../controllers/organizations/public-organization-controller';
+import { Environment } from '../../types/auth/organization-token-types';
+
+class PaymentMethodRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly setupPaymentMethod = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.setupPaymentMethod(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 getPaymentMethod = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.getPaymentMethod(req[`environment`] as Environment, 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 listPaymentMethods = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.listPaymentMethods(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 addPaymentMethod = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.addPaymentMethod(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 updatePaymentMethod = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.updatePaymentMethod(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 deletePaymentMethod = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.deletePaymentMethod(req[`environment`] as Environment, 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 = () => {
+    this.router.post(`/setup`, this.setupPaymentMethod);
+    this.router.post(`/list`, this.listPaymentMethods);
+    this.router.get(`/:uuid`, this.getPaymentMethod);
+    this.router.post(`/`, this.addPaymentMethod);
+    this.router.patch(`/:uuid`, this.updatePaymentMethod);
+    this.router.delete(`/:uuid`, this.deletePaymentMethod);
+  };
+}
+
+const paymentMethodRouter = (new PaymentMethodRouter()).router;
+export default paymentMethodRouter;

package/src/v1/routes/organizations/public-organization-router.ts

@@ -0,0 +1,319 @@
+import { Request, Response, Router } from 'express';
+import httpcodes, { StatusCodes } from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+import publicOrganizationController from '../../controllers/organizations/public-organization-controller';
+import identityTokenMiddleware from '../../middlewares/auth/identity-token-middleware';
+import organizationTokenMiddleware from '../../middlewares/auth/organization-token-middleware';
+import authorityMiddleware from '../../middlewares/authority-middleware';
+import organizationMiddleware from '../../middlewares/organizations/organization-middleware';
+import userMiddleware from '../../middlewares/users/user-middleware';
+import { User } from '../../types/admin/user-types';
+import { Environment } from '../../types/auth/organization-token-types';
+import usersRouter from './users-router';
+import paymentMethodRouter from './payments-router';
+import invoiceRouter from './invoices-router';
+
+class PublicOrganizationRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly create = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.create(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 authority = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.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 publicOrganizationController.get(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 update = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.update((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 delete = async (req: Request, res: Response) => {
+    try {
+      await publicOrganizationController.delete((req[`environment`] as Environment), `force` in req.query);
+      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 ownership = async (req: Request, res: Response) => {
+    try {
+      await publicOrganizationController.ownership(req[`environment`] as Environment, 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 getServiceLicenses = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.getServiceLicenses(req[`environment`] as Environment, req.params[`service`], 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 activateServiceLicense = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.activateServiceLicense(req[`environment`] as Environment, req.params[`service`], req.body);
+      res.json(response);
+    } catch (e) {
+      console.log(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 renewServiceLicense = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.renewServiceLicense(req[`environment`] as Environment, req.params[`service`], req.params[`uuid`]);
+      res.status(response ? StatusCodes.OK : StatusCodes.NO_CONTENT).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 cancelServiceLicense = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.cancelServiceLicense(req[`environment`] as Environment, req.params[`service`], req.params[`uuid`]);
+      res.status(response ? StatusCodes.OK : StatusCodes.NO_CONTENT).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 getServicePowerUps = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.getServicePowerUps(req[`environment`] as Environment, req.params[`service`], 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 activateServicePowerUp = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.activateServicePowerUp(req[`environment`] as Environment, req.params[`service`], 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 cancelServicePowerUp = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.cancelServicePowerUp(req[`environment`] as Environment, req.params[`service`], req.params[`uuid`]);
+      res.status(response ? StatusCodes.OK : StatusCodes.NO_CONTENT).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 endTrial = async (req: Request, res: Response) => {
+    try {
+      await publicOrganizationController.endTrial(req[`environment`] as Environment);
+      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 getServices = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.getServices(req[`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 getServiceQuota = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.getServiceQuota(req[`environment`] as Environment, req.params[`service`], 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 checkServiceQuota = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.checkServiceQuota(req[`environment`] as Environment, req.params[`service`]);
+      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 updateOverconsume = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.updateOverconsume(req[`environment`] as Environment, req.params[`service`], 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 information = async (req: Request, res: Response) => {
+    try {
+      const response = await publicOrganizationController.getInformation(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 init = () => {
+    this.router.post(`/`, identityTokenMiddleware.exists, identityTokenMiddleware.validate, userMiddleware.active, this.create);
+
+    this.router.get(`/authority/:uuid`, authorityMiddleware.service, this.authority);
+
+    this.router.use(organizationTokenMiddleware.exists, organizationTokenMiddleware.validate);
+
+    this.router.get(`/`, this.get);
+
+    this.router.use(`/users`, usersRouter);
+
+    // read-only information public for all organization members
+    this.router.get(`/services`, this.getServices);
+    this.router.get(`/services/:service/licenses`, this.getServiceLicenses);
+    this.router.get(`/services/:service/power-ups`, this.getServicePowerUps);
+    this.router.get(`/services/:service/quota`, this.getServiceQuota);
+
+    this.router.use(organizationMiddleware.admin);
+
+    this.router.patch(`/`, this.update);
+
+    this.router.use(organizationMiddleware.active);
+
+    this.router.delete(`/trial`, this.endTrial);
+
+    this.router.patch(`/services/:service/overconsume`, this.updateOverconsume);
+    this.router.patch(`/services/:service/quota`, this.checkServiceQuota);
+
+    this.router.post(`/services/:service/licenses`, this.activateServiceLicense);
+    this.router.post(`/services/:service/licenses/:uuid/renew`, this.renewServiceLicense);
+    this.router.delete(`/services/:service/licenses/:uuid`, this.cancelServiceLicense);
+
+    this.router.post(`/services/:service/power-ups`, this.activateServicePowerUp);
+    this.router.delete(`/services/:service/power-ups/:uuid`, this.cancelServicePowerUp);
+
+    this.router.use(`/payments`, paymentMethodRouter);
+    this.router.use(`/invoices`, invoiceRouter);
+
+    this.router.use(organizationMiddleware.owner);
+
+    this.router.delete(`/`, this.delete);
+    this.router.patch(`/ownership`, this.ownership);
+    this.router.get(`/information`, this.information);
+  };
+}
+
+const publicOrganizationRouter = (new PublicOrganizationRouter()).router;
+export default publicOrganizationRouter;