@sweepbright/api-client 0.30.2 → 0.30.4

package/src/entities/property.ts

@@ -0,0 +1,574 @@
+import * as fs from 'fs';
+import { Currency } from '../common/currencies';
+import { Maybe } from '../common/types';
+
+export enum ADScale {
+  A = 'A',
+  B = 'B',
+  C = 'C',
+  D = 'D',
+}
+
+export enum Amenity {
+  Attic = 'attic',
+  Balcony = 'balcony',
+  Basement = 'basement',
+  ClimateControl = 'climate_control',
+  Code = 'code',
+  CoolingRoom = 'cooling_room',
+  DisplayWindow = 'display_window',
+  Drainage = 'drainage',
+  ElectricalGate = 'electrical_gate',
+  ExteriorParking = 'exterior_parking',
+  Fence = 'fence',
+  Fenced = 'fenced',
+  Garden = 'garden',
+  Guesthouse = 'guesthouse',
+  InteriorParking = 'interior_parking',
+  KeyCard = 'key_card',
+  Lift = 'lift',
+  ManualGate = 'manual_gate',
+  Parking = 'parking',
+  Pool = 'pool',
+  PrintAndCopyArea = 'print_and_copy_area',
+  ReceptionArea = 'reception_area',
+  RoadAccess = 'road_access',
+  ServerRoom = 'server_room',
+  SewerAccess = 'sewer_access',
+  StorageSpace = 'storage_space',
+  Terrace = 'terrace',
+  UtilitiesAccess = 'utilities_access',
+  WaitingArea = 'waiting_area',
+  WaterAccess = 'water_access',
+}
+
+export enum UnitOfMeasurement {
+  cm = 'cm',
+  inch = 'inch',
+  sq_m = 'sq_m',
+  sq_ft = 'sq_ft',
+}
+
+export enum MeasurementSystem {
+  Metric = 'metric',
+  Imperial = 'imperial',
+}
+
+export enum AreaType {
+  Bathrooms = 'bathrooms',
+  Bedrooms = 'bedrooms',
+  ClosedOfficeSpaces = 'closed_office_spaces',
+  ConferenceRooms = 'conference_rooms',
+  Floors = 'floors',
+  Kitchens = 'kitchens',
+  LivingRoom = 'living_room',
+  ManufacturingAreas = 'manufacturing_areas',
+  MeetingRooms = 'meeting_rooms',
+  OpenOfficeSpaces = 'open_office_spaces',
+  ParkingSpaces = 'parking_spaces',
+  Showrooms = 'showrooms',
+  StorageRooms = 'storage_rooms',
+  Toilets = 'toilets',
+}
+
+export enum PropertyStatus {
+  prospect = 'prospect',
+  lost = 'lost',
+  available = 'available',
+  rented = 'rented',
+  sold = 'sold',
+  bid = 'bid',
+  option = 'option',
+  under_contract = 'under_contract',
+}
+
+export enum PropertySubType {
+  duplex = 'duplex',
+  agricultural = 'agricultural',
+  pasture_land = 'pasture_land',
+  private_garage = 'private_garage',
+  loft = 'loft',
+  recreational = 'recreational',
+  investment_property = 'investment_property',
+  mansion = 'mansion',
+  terraced = 'terraced',
+  townhouse = 'townhouse',
+  condo = 'condo',
+  penthouse = 'penthouse',
+  farm = 'farm',
+  cottage = 'cottage',
+  buildable = 'buildable',
+  villa = 'villa',
+  retail = 'retail',
+  covered_outdoor_space = 'covered_outdoor_space',
+  indoor_parking_space = 'indoor_parking_space',
+  flex_office = 'flex_office',
+  open_office = 'open_office',
+  industrial = 'industrial',
+  restaurant_and_cafe = 'restaurant_and_cafe',
+  student_accommodation = 'student_accommodation',
+  leisure_and_sports = 'leasure_and_sports',
+  outdoor_parking_space = 'outdoor_parking_space',
+  coworking = 'coworking',
+  warehouse = 'warehouse',
+  shop = 'shop',
+  semi_detached = 'semi_detached',
+  healthcare = 'healthcare',
+  detached = 'detached',
+  bungalow = 'bungalow',
+}
+
+export enum PropertyType {
+  apartment = 'apartment',
+  house = 'house',
+  land = 'land',
+  office = 'office',
+  parking = 'parking',
+  commercial = 'commercial',
+}
+
+export enum Negotiation {
+  sale = 'sale',
+  let = 'let',
+}
+
+export enum Condition {
+  new = 'new',
+  good = 'good',
+  mint = 'mint',
+  poor = 'poor',
+  fair = 'fair',
+}
+
+export enum Orientation {
+  N = 'N',
+  S = 'S',
+  E = 'E',
+  W = 'W',
+  NE = 'NE',
+  NW = 'NW',
+  SE = 'SE',
+  SW = 'SW',
+}
+
+export enum EnergyCategory {
+  A = 'A',
+  B = 'B',
+  C = 'C',
+  D = 'D',
+  E = 'E',
+  F = 'F',
+  G = 'G',
+}
+
+export enum EnergyCategoryExtended {
+  A_PLUS_PLUS = 'A++',
+  A_PLUS = 'A+',
+  A = 'A',
+  B = 'B',
+  C = 'C',
+  D = 'D',
+  E = 'E',
+  F = 'F',
+  G = 'G',
+}
+
+export enum EnergyReport {
+  conform = 'conform',
+  not_conform = 'not_conform',
+  no_report = 'no_report',
+  not_applicable = 'not_applicable',
+}
+
+export enum FloodRisk {
+  no_flood_risk_area = 'no_flood_risk_area',
+  potential_flood_sensitive_area = 'potential_flood_sensitive_area',
+  effective_flood_sensitive_area = 'effective_flood_sensitive_area',
+}
+
+export enum Shape {
+  flat = 'flat',
+  sloped = 'sloped',
+  wooded = 'wooded',
+  has_rivers_lakes_or_ponds = 'has_rivers_lakes_or_ponds',
+  single = 'single',
+  double = 'double',
+}
+
+export enum LandUseDesignation {
+  residential = 'residential',
+  mixed_residential = 'mixed_residential',
+  industrial = 'industrial',
+  recreational = 'recreational',
+  park = 'park',
+  area_with_economical_activity = 'area_with_economical_activity',
+  forest_area = 'forest_area',
+  agricultural = 'agricultural',
+  nature_area = 'nature_area',
+  natural_reserve = 'natural_reserve',
+  residential_area_with_cultural_historical_value = 'residential_area_with_cultural_historical_value',
+  industrial_area_for_sme = 'industrial_area_for_sme',
+  day_recreation_area = 'day_recreation_area',
+  other = 'other',
+}
+
+export interface Regulations {
+  heritage_list?: Maybe<boolean>;
+  as_build_report?: Maybe<boolean>;
+  building_permit?: Maybe<boolean>;
+  expropriation_plan?: Maybe<boolean>;
+  registered_building?: Maybe<boolean>;
+  urban_planning_breach?: Maybe<boolean>;
+  site_untapped_activity?: Maybe<boolean>;
+  priority_purchase_right?: Maybe<boolean>;
+  subdivision_authorisation?: Maybe<boolean>;
+  urban_planning_certificate?: Maybe<boolean>;
+  pending_legal_proceedings?: Maybe<boolean>;
+  asbestos_certificate?: Maybe<boolean>;
+  asbestos_certificate_reference?: Maybe<string>;
+  zone_subject_to_rent_control?: Maybe<boolean>;
+  ongoing_litigation?: Maybe<boolean>;
+  renovation_obligation?: Maybe<boolean>;
+}
+
+export interface PropertyAndLand {
+  flood_risk?: Maybe<FloodRisk>;
+  purchased_year?: Maybe<number | string>;
+  cadastral_income?: Maybe<number>;
+  land_use_designation?: Maybe<LandUseDesignation>;
+  flood_risk_plot_score?: Maybe<ADScale>;
+  flood_risk_building_score?: Maybe<ADScale>;
+}
+
+export interface Energy {
+  epc_value?: Maybe<number>;
+  epc_category?: Maybe<EnergyCategoryExtended>;
+  epc_reference?: Maybe<string>;
+  co2_emissions?: Maybe<number>;
+  e_level?: Maybe<number>;
+  report_electricity_gas?: Maybe<EnergyReport>;
+  report_fuel_tank?: Maybe<EnergyReport>;
+  total_epc_value?: Maybe<number>;
+  dpe?: Maybe<EnergyCategory>;
+  greenhouse_emissions?: Maybe<EnergyCategory>;
+}
+
+export interface LegalAttributes {
+  energy?: Maybe<Energy>;
+  regulations?: Maybe<Regulations>;
+  legal_mentions?: Maybe<Record<string, string>>;
+  property_and_land?: Maybe<PropertyAndLand>;
+}
+
+export interface Price {
+  amount: number;
+  currency: Currency;
+}
+
+export interface PropertyPrice {
+  costs?: Maybe<Record<string, string>>;
+  taxes?: Maybe<Record<string, string>>;
+  current_price?: Maybe<Price>;
+  published_price?: Maybe<Price>;
+  yearly_budgeted_building_costs?: Maybe<Price>;
+  recurring_costs?: Maybe<Price>;
+  property_tax?: Maybe<Price>;
+  vat_regime?: Maybe<number>;
+  guarantee?: Maybe<Price>;
+}
+
+export interface RenovationAttributes {
+  year?: Maybe<number | string>;
+  description?: Maybe<string>;
+}
+
+export interface ConstructionAttributes {
+  year?: Maybe<number | string>;
+  architect?: Maybe<string>;
+  residential_lots?: Maybe<number>;
+}
+
+export interface BuildingAttributes {
+  renovation?: Maybe<RenovationAttributes>;
+  construction?: Maybe<ConstructionAttributes>;
+  units_of_building?: Maybe<number>;
+}
+
+export interface EnergyFeatures {
+  gas?: Maybe<boolean>;
+  electricity?: Maybe<boolean>;
+  fuel?: Maybe<boolean>;
+  heat_pump?: Maybe<boolean>;
+}
+
+export interface ComfortFeatures {
+  sauna?: Maybe<boolean>;
+  fireplace?: Maybe<boolean>;
+  fitness_room?: Maybe<boolean>;
+  furnished?: Maybe<boolean>;
+  home_automation?: Maybe<boolean>;
+  home_cinema?: Maybe<boolean>;
+  wine_cellar?: Maybe<boolean>;
+  walk_in_closet?: Maybe<boolean>;
+  water_softener?: Maybe<boolean>;
+}
+
+export interface EcologyFeatures {
+  solar_boiler?: Maybe<boolean>;
+  solar_panels?: Maybe<boolean>;
+  double_glazing?: Maybe<boolean>;
+  rainwater_harvesting?: Maybe<boolean>;
+  insulated_roof?: Maybe<boolean>;
+}
+
+export interface SecurityFeatures {
+  alarm?: Maybe<boolean>;
+  concierge?: Maybe<boolean>;
+  video_surveillance?: Maybe<boolean>;
+}
+
+export interface HeatingCoolingFeatures {
+  air_conditioning?: Maybe<boolean>;
+  central_heating?: Maybe<boolean>;
+  floor_heating?: Maybe<boolean>;
+  individual_heating?: Maybe<boolean>;
+}
+
+export interface FeaturesAttributes {
+  energy?: Maybe<EnergyFeatures>;
+  comfort?: Maybe<ComfortFeatures>;
+  ecology?: Maybe<EcologyFeatures>;
+  security?: Maybe<SecurityFeatures>;
+  heating_cooling?: Maybe<HeatingCoolingFeatures>;
+}
+
+export interface GeoData {
+  latitude: number;
+  longitude: number;
+}
+
+export interface LocationAttributes {
+  country?: Maybe<string>;
+  box?: Maybe<string>;
+  geo?: Maybe<GeoData>;
+  city?: Maybe<string>;
+  floor?: Maybe<string>;
+  number?: Maybe<string>;
+  street?: Maybe<string>;
+  addition?: Maybe<string>;
+  street_2?: Maybe<string>;
+  postal_code?: Maybe<string | number>;
+  province_or_state?: Maybe<string>;
+  borough_or_district?: Maybe<string>;
+}
+
+export interface OfficeSettings {
+  reference?: Maybe<string>;
+}
+
+export interface MandateSettings {
+  end_date?: Maybe<string>;
+  start_date?: Maybe<string>;
+  number?: Maybe<string>;
+  exclusive?: Maybe<boolean>;
+}
+
+export interface AgencyCommission {
+  fixed_fee?: Maybe<number>;
+  percentage?: Maybe<number>;
+}
+
+export interface AgencyCommissions {
+  buyer?: Maybe<AgencyCommission>;
+  seller?: Maybe<AgencyCommission>;
+}
+
+export interface PropertySettings {
+  office?: Maybe<OfficeSettings>;
+  mandate?: Maybe<MandateSettings>;
+  current_rent?: Maybe<Price>;
+  internal_note?: Maybe<string>;
+  agency_commission?: Maybe<AgencyCommissions>;
+}
+
+export interface OccupancyAttributes {
+  vacant?: Maybe<boolean>;
+  occupied?: Maybe<boolean>;
+  contact_details?: Maybe<string>;
+  available_from?: Maybe<string>;
+}
+
+export interface PropertyRoomAttributes {
+  size: number | string;
+  type: string;
+  units: UnitOfMeasurement;
+  ordinal: Maybe<number>;
+  size_description: string;
+}
+
+export interface Area {
+  size: number;
+  units?: Maybe<UnitOfMeasurement>;
+  size_description: string;
+}
+
+export interface PropertyStructure {
+  rooms?: Maybe<Record<string, PropertyRoomAttributes>>;
+  toilets?: Maybe<number>;
+  bedrooms?: Maybe<number>;
+  bathrooms?: Maybe<number>;
+  kitchens?: Maybe<number>;
+  floors?: Maybe<number>;
+  living_room?: Maybe<number>;
+  showrooms?: Maybe<number>;
+  shower_rooms?: Maybe<number>;
+  manufacturing_areas?: Maybe<number>;
+  storage_rooms?: Maybe<number>;
+  parking_spaces?: Maybe<number>;
+  meeting_rooms?: Maybe<number>;
+  open_office_spaces?: Maybe<number>;
+  closed_office_spaces?: Maybe<number>;
+  conference_rooms?: Maybe<number>;
+  liveable_area?: Maybe<Area>;
+  gross_area?: Maybe<Area>;
+  net_area?: Maybe<Area>;
+  plot_area?: Maybe<Area>;
+  display_window_length?: Maybe<Area>;
+  ceiling_height?: Maybe<Area>;
+  loi_carrez_area?: Maybe<Area>;
+}
+
+export interface PropertyConditions {
+  kitchen?: Maybe<Condition>;
+  bathroom?: Maybe<Condition>;
+}
+
+export interface PropertyDescription {
+  title: Record<string, string>;
+  description: Record<string, string>;
+}
+
+export interface PropertyOrientation {
+  balcony?: Maybe<Orientation>;
+  garden?: Maybe<Orientation>;
+  terrace?: Maybe<Orientation>;
+}
+
+export interface PropertyAccessibility {
+  alarm?: Maybe<boolean>;
+  alarm_code?: Maybe<number | string>;
+  key_available?: Maybe<boolean>;
+}
+
+export interface PropertyDocument {
+  private: boolean;
+  filename: string;
+  extension: string;
+  description?: Maybe<string>;
+  uploaded_at: string;
+  'content-type': string;
+}
+
+export interface FloorPlan {
+  private: boolean;
+  filename: string;
+  extension: string;
+  description: Maybe<string>;
+  uploaded_at: string;
+  'content-type': string;
+}
+
+export interface Image {
+  ordinal: number;
+  private: boolean;
+  filename: string;
+  extension: string;
+  description?: Maybe<string>;
+  equirectangular?: Maybe<boolean>;
+  uploaded_at: string;
+  'content-type': string;
+}
+
+export interface PropertyPermissions {
+  construction?: Maybe<boolean>;
+  farming?: Maybe<boolean>;
+  fishing?: Maybe<boolean>;
+  planning?: Maybe<boolean>;
+}
+
+export interface TenantContract {
+  start_date?: Maybe<string>;
+  end_date?: Maybe<string>;
+}
+
+export interface PropertyAttributes {
+  legal?: Maybe<LegalAttributes>;
+  price?: Maybe<PropertyPrice>;
+  images?: Maybe<Record<string, Image>>;
+  status?: Maybe<PropertyStatus>;
+  building?: Maybe<BuildingAttributes>;
+  features?: Maybe<FeaturesAttributes>;
+  location?: Maybe<LocationAttributes>;
+  settings?: Maybe<PropertySettings>;
+  sub_type?: Maybe<PropertySubType[]>;
+  amenities?: Maybe<Amenity[]>;
+  documents?: Maybe<Record<string, PropertyDocument>>;
+  occupancy?: Maybe<OccupancyAttributes>;
+  structure?: Maybe<PropertyStructure>;
+  conditions?: Maybe<PropertyConditions>;
+  description?: Maybe<PropertyDescription>;
+  floor_plans?: Maybe<Record<string, FloorPlan>>;
+  orientation?: Maybe<PropertyOrientation>;
+  accessibility?: Maybe<PropertyAccessibility>;
+  tenant_contract?: Maybe<TenantContract>;
+  general_condition?: Maybe<Condition>;
+  permissions?: Maybe<PropertyPermissions>;
+  shape?: Maybe<Shape>;
+  video?: Maybe<string>;
+  virtual_tour?: Maybe<string>;
+}
+
+export interface Property {
+  id: string;
+  type: PropertyType;
+  negotiation: Negotiation;
+  is_project: boolean;
+  project_id?: Maybe<string>;
+  office_id: string;
+  negotiator_id: string;
+  attributes: PropertyAttributes;
+  archived_at?: Maybe<string>;
+  created_at?: Maybe<string>;
+  updated_at?: Maybe<string>;
+}
+
+export type Resource = FloorPlan | PropertyDocument | Image;
+export type FileUploadStream = fs.ReadStream;
+export interface LanguageWithDefaultValue {
+  language: string;
+  default_value: string;
+}
+
+export interface RoomData {
+  name: AreaType;
+  value: number;
+}
+
+export type LocalizedStringMap = { [key: string]: string };
+
+export interface UserDefaults {
+  measurementSystem: MeasurementSystem;
+  currency: Currency;
+  defaultLanguage: string[];
+  country: string;
+}
+
+export enum InternalType {
+  project = 'project',
+  unit = 'unit',
+  standalone = 'standalone',
+}
+export interface PropertyForSnsEvent extends Property {
+  is_archived: boolean;
+  internal_type: InternalType;
+}

