Merge pull request #38 from companieshouse/feature/obj-392-filing-history-required

Feature/obj 392 filing history required

Author: mattch1

src/services/company-filing-history/index.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./service";

src/services/company-filing-history/service.ts

@@ -0,0 +1,47 @@
+import {IHttpClient} from "../../http";
+import {CompanyFilingHistory, CompanyFilingHistoryResource, FilingHistoryItemResource} from "./types";
+import Resource from "../resource";
+import {CompanyProfile, CompanyProfileResource} from "../company-profile";
+import Mapping from "../../mapping/mapping";
+import {CompanyOfficers} from "../company-officers";
+
+/**
+ * https://developer.companieshouse.gov.uk/api/docs/company/company_number/filing-history/getFilingHistoryList.html
+ **/
+export default class CompanyFilingHistoryService {
+  constructor (private readonly client: IHttpClient) { }
+
+  /**
+   * Get the filing history for a company
+   *
+   */
+  public async getCompanyFilingHistory (number: string, category?: string): Promise<Resource<CompanyFilingHistory>> {
+    let queryString;
+    if (category) {
+      queryString = `?category=${category}`;
+    }
+
+    let url = `/company/${number}/filing-history`;
+
+    if (queryString) {
+      url = url.concat(queryString);
+    }
+
+    const resp = await this.client.httpGet(url);
+
+    const resource: Resource<CompanyFilingHistory> = {
+      httpStatusCode: resp.status
+    };
+
+    if (resp.error) {
+      return resource;
+    }
+
+    // cast the response body to the expected type
+    const body = resp.body as CompanyFilingHistoryResource;
+
+    resource.resource = Mapping.camelCaseKeys<CompanyFilingHistory>(body);
+
+    return resource;
+  }
+}

src/services/company-filing-history/types.ts

@@ -0,0 +1,131 @@
+/**
+ * CompanyFilingHistoryResource is what is returned from the api.
+ */
+export interface CompanyFilingHistoryResource {
+  etag: string,
+  filing_history_status?: string,
+  items: FilingHistoryItemResource[],
+  items_per_page: number,
+  kind: string,
+  start_index: number,
+  total_count: number
+}
+
+export interface FilingHistoryItemResource {
+  annotations?: FilingHistoryItemAnnotationResource[],
+  associated_filings?: FilingHistoryItemAssociatedFilingResource[],
+  barcode?: string
+  category: string,
+  date: string,
+  description: string,
+  description_values?: FilingHistoryDescriptionValuesResource,
+  links?: FilingHistoryItemLinksResource,
+  pages?: number,
+  paper_filed?: boolean,
+  resolutions?: FilingHistoryItemResolutionResource[],
+  subcategory?: string,
+  transaction_id: string,
+  type: string
+}
+
+export interface FilingHistoryItemAnnotationResource {
+  annotation?: string,
+  category?: string,
+  date: string,
+  description: string,
+  description_values?: FilingHistoryDescriptionValuesResource,
+  type?: string
+}
+
+export interface FilingHistoryItemAssociatedFilingResource {
+  category?: string,
+  date: string,
+  description: string,
+  description_values?: FilingHistoryDescriptionValuesResource,
+  type: string
+}
+
+export interface FilingHistoryDescriptionValuesResource {
+  [key:string]: string
+}
+
+export interface FilingHistoryItemLinksResource {
+  document_metadata?: string,
+  self?: string
+}
+
+export interface FilingHistoryItemResolutionResource {
+  category: string,
+  description: string,
+  description_values?: FilingHistoryDescriptionValuesResource,
+  document_id?: string,
+  receive_date: string,
+  subcategory: string
+  type: string
+}
+
+/**
+ * CompanyFilingHistory is the interface used within the sdk
+ */
+export interface CompanyFilingHistory {
+  etag: string,
+  filingHistoryStatus?: string,
+  items: FilingHistoryItem[],
+  itemsPerPage: number,
+  kind: string,
+  startIndex: number,
+  totalCount: number
+}
+
+export interface FilingHistoryItem {
+  annotations?: FilingHistoryItemAnnotation[],
+  associatedFilings?: FilingHistoryItemAssociatedFiling[],
+  barcode?: string
+  category: string,
+  date: string,
+  description: string,
+  descriptionValues?: FilingHistoryDescriptionValues,
+  links?: FilingHistoryItemLinks,
+  pages?: number,
+  paperFiled?: boolean,
+  resolutions?: FilingHistoryItemResolution[],
+  subcategory?: string,
+  transactionId: string,
+  type: string
+}
+
+export interface FilingHistoryItemAnnotation {
+  annotation?: string,
+  category?: string,
+  date: string,
+  description: string,
+  descriptionValues?: FilingHistoryDescriptionValues,
+  type?: string
+}
+
+export interface FilingHistoryItemAssociatedFiling {
+  category?: string,
+  date: string,
+  description: string,
+  descriptionValues?: FilingHistoryDescriptionValues,
+  type: string
+}
+
+export interface FilingHistoryDescriptionValues {
+  [key:string]: string
+}
+
+export interface FilingHistoryItemLinks {
+  documentMetadata?: string,
+  self?: string
+}
+
+export interface FilingHistoryItemResolution {
+  category: string,
+  description: string,
+  descriptionValues?: FilingHistoryDescriptionValues,
+  documentId?: string,
+  receiveDate: string,
+  subcategory: string
+  type: string
+}

