@sweepbright/api-client 0.30.2 → 0.30.4

package/src/resources/channel_accounts.ts

@@ -0,0 +1,39 @@
+import { ClientCtx, TokenType } from '../types';
+
+export default function (ctx: ClientCtx) {
+  async function getAll({ companyId }: { companyId: string }) {
+    ctx.checkAuth(TokenType.API_TOKEN);
+    const endpoint = `/services/companies/${companyId}/channel-accounts`;
+
+    return ctx.httpClient.get(endpoint, {
+      params: {
+        includes: 'channel',
+      },
+    });
+  }
+
+  async function get({ channelAccountId }: { channelAccountId: string }) {
+    ctx.checkAuth(TokenType.API_TOKEN);
+    const endpoint = `/services/channel-accounts/${channelAccountId}`;
+
+    return ctx.httpClient.get(endpoint, {
+      params: {
+        includes: 'channel',
+      },
+    });
+  }
+
+  async function getEstateHash({
+    estateId,
+    channelAccountId,
+  }: {
+    estateId: string;
+    channelAccountId: string;
+  }): Promise<{ hash: string }> {
+    const endpoint = `services/estates/${estateId}/channel-accounts/${channelAccountId}/hash`;
+    const response = await ctx.httpClient.post(endpoint);
+    return response.data;
+  }
+
+  return { getAll, get, getEstateHash } as const;
+}

package/src/resources/channels.ts

@@ -0,0 +1,52 @@
+import { ClientCtx, TokenType } from '../types';
+
+interface ReferenceDetails {
+  reference_code: string;
+  estate_id: string;
+  channel_id: string;
+  channel_account_id: string;
+  company_id: string;
+}
+
+export interface ChannelsResolveReferencesResult {
+  data: ReferenceDetails[];
+}
+
+export default function (ctx: ClientCtx) {
+  /**
+   * @deprecated use channels.resolveReferences()
+   */
+  async function getPropertyIdFromReference(
+    channel: string,
+    referenceId: string
+  ) {
+    ctx.checkAuth(TokenType.API_TOKEN);
+    const endpoint = `/channels/${channel}/channel-references/${referenceId}`;
+
+    return ctx.httpClient.get(endpoint);
+  }
+
+  /**
+   * @param channel_id Channel ID, for example, `"immoweb"` or `"immovlan"` etc
+   * @param reference_code Reference
+   * @param company_id Company ID
+   */
+  async function resolveReferences(
+    channel_id: string,
+    reference_code: string,
+    company_id?: string
+  ): Promise<ChannelsResolveReferencesResult> {
+    ctx.checkAuth(TokenType.API_TOKEN);
+    const endpoint = `/services/channel-references`;
+
+    return ctx.httpClient.get(endpoint, {
+      params: {
+        channel_id,
+        reference_code,
+        company_id,
+      },
+    });
+  }
+
+  return { getPropertyIdFromReference, resolveReferences };
+}

package/src/resources/companies.ts

@@ -0,0 +1,15 @@
+import { ClientCtx, TokenType } from '../types';
+
+export default function (ctx: ClientCtx) {
+  function get(attributes: { companyId: string; includes?: string[] }) {
+    ctx.checkAuth(TokenType.API_TOKEN);
+
+    return ctx.httpClient.get(`/companies/${attributes.companyId}`, {
+      params: {
+        includes: attributes.includes?.join(','),
+      },
+    });
+  }
+
+  return { get };
+}

package/src/resources/contact_preferences.ts

@@ -0,0 +1,14 @@
+import { ClientCtx, TokenType } from '../types';
+
+export default function contact_preferences(ctx: ClientCtx) {
+  function getAll(attributes: { contactId: string }) {
+    ctx.checkAuth(TokenType.API_TOKEN);
+    return ctx.httpClient.get(
+      `/services/contacts/${attributes.contactId}/preferences`
+    );
+  }
+
+  return {
+    getAll,
+  };
+}

