@hapl/api-queries 0.1.116 → 0.1.119

package/src/clients/v1/api/index.ts

@@ -51,7 +51,7 @@ export * from './serviceRequest/findServiceRequestActivities';
 export * from './serviceRequest/findServiceRequestById';
 export * from './serviceRequest/findServiceRequestDuplicates';
 export * from './serviceRequest/findServiceRequests';
-export * from './serviceRequest/findServiceRequestSellerReport';
+export * from './serviceRequest/findServiceRequestSellerReports';
 export * from './serviceRequest/findServiceRequestShortInfo';
 export * from './serviceRequest/findServiceRequestShortInfoById';
 export * from './serviceRequest/findServiceRequestShortInfoByDealId';
@@ -72,3 +72,5 @@ export * from './users/fireUser';
 export * from './users/assignSubordinateUsers';
 
 export * from './task/findTasks';
+
+export * from './valuation/findValuationByServiceRequestId';

package/src/clients/v1/api/serviceRequest/{findServiceRequestSellerReport → findServiceRequestSellerReports}/index.ts

@@ -8,30 +8,30 @@ type ErrorData = { success: false; data: { error: string } };
 type ResultData = { ids: string[]; byId: Record<string, ServiceRequestSellerReport>; meta: { total: number } };
 type ResultError = ErrorData['data']['error'];
 