package/src/index.ts

@@ -0,0 +1,128 @@
+import axios from 'axios';
+import invariant from 'tiny-invariant';
+import channelAccounts from './resources/channel_accounts';
+import channels from './resources/channels';
+import companies from './resources/companies';
+import contact_preferences from './resources/contact_preferences';
+import contacts from './resources/contacts';
+import estates from './resources/estates';
+import leads from './resources/leads';
+import negotiators from './resources/negotiators';
+import offices from './resources/offices';
+import { Auth, ClientConf, Env, InitConf, Maybe, TokenType } from './types';
+import { getData, handleRequestFailure } from './utils';
+
+const envHosts: Record<Env, string> = {
+  [Env.PRODUCTION]: 'https://api.sweepbright.com',
+  [Env.STAGING]: 'https://api.staging.sweepbright.com',
+  [Env.DEV]: 'https://api.dev.sweepbright.com',
+};
+
+interface Client {
+  authorize(config?: InitConf): Promise<Client>;
+  withUserToken(accessToken: string): Promise<Client>;
+  leads: ReturnType<typeof leads>;
+  negotiators: ReturnType<typeof negotiators>;
+  offices: ReturnType<typeof offices>;
+  contacts: ReturnType<typeof contacts>;
+  channelAccounts: ReturnType<typeof channelAccounts>;
+  channels: ReturnType<typeof channels>;
+  companies: ReturnType<typeof companies>;
+  contactPreferences: ReturnType<typeof contact_preferences>;
+  estates: ReturnType<typeof estates>;
+}
+
+function createClient(conf: ClientConf) {
+  const { clientId, clientSecret, env = Env.PRODUCTION, version } = conf;
+  let _auth: Maybe<Auth> = null;
+
+  const httpClient = axios.create({
+    baseURL: envHosts[env],
+  });
+
+  //TODO: getData here is an antipattern. Interceptor should not change a type of response
+  httpClient.interceptors.response.use(getData, handleRequestFailure);
+  if (version) {
+    httpClient.defaults.headers.common[
+      'Accept'
+    ] = `application/vnd.sweepbright.${version}+json`;
+  }
+
+  const ctx = {
+    httpClient,
+    checkAuth(tokenType: TokenType) {
+      if (!_auth) {
+        throw new Error('client is not authenticated');
+      }
+
+      if (_auth.type !== tokenType) {
+        throw new Error('authenticated with invalid token type');
+      }
+    },
+  };
+
+  const client: Client = {
+    authorize(config: InitConf = {}): Promise<Client> {
+      const {
+        scopes = ['companies:read', 'properties:download', 'lead_info:write'],
+      } = config;
+
+      invariant(clientId, 'missing client id');
+      invariant(clientSecret, 'missing client secret');
+
+      return httpClient
+        .post<
+          any,
+          {
+            access_token: string;
+            expires_in: string;
+          }
+        >('/auth/access-token', {
+          client_id: clientId,
+          client_secret: clientSecret,
+          grant_type: 'client_credentials',
+          scope: scopes.join(','),
+        })
+        .then(({ access_token, expires_in }) => {
+          invariant(access_token, 'access token should be defined');
+          invariant(expires_in, 'expires_in should be defined');
+          _auth = {
+            token: access_token,
+            expiresIn: expires_in,
+            type: TokenType.API_TOKEN,
+          };
+
+          // https://github.com/axios/axios#custom-instance-defaults
+          httpClient.defaults.headers.common[
+            'Authorization'
+          ] = `Bearer ${_auth.token}`;
+          return client;
+        });
+    },
+    withUserToken: async (accessToken: string): Promise<Client> => {
+      _auth = {
+        token: accessToken,
+        type: TokenType.USER_TOKEN,
+      };
+
+      httpClient.defaults.headers.common[
+        'Authorization'
+      ] = `Bearer ${_auth.token}`;
+
+      return client;
+    },
+    leads: leads(ctx),
+    channels: channels(ctx),
+    estates: estates(ctx),
+    channelAccounts: channelAccounts(ctx),
+    companies: companies(ctx),
+    contacts: contacts(ctx),
+    contactPreferences: contact_preferences(ctx),
+    negotiators: negotiators(ctx),
+    offices: offices(ctx),
+  };
+
+  return client;
+}
+
+export { createClient, Env, Client };