package/src/resources/contacts.ts

@@ -0,0 +1,38 @@
+import { ClientCtx, TokenType } from '../types';
+
+export default function (ctx: ClientCtx) {
+  function getOne(attributes: { contactId: string }) {
+    ctx.checkAuth(TokenType.API_TOKEN);
+    return ctx.httpClient.get(`/services/contacts/${attributes.contactId}`);
+  }
+
+  function getOneWithNegotiators(attributes: { contactId: string }) {
+    ctx.checkAuth(TokenType.API_TOKEN);
+    return ctx.httpClient.get(
+      `/services/contacts/${attributes.contactId}?includes=negotiators`
+    );
+  }
+
+  function getAll(attributes: {
+    companyId: string;
+    page?: number;
+    limit?: number;
+  }) {
+    ctx.checkAuth(TokenType.API_TOKEN);
+    return ctx.httpClient.get(
+      `/services/companies/${attributes.companyId}/contacts`,
+      {
+        params: {
+          page: attributes.page ?? 1,
+          limit: attributes.limit ?? 10,
+        },
+      }
+    );
+  }
+
+  return {
+    getOne,
+    getOneWithNegotiators,
+    getAll,
+  };
+}

package/src/resources/estates.ts

@@ -0,0 +1,145 @@
+import { Property } from '../entities/property';
+import {
+  ClientCtx,
+  EstateInclude,
+  GetUnitsInput,
+  PropertiesOutput,
+  TokenType,
+  UnitsOutput,
+} from '../types';
+
+export default function (ctx: ClientCtx) {
+  function getOne(attributes: {
+    estateId: string;
+    companyId: string;
+    includes?: EstateInclude[];
+  }): Promise<Property> {
+    ctx.checkAuth(TokenType.API_TOKEN);
+
+    return ctx.httpClient
+      .get(`/services/estates/${attributes.estateId}`, {
+        params: {
+          includes: attributes.includes ?? [],
+        },
+      })
+      .then((res) => res.data);
+  }
+
+  function getAll(attributes: {
+    companyId: string;
+    page?: number;
+    limit?: number;
+    archived?: boolean;
+  }): Promise<PropertiesOutput> {
+    ctx.checkAuth(TokenType.API_TOKEN);
+    return ctx.httpClient.get(
+      `/services/companies/${attributes.companyId}/estates`,
+      {
+        params: {
+          page: attributes.page ?? 1,
+          limit: attributes.limit ?? 10,
+          archived: attributes.archived,
+        },
+      }
+    );
+  }
+
+  function getUnits(
+    projectId: string,
+    { page, limit, includes }: GetUnitsInput = {}
+  ): Promise<UnitsOutput> {
+    ctx.checkAuth(TokenType.API_TOKEN);
+    return ctx.httpClient.get(`/services/projects/${projectId}/units`, {
+      params: {
+        page,
+        limit,
+        includes,
+      },
+    });
+  }
+
+  function createPublication(attributes: {
+    estateId: string;
+    channelAccountId: string;
+    config: Record<string, any>;
+  }) {
+    ctx.checkAuth(TokenType.USER_TOKEN);
+
+    return ctx.httpClient.post(
+      `/estates/${attributes.estateId}/channel-accounts/${attributes.channelAccountId}/ads`,
+      {
+        config: attributes.config,
+      }
+    );
+  }
+
+  function updatePublication(attributes: {
+    estateId: string;
+    channelAccountId: string;
+    config: Record<string, any>;
+  }) {
+    ctx.checkAuth(TokenType.USER_TOKEN);
+
+    return ctx.httpClient.put(
+      `/estates/${attributes.estateId}/channel-accounts/${attributes.channelAccountId}/ads`,
+      {
+        config: attributes.config,
+      }
+    );
+  }
+
+  function unpublishPublication(attributes: {
+    estateId: string;
+    channelAccountId: string;
+  }) {
+    ctx.checkAuth(TokenType.USER_TOKEN);
+
+    return ctx.httpClient.delete(
+      `/estates/${attributes.estateId}/channel-accounts/${attributes.channelAccountId}/ads`
+    );
+  }
+
+  function scheduleVisit(
+    estateId: string,
+    attributes: {
+      first_name: string;
+      last_name: string;
+      email: string;
+      phone: string;
+      preferences?: {
+        locale: string;
+      };
+    }
+  ) {
+    ctx.checkAuth(TokenType.API_TOKEN);
+
+    return ctx.httpClient.put(
+      `/properties/${estateId}/schedule-visit`,
+      attributes
+    );
+  }
+
+  function unstable_setPublicationUrl({
+    estateId,
+    url,
+  }: {
+    estateId: string;
+    url: string;
+  }) {
+    ctx.checkAuth(TokenType.API_TOKEN);
+    return ctx.httpClient.put(`/estates/${estateId}/website-url`, {
+      published_url: url,
+    });
+  }
+
+  return {
+    getOne,
+    getAll,
+    getUnits,
+    createPublication,
+    updatePublication,
+    unpublishPublication,
+    scheduleVisit,
+    unstable_setPublicationUrl,
+  };
+}