-export type FindServiceRequestSellerReportParams = {
+export type FindServiceRequestSellerReportsParams = {
   sorting?: {
     type: 'createdAt';
     direction: 'asc' | 'desc';
   };
   limits?: { page?: number; count?: number | 'all' };
 };
-export type FindServiceRequestSellerReportUrlParams = { id: number };
-export type FindServiceRequestSellerReportHeaders = { 'x-auth-hc': string };
-export type FindServiceRequestSellerReportData = AxiosResponse<ResultData>;
-export type FindServiceRequestSellerReportError = AxiosError<ResultError>;
-export type FindServiceRequestSellerReportConfig = {
+export type FindServiceRequestSellerReportsUrlParams = { id: number };
+export type FindServiceRequestSellerReportsHeaders = { 'x-auth-hc': string };
+export type FindServiceRequestSellerReportsData = AxiosResponse<ResultData>;
+export type FindServiceRequestSellerReportsError = AxiosError<ResultError>;
+export type FindServiceRequestSellerReportsConfig = {
   baseURL?: string;
-  urlParams: FindServiceRequestSellerReportUrlParams;
-  params: FindServiceRequestSellerReportParams;
-  headers?: FindServiceRequestSellerReportHeaders;
+  urlParams: FindServiceRequestSellerReportsUrlParams;
+  params: FindServiceRequestSellerReportsParams;
+  headers?: FindServiceRequestSellerReportsHeaders;
 };
 
-export function findServiceRequestSellerReportRequest({
+export function findServiceRequestSellerReportsRequest({
   baseURL = 'https://clients.homeapp.ru',
   urlParams,
   headers,
   params,
-}: FindServiceRequestSellerReportConfig) {
+}: FindServiceRequestSellerReportsConfig) {
   return axios
     .get(`/api/service-request/${urlParams.id}/report-for-seller`, {
       baseURL,
@@ -55,8 +55,8 @@ export function findServiceRequestSellerReportRequest({
         },
       ],
     })
-    .then((res: FindServiceRequestSellerReportData) => res)
-    .catch((err: FindServiceRequestSellerReportError) => {
+    .then((res: FindServiceRequestSellerReportsData) => res)
+    .catch((err: FindServiceRequestSellerReportsError) => {
       throw err;
     });
 }

package/src/clients/v1/api/serviceRequest/findServiceRequests/index.ts

@@ -10,28 +10,30 @@ type ResultError = ErrorData['data']['error'];
 
 export type FindServiceRequestsParams = {
   filter?: {
-    address?: string;
-    category?: ServiceRequestCategory | ServiceRequestCategory[];
-    createdAt?: string;
-    'contract.id'?: number;
     'contract.formalId'?: string;
+    'contract.id'?: number;
     'contract.isSigned'?: boolean;
     'curator.id'?: number;
     'curator.supervisor'?: number;
-    hasValuation?: boolean;
+    'realty.price'?: number | { from?: number; to?: number };
+    'user.id'?: number;
+    'user.phones.phone.number'?: string;
+    address?: string;
+    category?: ServiceRequestCategory | ServiceRequestCategory[];
+    createdAt?: string;
     hasPublishedValuations?: boolean;
+    hasValuation?: boolean;
     id?: number | number[];
     idOrFormalId?: string;
     isDeferred?: boolean;
     isPublished?: boolean;
     realtyExtId?: number;
-    'realty.price'?: number | { from?: number; to?: number };
     showTrainees?: boolean;
     source?: string;
     status?: ServiceRequestStatus | ServiceRequestStatus[];
     statusDate?: string | { from?: string; to?: string };
     type?: ServiceRequestType | ServiceRequestType[];
-    'user.phones.phone.number'?: string;
+    withRealty?: boolean;
   };
   limits?: { page: number; count: number };
 };

package/src/clients/v1/api/valuation/findValuationByServiceRequestId/index.ts

@@ -0,0 +1,42 @@
+import axios, { AxiosResponse, AxiosError, AxiosTransformer } from 'axios';
+import qs from 'qs';
+import { Valuation } from '../../../types';
+
+type SuccessData = { success: true; data: Valuation };
+type ErrorData = { success: false; data: { error: string } };
+
+type ResultData = SuccessData['data'];
+type ResultError = ErrorData['data']['error'];
+
+export type FindValuationByServiceRequestIdUrlParams = { id: number };
+export type FindValuationByServiceRequestIdParams = { withDrafts?: boolean };
+export type FindValuationByServiceRequestIdData = AxiosResponse<ResultData>;
+export type FindValuationByServiceRequestIdError = AxiosError<ResultError>;
+
+export type FindValuationByServiceRequestIdConfig = {
+  baseURL?: string;
+  urlParams: FindValuationByServiceRequestIdUrlParams;
+  params?: FindValuationByServiceRequestIdParams;
+};
+
+export function findValuationByServiceRequestIdRequest({
+  baseURL = 'https://clients.homeapp.ru',
+  urlParams,
+  params,
+}: FindValuationByServiceRequestIdConfig) {
+  return axios
+    .get(`/api/valuation/${urlParams.id}`, {
+      baseURL,
+      params,
+      paramsSerializer: params => qs.stringify(params, { arrayFormat: 'brackets' }),
+      headers: { Accept: 'application/json' },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => (data.success ? data.data : data.data.error),
+      ],
+    })
+    .then((res: FindValuationByServiceRequestIdData) => res)
+    .catch((err: FindValuationByServiceRequestIdError) => {
+      throw err;
+    });
+}

package/src/clients/v1/dictionaries/Valuation.ts

@@ -0,0 +1,11 @@
+import { ValuationConcurrency } from '../types';
+
+export const ValuationDictionary = {
+  Concurrency: {
+    [ValuationConcurrency.Low]: 'Не высокий',
+    [ValuationConcurrency.Medium]: 'Средний',
+    [ValuationConcurrency.MediumHigh]: 'Выше среднего',
+    [ValuationConcurrency.High]: 'Высокий',
+    [ValuationConcurrency.VeryHigh]: 'Очень высокий',
+  },
+};

package/src/clients/v1/dictionaries/index.ts

@@ -16,3 +16,4 @@ export * from './ServiceRequestCategorizedFile';
 export * from './Shape';
 export * from './Task';
 export * from './User';
+export * from './Valuation';

package/src/clients/v1/index.ts

@@ -347,12 +347,12 @@ export class Api {
     return api.startServiceRequestModerationForOldRealtyRequest({ urlParams, headers, baseURL: this.baseURL });
   };
 
-  findServiceRequestSellerReport = (
-    urlParams: api.FindServiceRequestSellerReportUrlParams,
-    params: api.FindServiceRequestSellerReportParams,
-    headers: api.FindServiceRequestSellerReportHeaders
+  findServiceRequestSellerReports = (
+    urlParams: api.FindServiceRequestSellerReportsUrlParams,
+    params: api.FindServiceRequestSellerReportsParams,
+    headers: api.FindServiceRequestSellerReportsHeaders
   ) => {
-    return api.findServiceRequestSellerReportRequest({ urlParams, params, headers, baseURL: this.baseURL });
+    return api.findServiceRequestSellerReportsRequest({ urlParams, params, headers, baseURL: this.baseURL });
   };
 
   // sold
@@ -396,6 +396,15 @@ export class Api {
   ) => {
     return api.assignSubordinateUsersRequest({ urlParams, body, headers, baseURL: this.baseURL });
   };
+
+  // valuation
+
+  findValuationByServiceRequestId = (
+    urlParams: api.FindValuationByServiceRequestIdUrlParams,
+    params?: api.FindValuationByServiceRequestIdParams
+  ) => {
+    return api.findValuationByServiceRequestIdRequest({ urlParams, params, baseURL: this.baseURL });
+  };
 }
 
 export * from './api';

package/src/clients/v1/types/Valuation.ts

@@ -0,0 +1,57 @@
+import { ServiceRequest } from './ServiceRequest';
+
+export enum ValuationConcurrency {
+  Low = 'low',
+  Medium = 'medium',
+  MediumHigh = 'medium-high',
+  High = 'high',
+  VeryHigh = 'very-high',
+}
+
+type ValueRange = { max: number; min: number; p10: number; p50: number; p90: number };
+
+type Stats = {
+  count: number;
+  outOfRange: number;
+  area?: ValueRange;
+  price?: ValueRange;
+  realtyIds?: number[];
+};
+
+export type Valuation = {
+  addresses: number[];
+  comments: Array<{ comment: string; realtyId: number }>;
+  createdAt: string;
+  id: number;
+  isDraft: boolean;
+  isOnlyInMarketRangeShown: boolean;
+  realties: number[];
+  realtyParams:
+    | any[]
+    | {
+        address?: string;
+        area?: number;
+        floor?: number;
+        lat?: number;
+        lng?: number;
+        price?: number;
+        roomsNumber?: number;
+      };
+  serviceRequest: Partial<ServiceRequest> & Required<Pick<ServiceRequest, 'id'>>;
+
+  calculationData?: {
+    active: Stats;
+    concurrencyLevel: ValuationConcurrency;
+    inventoryPerBuyer: number;
+    sold: Stats;
+  };
+  comment?: string;
+  filter?: {
+    address?: string;
+    area?: { from?: number; to?: number };
+    floor?: { from?: number; to?: number };
+    floorsNumber?: { from: number; to: number };
+    isShortDateRange?: boolean;
+    roomsNumber?: number[];
+  };
+};

package/src/clients/v1/types/index.ts

@@ -27,3 +27,4 @@ export * from './Task';
 export * from './User';
 export * from './UserCase';
 export * from './UserPhone';
+export * from './Valuation';

package/src/registry/v1/api/index.ts

@@ -1 +1,3 @@
-export * from './complexes/findComplexIds';
+export * from './complex/findComplexIds';
+
+export * from './realty/findRealties';

package/src/registry/v1/api/realty/findRealties/index.ts

@@ -0,0 +1,54 @@
+import axios, { AxiosResponse, AxiosError, AxiosTransformer } from 'axios';
+import qs from 'qs';
+import { Realty } from '../../../types';
+
+type SuccessData = { success: true; data: Realty[]; pageParams: { page: number; length: number } };
+type ErrorData = { success: false; data: Record<'error' | 'message', string> };
+
+type ResultData = { ids: number[]; byId: Record<string, Realty>; meta: { total: number } };
+type ResultError = string;
+
+export type FindRealtiesHeaders = { 'x-auth-hc': string };
+export type FindRealtiesParams = {
+  filter?: { id?: number | number[] };
+  limits?: { page?: number; count?: number | 'all' };
+  sorting?: { direction: 'asc' | 'desc'; type: 'createdAt' | 'id' };
+};
+export type FindRealtiesData = AxiosResponse<ResultData>;
+export type FindRealtiesError = AxiosError<ResultError>;
+export type FindRealtiesConfig = {
+  baseURL?: string;
+  params: FindRealtiesParams;
+};
+
+export function findRealtiesRequest({ baseURL = 'https://clients.homeapp.ru', params }: FindRealtiesConfig) {
+  return axios
+    .get('/api/realty', {
+      baseURL,
+      params,
+      paramsSerializer: params => qs.stringify(params, { arrayFormat: 'brackets' }),
+      headers: { Accept: 'application/json' },
+      transformResponse: [
+        ...(axios.defaults.transformResponse as AxiosTransformer[]),
+        (data: SuccessData | ErrorData): ResultData | ResultError => {
+          if (!data.success) {
+            return data.data.error || data.data.message;
+          }
+
+          const ids: ResultData['ids'] = [];
+          const byId: ResultData['byId'] = {};
+
+          data.data.forEach(entity => {
+            byId[entity.id] = entity;
+            ids.push(entity.id);
+          });
+
+          return { ids, byId, meta: { total: data.pageParams.length } };
+        },
+      ],
+    })
+    .then((res: FindRealtiesData) => res)
+    .catch((err: FindRealtiesError) => {
+      throw err;
+    });
+}

package/src/registry/v1/dictionaries/AddressBTIParams.ts

@@ -0,0 +1,25 @@
+import { AddressBTIParamsParking, AddressBTIParamsWallsMaterial, AddressBTIParamsHeatingType } from '../types';
+
+export const AddressBTIParamsDictionary = {
+  Parking: {
+    [AddressBTIParamsParking.Ground]: 'Наземная',
+    [AddressBTIParamsParking.Multilevel]: 'Многоуровневая',
+    [AddressBTIParamsParking.Underground]: 'Подземная',
+  },
+  WallsMaterial: {
+    [AddressBTIParamsWallsMaterial.Brick]: 'Кирпичный',
+    [AddressBTIParamsWallsMaterial.Monolith]: 'Монолитный',
+    [AddressBTIParamsWallsMaterial.Monobrick]: 'Монолитно-кирпичный',
+    [AddressBTIParamsWallsMaterial.Timber]: 'Деревянный',
+    [AddressBTIParamsWallsMaterial.Panel]: 'Панельный',
+    [AddressBTIParamsWallsMaterial.Block]: 'Блочный',
+  },
+  HeatingType: {
+    [AddressBTIParamsHeatingType.None]: 'Нет',
+    [AddressBTIParamsHeatingType.Central]: 'Центральное',
+    [AddressBTIParamsHeatingType.Local]: 'Отдельное',
+    [AddressBTIParamsHeatingType.Gas]: 'Газовое',
+    [AddressBTIParamsHeatingType.Electricity]: 'Электрическое',
+    [AddressBTIParamsHeatingType.Liquid]: 'Жидкое топливо',
+  },
+};

package/src/registry/v1/dictionaries/Realty.ts

@@ -0,0 +1,84 @@
+import {
+  RealtyType,
+  RealtyRenovationType,
+  RealtyGas,
+  RealtyHouseType,
+  RealtyLandShape,
+  RealtyLandUsageType,
+  RealtyRelief,
+  RealtyElectricity,
+  RealtyFurniture,
+  RealtySewerage,
+  RealtyWindowView,
+} from '../types';
+
+export const RealtyDictionary = {
+  Type: {
+    [RealtyType.Flat]: 'Квартира',
+    [RealtyType.House]: 'Дом',
+  },
+  RenovationType: {
+    [RealtyRenovationType.None]: 'Без ремонта',
+    [RealtyRenovationType.Author]: 'Авторский',
+    [RealtyRenovationType.Cosmetic]: 'Косметический',
+    [RealtyRenovationType.Euro]: 'Евро',
+    [RealtyRenovationType.FineFinishing]: 'Чистовая отделка',
+    [RealtyRenovationType.RoughFinishing]: 'Черновая отделка',
+  },
+  Gas: {
+    [RealtyGas.None]: 'Нет',
+    [RealtyGas.Connected]: 'Подключено',
+    [RealtyGas.Border]: 'По границе',
+    [RealtyGas.Possible]: 'Возможно',
+    [RealtyGas.Autonomous]: 'Автономное',
+  },
+  HouseType: {
+    [RealtyHouseType.Townhouse]: 'Таунхаус',
+    [RealtyHouseType.House]: 'Дом',
+    [RealtyHouseType.Cottage]: 'Коттедж',
+    [RealtyHouseType.Part]: 'Часть дома',
+    [RealtyHouseType.Duplex]: 'Дуплекс',
+  },
+  LandShape: {
+    [RealtyLandShape.Regular]: 'Правильная',
+    [RealtyLandShape.Irregular]: 'Неправильная',
+  },
+  LandUsageType: {
+    [RealtyLandUsageType.IGS]: 'ИЖС',
+    [RealtyLandUsageType.LPH]: 'ЛПХ (личное подсобное хозяйство)',
+    [RealtyLandUsageType.DNP]: 'ДНП (дачное некоммерческое партнероство)',
+    [RealtyLandUsageType.SNT]: 'СНТ (садоводческое некоммерческое товарищество)',
+    [RealtyLandUsageType.Farm]: 'Фермерское хозяйство',
+    [RealtyLandUsageType.Garden]: 'Садоводство',
+    [RealtyLandUsageType.Investproject]: 'Инвестпроект',
+  },
+  Relief: {
+    [RealtyRelief.Flat]: 'Ровный',
+    [RealtyRelief.Elevations]: 'Значительные перепады высот',
+    [RealtyRelief.Slope]: 'Склон',
+    [RealtyRelief.Hills]: 'Холмы',
+  },
+  Electricity: {
+    [RealtyElectricity.None]: 'Нет',
+    [RealtyElectricity.Connected]: 'Подключено',
+    [RealtyElectricity.Possible]: 'Возможно',
+    [RealtyElectricity.Autonomous]: 'Автономное',
+  },
+  Furniture: {
+    [RealtyFurniture.None]: 'Отсутствует',
+    [RealtyFurniture.Full]: 'Полностью мебелирован',
+    [RealtyFurniture.Part]: 'Частично мебелирован',
+  },
+  Sewerage: {
+    [RealtySewerage.None]: 'Нет',
+    [RealtySewerage.Cesspool]: 'Выгребная яма',
+    [RealtySewerage.Septic]: 'Септик',
+    [RealtySewerage.Bio]: 'Устройства биологической очистки',
+    [RealtySewerage.Central]: 'Центральная',
+  },
+  WindowView: {
+    [RealtyWindowView.Street]: 'На улицу',
+    [RealtyWindowView.Yard]: 'Во двор',
+    [RealtyWindowView.Both]: 'В обе стороны',
+  },
+};

package/src/registry/v1/dictionaries/Shape.ts

@@ -0,0 +1,12 @@
+import { ShapeType } from '../types';
+
+export const ShapeDictionary = {
+  Type: {
+    [ShapeType.AdministrativeDistrict]: 'Административный округ',
+    [ShapeType.Block]: 'Квартал',
+    [ShapeType.Complex]: 'Новостройка',
+    [ShapeType.District]: 'Район',
+    [ShapeType.House]: 'Здание',
+    [ShapeType.Microdistrict]: 'Микрорайон',
+  },
+};

package/src/registry/v1/dictionaries/index.ts

@@ -0,0 +1,3 @@
+export * from './AddressBTIParams';
+export * from './Realty';
+export * from './Shape';

package/src/registry/v1/index.ts

@@ -3,9 +3,19 @@ import * as api from './api';
 export class Api {
   constructor(private baseURL: string | undefined) {}
 
+  // complex
+
   findComplexIds = (params: api.FindComplexIdsParams) => {
     return api.findComplexIdsRequest({ params, baseURL: this.baseURL });
   };
+
+  // realty
+
+  findRealties = (params: api.FindRealtiesParams) => {
+    return api.findRealtiesRequest({ params, baseURL: this.baseURL });
+  };
 }
 
 export * from './api';
+export * from './dictionaries';
+export * from './types';

package/src/registry/v1/types/Address.ts

@@ -0,0 +1,29 @@
+import { AddressBTIParams } from './AddressBTIParams';
+import { AddressMetroDistance } from './AddressMetroDistance';
+import { Shape } from './Shape';
+
+export type Address = {
+  btiParams: Partial<AddressBTIParams>;
+  country: string;
+  fullAddress: string;
+  id: number;
+  isManual: boolean;
+  lat: number;
+  lng: number;
+  metroDistances: Array<Partial<AddressMetroDistance> & { id: number }>;
+  shapes: Array<Partial<Shape> & { id: number }>;
+
+  city?: string;
+  cityArea?: string;
+  district?: string;
+  draftName?: string;
+  fiasCode?: number;
+  house?: string;
+  kladrCode?: number;
+  medianPrice?: number;
+  medianSqmPrice?: number;
+  postalCode?: number;
+  realtyIds?: number[];
+  region?: string;
+  street?: string;
+};

package/src/registry/v1/types/AddressBTIParams.ts

@@ -0,0 +1,42 @@
+export enum AddressBTIParamsParking {
+  Ground = 'ground',
+  Multilevel = 'multilevel',
+  Underground = 'underground',
+}
+
+export enum AddressBTIParamsWallsMaterial {
+  Brick = 'brick',
+  Monolith = 'monolith',
+  Monobrick = 'monobrick',
+  Timber = 'timber',
+  Panel = 'panel',
+  Block = 'block',
+}
+
+export enum AddressBTIParamsHeatingType {
+  None = 'none',
+  Central = 'central',
+  Local = 'local',
+  Gas = 'gas',
+  Electricity = 'electricity',
+  Liquid = 'liquid',
+}
+
+export type AddressBTIParams = {
+  buildYear?: number;
+  cargoLifts?: number;
+  ceilingHeight?: number;
+  deliveryQuarter?: number;
+  deliveryYear?: number;
+  emergency?: boolean;
+  floors?: number;
+  garbageChute?: boolean;
+  heatingType?: AddressBTIParamsHeatingType;
+  id?: number;
+  isDelivered?: boolean;
+  isUpToDate?: boolean;
+  parking?: AddressBTIParamsParking;
+  passengerLifts?: number;
+  series?: string;
+  wallsMaterial?: AddressBTIParamsWallsMaterial;
+};

package/src/registry/v1/types/AddressMetroDistance.ts

@@ -0,0 +1,9 @@
+export type AddressMetroDistance = {
+  distance: number;
+  id: number;
+  metroLine: string;
+  metroLineColor: string;
+  metroStation: string;
+  timeCar: number;
+  timeFoot: number;
+};

package/src/registry/v1/types/Image.ts

@@ -0,0 +1,13 @@
+export enum ImageType {
+  Complex = 'complex',
+  Apartment = 'apartment',
+  Layout = 'layout',
+}
+
+export type Image = {
+  id: number;
+  properties: { oldId?: number; maxSize?: string };
+  storagePath: string;
+  thumbnailPath: string;
+  type: string | ImageType;
+};