prow-authority 3.6.3

package/src/v1/controllers/policies/public-policy-controller.ts

@@ -0,0 +1,68 @@
+import { Date2 } from '@beseif-solutions/utility-functions/dist/utils/date-utils';
+import APIError, { StatusCodes } from '../../../helpers/api-error';
+import { Policy } from '../../types/admin/policy-types';
+import { PolicyVersion } from '../../types/admin/policy-version-types';
+import { PublicPolicy } from '../../types/policies/public-policy-types';
+import policyController from '../admin/policy-controller';
+import policyVersionController from '../admin/policy-version-controller';
+
+class PublicPolicyController {
+
+  public readonly getLatestVersion = async (id: number): Promise<PolicyVersion> => {
+    try {
+      const versions = await policyVersionController.list(
+        { policy: id },
+        { order: { by: [`effective_date`], direction: `descendent` } },
+      );
+      return (versions.filter(v => new Date2(v.effective_date).isPast()))[0];
+    } catch (e) { throw e; }
+  };
+
+  public readonly list = async (): Promise<PublicPolicy[]> => {
+    try {
+      const policies = await policyController.list({});
+      return await this.parsePolicies(policies);
+    } catch (e) { throw e; }
+  };
+
+  public readonly get = async (uuid: string): Promise<PublicPolicy[]> => {
+    try {
+      const policy = (await policyController.list({ uuid: uuid }))[0];
+      if (!policy) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Policy ${uuid} not found.`,
+        });
+      }
+      return await this.parsePolicies([policy]);
+    } catch (e) { throw e; }
+  };
+
+  public readonly parsePolicies = async (policies: Policy[]): Promise<PublicPolicy[]> => {
+    try {
+      const parsed: PublicPolicy[] = [];
+
+      for (const policy of policies) {
+        const currentVersion = await this.getLatestVersion(policy.id);
+        const p: PublicPolicy = {
+          uuid: policy.uuid,
+          name: policy.name,
+          current_version: currentVersion ? {
+            version: currentVersion.version,
+            url: currentVersion.url,
+            metadata: currentVersion.metadata,
+            created_date: currentVersion.created_date,
+            effective_date: currentVersion.effective_date,
+          } : null,
+          metadata: policy.metadata,
+        };
+        parsed.push(p);
+      }
+
+      return parsed;
+    } catch (e) { throw e; }
+  };
+}
+
+const publicPolicyController = new PublicPolicyController();
+export default publicPolicyController;

package/src/v1/controllers/services/public-service-controller.ts

@@ -0,0 +1,177 @@
+import { Validator } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+import APIError, { StatusCodes } from "../../../helpers/api-error";
+import { License, LicenseType } from "../../types/admin/license-types";
+import { Service } from "../../types/admin/service-types";
+import { ListLicenseParams, PublicLicense, PublicService } from "../../types/services/public-service-types";
+import licenseController from "../admin/license-controller";
+import licenseLimitController from "../admin/license-limit-controller";
+import serviceController from "../admin/service-controller";
+import { listLicensesSchema } from "../../schemas/services/public-service-schemas";
+import _ from "lodash";
+
+class PublicServiceController {
+
+  public readonly services = async (): Promise<PublicService[]> => {
+    try {
+      const services = await serviceController.list({ enabled: true });
+      return await this.parseServices(services);
+    } catch (e) { throw e; }
+  };
+
+
+  public readonly licenses = async (serviceUUID: string, params: ListLicenseParams): Promise<PublicLicense[]> => {
+    try {
+      Validator.validate(listLicensesSchema, params);
+
+      const service = (await serviceController.list({ uuid: serviceUUID, enabled: true }))[0];
+      if (!service) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Service ${serviceUUID} not found.`,
+        });
+      }
+
+      const licenses = await licenseController.list({
+        service: service.id,
+        type: LicenseType.Base,
+        public: true,
+        enabled: true,
+        ...params,
+      });
+
+      return await this.parseLicenses(licenses);
+    } catch (e) {
+      console.log(e);
+      throw e;
+    }
+  };
+
+  public readonly license = async (serviceUUID: string, licenseUUID: string): Promise<PublicLicense[]> => {
+    try {
+      const service = (await serviceController.list({ uuid: serviceUUID, enabled: true }))[0];
+      if (!service) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Service ${serviceUUID} not found.`,
+        });
+      }
+
+      const licenses = await licenseController.list({
+        uuid: licenseUUID,
+        service: service.id,
+        type: LicenseType.Base,
+        enabled: true,
+      });
+
+      return await this.parseLicenses(licenses);
+    } catch (e) {
+      console.log(e);
+      throw e;
+    }
+  };
+
+  public readonly powerUps = async (serviceUUID: string, params: ListLicenseParams): Promise<PublicLicense[]> => {
+    try {
+      Validator.validate(listLicensesSchema, params);
+
+      const service = (await serviceController.list({ uuid: serviceUUID, enabled: true }))[0];
+      if (!service) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Service ${serviceUUID} not found.`,
+        });
+      }
+
+      const licenses = await licenseController.list({
+        service: service.id,
+        type: LicenseType.Variant,
+        public: true,
+        enabled: true,
+        ...params,
+      });
+
+      return await this.parseLicenses(licenses);
+    } catch (e) { throw e; }
+  };
+
+  public readonly powerUp = async (serviceUUID: string, licenseUUID: string): Promise<PublicLicense[]> => {
+    try {
+      const service = (await serviceController.list({ uuid: serviceUUID, enabled: true }))[0];
+      if (!service) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `Service ${serviceUUID} not found.`,
+        });
+      }
+
+      const licenses = await licenseController.list({
+        uuid: licenseUUID,
+        service: service.id,
+        type: LicenseType.Variant,
+        enabled: true,
+      });
+
+      return await this.parseLicenses(licenses);
+    } catch (e) { throw e; }
+  };
+
+  public readonly parseServices = async (records: Service[]): Promise<PublicService[]> => {
+    try {
+      const response: PublicService[] = [];
+      for (const record of records) {
+        response.push({
+          uuid: record.uuid,
+          properties: record.properties,
+          preferences: record.preferences,
+          created_date: record.created_date,
+          modified_date: record.modified_date,
+          metadata: record.metadata,
+        });
+      }
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly parseLicenses = async (records: License[]): Promise<PublicLicense[]> => {
+    try {
+      const [limits, associatedLicenses] = await Promise.all([
+        licenseLimitController.list({ license: { in: records.map((l) => l.id) } }),
+        licenseController.list({ id: { in: _.compact(records.map((r) => r.associated)) } }),
+      ]);
+
+      const response: PublicLicense[] = [];
+      for (const record of records) {
+        const licenseLimits = limits.filter((l) => l.license === record.id);
+        response.push({
+          uuid: record.uuid,
+          type: record.type,
+          associated: record.associated ?
+            associatedLicenses.find((l) => l.id === record.associated)?.uuid || null
+            : null,
+          properties: record.properties,
+          data: record.data,
+          annual_price: record.annual_price,
+          monthly_price: record.monthly_price,
+          limits: licenseLimits.map((ll) => ({
+            name: ll.name,
+            limit: ll.limit,
+            period: ll.period,
+            monthly_price_abs: ll.monthly_price_abs,
+            annual_price_abs: ll.annual_price_abs,
+            overconsume_monthly_price_per_unit: ll.overconsume_monthly_price_per_unit,
+            overconsume_annual_price_per_unit: ll.overconsume_annual_price_per_unit,
+            metadata: ll.metadata,
+          })),
+          created_date: record.created_date,
+          modified_date: record.modified_date,
+          metadata: record.metadata,
+        });
+      }
+      return response;
+    } catch (e) { throw e; }
+  };
+
+}
+
+const publicServiceController = new PublicServiceController();
+export default publicServiceController;