package/src/resources/leads.ts

@@ -0,0 +1,65 @@
+import { ClientCtx, TokenType } from '../types';
+
+export default function (ctx: ClientCtx) {
+  function createLead(attributes: {
+    firstName?: string;
+    lastName: string;
+    propertyId: string;
+    email?: string;
+    phone?: string;
+    message: string;
+    portal: string;
+    location_preference?: {
+      country: string;
+      postal_codes: string[];
+    };
+  }) {
+    ctx.checkAuth(TokenType.API_TOKEN);
+
+    const { firstName, lastName, propertyId, email, phone, message, portal } =
+      attributes;
+
+    return ctx.httpClient.put(`estates/${propertyId}/leads`, {
+      first_name: firstName,
+      last_name: lastName,
+      message,
+      email,
+      phone,
+      source_type: 'channel',
+      external_source: portal,
+      location_preference: attributes.location_preference,
+    });
+  }
+
+  function createUnassignedLead(
+    companyId: string,
+    attributes: {
+      first_name: string;
+      last_name: string;
+      phone: string;
+      email: string;
+      message: string;
+      source_type: 'channel';
+      external_source: string;
+      preferences?: {
+        types: string[];
+        negotiation: 'sale' | 'let';
+        condition: string;
+        min_price?: number;
+        max_price?: number;
+        wishes: string[];
+        min_rooms: number;
+        locale: string;
+      };
+      location_preference?: {
+        country: string;
+        postal_codes: string[];
+      };
+    }
+  ) {
+    ctx.checkAuth(TokenType.API_TOKEN);
+    return ctx.httpClient.put(`companies/${companyId}/leads`, attributes);
+  }
+
+  return { createLead, createUnassignedLead };
+}

package/src/resources/negotiators.ts

@@ -0,0 +1,19 @@
+import { ClientCtx, NegotiatorInfo, TokenType } from '../types';
+
+export default function (ctx: ClientCtx) {
+  function getNegotiatorsByIdCompanyId(attributes: {
+    ids: string;
+    companyId: string;
+  }) {
+    ctx.checkAuth(TokenType.API_TOKEN);
+    return ctx.httpClient.get(
+      `/services/companies/${attributes.companyId}/negotiators`,
+      {
+        params: { ids: attributes.ids },
+      }
+    ) as unknown as Promise<{ data: NegotiatorInfo[] }>;
+  }
+  return {
+    getNegotiatorsByIdCompanyId,
+  };
+}

package/src/resources/offices.ts