test/services/company-filing-history/service.spec.ts

@@ -0,0 +1,81 @@
+import chai from "chai";
+import {RequestClient} from "../../../src/http";
+import sinon from "sinon";
+import CompanyFilingHistoryService from "../../../src/services/company-filing-history/service";
+import {
+  CompanyFilingHistoryResource,
+  FilingHistoryItemResource
+} from "../../../src/services/company-filing-history/types";
+
+const expect = chai.expect;
+
+const requestClient = new RequestClient({ baseUrl: "URL-NOT-USED", oauthToken: "TOKEN-NOT-USED" });
+
+describe("company-filing-history", () => {
+  beforeEach(() => {
+    sinon.reset();
+    sinon.restore();
+  });
+
+  afterEach(done => {
+    sinon.reset();
+    sinon.restore();
+    done();
+  });
+
+  it("returns an error response on failure", async () => {
+    const mockGetResponse = {
+      status: 401,
+      error: "An error occurred"
+    };
+    const mockRequest = sinon.stub(requestClient, "httpGet").resolves(mockGetResponse);
+    const companyFilingService : CompanyFilingHistoryService = new CompanyFilingHistoryService(requestClient);
+    const data = await companyFilingService.getCompanyFilingHistory("NUMBER-NOT-IMPORTANT");
+
+    expect(data.httpStatusCode).to.equal(401);
+    expect(data.resource).to.be.undefined;
+  });
+
+  it("maps the company filing history data items correctly", async () => {
+    const mockFilingHistoryItem: FilingHistoryItemResource = {
+      category: "category",
+      date: "someDate",
+      description: "A description",
+      transaction_id: "transaction id",
+      type: "a type"
+    }
+    const mockResponseBody : CompanyFilingHistoryResource = {
+      etag: "someEtag",
+      filing_history_status: "someFilingHistoryStatus",
+      items: [mockFilingHistoryItem],
+      items_per_page: 1,
+      kind: "a kind",
+      start_index: 0,
+      total_count: 1
+    };
+
+    const mockGetResponse = {
+      status: 200,
+      body: mockResponseBody
+    };
+
+    const mockRequest = sinon.stub(requestClient, "httpGet").resolves(mockGetResponse);
+    const companyFilingHistoryService : CompanyFilingHistoryService = new CompanyFilingHistoryService(requestClient);
+    const data = await companyFilingHistoryService.getCompanyFilingHistory("123");
+
+    expect(data.httpStatusCode).to.equal(200);
+
+    expect(data.resource.etag).to.equal(mockResponseBody.etag)
+    expect(data.resource.filingHistoryStatus).to.equal(mockResponseBody.filing_history_status)
+    expect(data.resource.itemsPerPage).to.equal(mockResponseBody.items_per_page)
+    expect(data.resource.kind).to.equal(mockResponseBody.kind)
+    expect(data.resource.startIndex).to.equal(mockResponseBody.start_index)
+    expect(data.resource.totalCount).to.equal(mockResponseBody.total_count)
+
+    expect(data.resource.items[0].category).to.equal(mockFilingHistoryItem.category);
+    expect(data.resource.items[0].date).to.equal(mockFilingHistoryItem.date);
+    expect(data.resource.items[0].description).to.equal(mockFilingHistoryItem.description);
+    expect(data.resource.items[0].transactionId).to.equal(mockFilingHistoryItem.transaction_id);
+    expect(data.resource.items[0].type).to.equal(mockFilingHistoryItem.type);
+    });
+});