Merge pull request #139 from companieshouse/feature/faml-746-psc-discrepancies

Feature/faml 746 psc discrepancies

Author: CH-JonathanBlake

src/services/psc-discrepancies-report/index.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export { default as PSCDiscrepanciesReportService } from "./service";

src/services/psc-discrepancies-report/service.ts

@@ -0,0 +1,46 @@
+import { IHttpClient } from "../../http";
+import { PSCDiscrepancyReport } from "./types"
+import Util from "./util"
+import { Result } from "services/result";
+import { ApiResponse, ApiErrorResponse } from "services/resource";
+
+const PSC_DISCREPANCY_API_URL = "/psc-discrepancy-reports";
+
+type PromisedReportResult= Promise<Result<ApiResponse<PSCDiscrepancyReport>, ApiErrorResponse>>;
+
+export default class {
+    utility: Util;
+    constructor (private readonly client: IHttpClient) { this.utility = new Util() }
+
+    public async getReport (reportId: string): PromisedReportResult {
+        return this.getReportBySelfLink(this.buildSelfLink(reportId));
+    }
+
+    public async getReportBySelfLink (selfLink: string): PromisedReportResult {
+        const resp = await this.client.httpGet(`${selfLink}`);
+        return this.utility.processResponse(resp);
+    }
+
+    public async createNewReport (obligedEntityType: String): PromisedReportResult {
+        const resp = await this.client.httpPost(
+            PSC_DISCREPANCY_API_URL,
+            {
+                obligedEntityType: obligedEntityType,
+                status: "INCOMPLETE"
+            });
+        return this.utility.processResponse(resp);
+    }
+
+    public async updateReport (reportId: string, report: PSCDiscrepancyReport): PromisedReportResult {
+        return this.updateReportBySelfLink(this.buildSelfLink(reportId), report);
+    }
+
+    public async updateReportBySelfLink (selfLink: string, report: PSCDiscrepancyReport): PromisedReportResult {
+        const resp = await this.client.httpPut(selfLink, report);
+        return this.utility.processResponse(resp);
+    }
+
+    private buildSelfLink (reportId: string): string {
+        return `${PSC_DISCREPANCY_API_URL}/${reportId}`;
+    }
+}

src/services/psc-discrepancies-report/types.ts

@@ -0,0 +1,18 @@
+export interface PSCDiscrepancyReport {
+    obliged_entity_organisation_name: string;
+    obliged_entity_name: string;
+    obliged_entity_contact_name: string;
+    obliged_entity_email: string;
+    obliged_entity_telephone_number: string;
+    obliged_entity_type: string;
+    company_number: string;
+    submission_reference: string;
+    status: string;
+    etag: string;
+    kind: string;
+    links: LinksResource;
+}
+
+export interface LinksResource {
+    self: string;
+}

src/services/psc-discrepancies-report/util.ts

@@ -0,0 +1,41 @@
+import { HttpResponse } from "../../http";
+import Resource, { ApiErrorResponse, ApiError, ApiResponse } from "../../services/resource";
+import { failure, success, Result, Success, Failure } from "../result";
+import Mapping from "../../mapping/mapping";
+
+type NestedErrors = { errors: ApiError[] }
+
+export default class {
+    constructor () { }
+
+    processResponse (resp: HttpResponse): Result<ApiResponse<any>, ApiErrorResponse> {
+        if (resp.error) {
+            const error: ApiErrorResponse = {
+                httpStatusCode: resp.status,
+                errors: this.buildErrors(resp.error)
+            };
+            return failure(error);
+        } else {
+            return success({
+                httpStatusCode: resp.status,
+                headers: resp.headers,
+                resource: resp.body
+            })
+        }
+    }
+
+    private buildErrors (errors: string | NestedErrors): ApiError[] {
+        if (typeof errors === "string") {
+            const ret: ApiError = {
+                error: errors
+            };
+            return [ret];
+        } else if ((errors as NestedErrors).errors) {
+            return (errors as NestedErrors).errors.reduce<ApiError[]>((previousValue, currentValue) => {
+                return [...previousValue, Mapping.camelCaseKeys(currentValue)]
+            }, []);
+        } else {
+            return [];
+        }
+    }
+}

src/services/psc-discrepancies/index.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export { default as PSCDiscrepanciesService } from "./service";

src/services/psc-discrepancies/service.ts

@@ -0,0 +1,33 @@
+import { IHttpClient } from "../../http";
+import { ApiErrorResponse, ApiResponse } from "../../services/resource";
+import { PSCDiscrepancy } from "./types"
+import { Result } from "../result";
+import Util from "../psc-discrepancies-report/util"
+
+type PromisedDiscrepancyResult = Promise<Result<ApiResponse<PSCDiscrepancy>, ApiErrorResponse>>;
+type PromisedDiscrepanciesResult = Promise<Result<ApiResponse<PSCDiscrepancy[]>, ApiErrorResponse>>;
+
+export default class {
+    utility: Util;
+    constructor (private readonly client: IHttpClient) { this.utility = new Util() }
+
+    public async getPscDiscrepanciesForReport (reportSelfLink: string): PromisedDiscrepanciesResult {
+        const resp = await this.client.httpGet(this.buildBaseURL(reportSelfLink));
+
+        return this.utility.processResponse(resp);
+    }
+
+    public async getPscDiscrepancy (selfLink: string): PromisedDiscrepancyResult {
+        const resp = await this.client.httpGet(selfLink);
+        return this.utility.processResponse(resp);
+    }
+
+    public async createPscDiscrepancy (reportSelfLink: string, discrepancy:PSCDiscrepancy): PromisedDiscrepancyResult {
+        const resp = await this.client.httpPost(this.buildBaseURL(reportSelfLink), discrepancy);
+        return this.utility.processResponse(resp);
+    }
+
+    private buildBaseURL (reportSelfLink: string): string {
+        return `${reportSelfLink}/discrepancies`;
+    }
+}

src/services/psc-discrepancies/types.ts

@@ -0,0 +1,12 @@
+export interface PSCDiscrepancy {
+    links: LinksResource,
+    etag: string,
+    kind: string,
+    details: string,
+    psc_name: string,
+    psc_date_of_birth: string
+}
+export interface LinksResource {
+    self: string;
+    psc_discrepancy_report: string;
+}