@@ -0,0 +1,12 @@
+import { OfficeData } from '../entities/office';
+import { ClientCtx, TokenType } from '../types';
+
+export default function (ctx: ClientCtx) {
+  function getOffice(attributes: { officeId: string }): Promise<OfficeData> {
+    ctx.checkAuth(TokenType.API_TOKEN);
+
+    return ctx.httpClient.get(`/service/offices/${attributes.officeId}`);
+  }
+
+  return { getOffice };
+}

package/src/types.ts

@@ -0,0 +1,88 @@
+import { AxiosInstance } from 'axios';
+import { Property } from './entities/property';
+
+export enum Env {
+  PRODUCTION = 'production',
+  STAGING = 'staging',
+  DEV = 'dev',
+}
+
+export enum EstateInclude {
+  settings = 'settings',
+  channels = 'channels',
+  negotiator = 'negotiator',
+  'office.settings' = 'office.settings',
+  'project.settings' = 'project.settings',
+  'project.office.settings' = 'project.office.settings',
+  'project.properties.office.settings' = 'project.properties.office.settings',
+  'project.properties.settings' = 'project.properties.settings',
+  'properties.settings' = 'properties.settings',
+  'properties.office.settings' = 'properties.office.settings',
+  'properties.negotiator' = 'properties.negotiator',
+  'item.settings' = 'item.settings',
+  'item.office.settings' = 'item.office.settings',
+  'item.channels' = 'item.channels',
+  'item.project.settings' = 'item.project.settings',
+  'item.project.office.settings' = 'item.project.office.settings',
+  'item.project.properties.office.settings' = 'item.project.properties.office.settings',
+  'item.project.properties.settings' = 'item.project.properties.settings',
+  'item.properties.settings' = 'item.properties.settings',
+  'item.properties.office.settings' = 'item.properties.office.settings',
+  'item.negotiator' = 'item.negotiator',
+  'item.properties.negotiator' = 'item.properties.negotiator',
+}
+
+export type ClientConf = {
+  clientId?: string;
+  clientSecret?: string;
+  env?: Env;
+  version?: string;
+};
+
+export type InitConf = {
+  scopes?: string[];
+};
+
+export enum TokenType {
+  USER_TOKEN,
+  API_TOKEN,
+}
+
+export type Auth = {
+  token: string;
+  expiresIn?: string;
+  type: TokenType;
+};
+
+export type Maybe<T> = T | null;
+
+export type ClientCtx = {
+  checkAuth: (tokenType: TokenType) => void;
+  httpClient: AxiosInstance;
+};
+
+export interface NegotiatorInfo {
+  id: number;
+  first_name?: string;
+  last_name?: string;
+  picture_url?: string;
+  full_name?: string;
+}
+
+export interface GetUnitsInput {
+  page?: number;
+  limit?: number;
+  includes?: EstateInclude[];
+}
+
+export interface UnitsOutput {
+  data: Property[];
+}
+
+export interface PropertyOutput {
+  data: Property;
+}
+
+export interface PropertiesOutput {
+  data: Property[];
+}

package/src/utils.ts

@@ -0,0 +1,35 @@
+export function getData(response: any) {
+  return response.data;
+}
+
+export function handleRequestFailure(exception: {
+  response?: {
+    status: number;
+    data: any;
+  };
+}) {
+  if (exception.response) {
+    const {
+      response: { status, data },
+    } = exception;
+
+    const error: any = new Error(`${status}: ${JSON.stringify(data)}`);
+    // remove parts of the stack trace so the error message (codeframe) shows up
+    // at the code where the actual problem is.
+    error.stack = (error.stack || '')
+      .split('\n')
+      .filter(
+        (line: string) =>
+          !line.includes('at handleRequestFailure') &&
+          !line.includes('at processTicksAndRejections')
+      )
+      .join('\n');
+
+    error.status = status;
+    error.data = data;
+
+    return Promise.reject(error);
+  } else {
+    return Promise.reject(exception);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "@sweepbright/shared-configs-tsconfig/tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "allowJs": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "**/*.spec.ts",
+    "mockServer.ts",
+    "setupTests.ts"
+  ]
+
+}