@wbsuite/react-hooks 1.0.211 → 1.0.212

package/src/hooks/useInvites/index.ts

@@ -0,0 +1,19 @@
+import { RequestorOptions } from 'models/Requestor';
+import { BackendHook, useBackend } from '../useBackend';
+
+export const useInvites: BackendHook<any> = (auth?: RequestorOptions['auth']) => {
+  const { requestor, ...endpoints } = useBackend<any>('invites', { auth });
+  return {
+    requestor,
+    ...endpoints,
+    validate: (invite: string) => {
+      return requestor.makeRequest.post(`invites/validate`, { invite }).then(({ data }) => data);
+    },
+    accept: (invite: string) => {
+      return requestor.makeRequest.post(`invites/accept`, { invite }).then(({ data }) => data);
+    },
+    reject: (invite: string) => {
+      return requestor.makeRequest.post(`invites/reject`, { invite }).then(({ data }) => data);
+    }
+  };
+};

package/src/hooks/useLabels/index.ts

@@ -0,0 +1,13 @@
+
+import { RequestorOptions } from 'models/Requestor';
+import { BackendHook, useBackend } from '../useBackend';
+
+export type ILabel = Record<string, unknown>;
+
+export const useLabels: BackendHook<ILabel> = (auth?: RequestorOptions['auth']) => {
+  const { requestor, ...endpoints } = useBackend<ILabel>('labels', { auth });
+  return {
+    requestor,
+    ...endpoints,
+  };
+};

package/src/hooks/useLanguages/index.ts

@@ -0,0 +1,16 @@
+import { RequestorOptions } from 'models/Requestor';
+import { BackendHook, useBackend } from '../useBackend';
+import { ILang } from '@wb/types/lang/lang.model';
+
+export const useLanguages: BackendHook<ILang, any, { getProductLanguages: () => Promise<ILang[]> }> = (auth?: RequestorOptions['auth']) => {
+  const { requestor, ...rest } = useBackend('languages', { auth });
+  return {
+    ...rest,
+    requestor,
+    getProductLanguages: () => {
+      return requestor.makeRequest
+        .get(`languages/product`)
+        .then(({ data }) => data);
+    },
+  };
+};

package/src/hooks/useLeads/index.ts

@@ -0,0 +1,149 @@
+import { BackendHook, useBackend } from '../useBackend';
+import { RequestorOptions } from 'models/Requestor';
+
+export type LeadStatus = 'new' | 'contacted' | 'closed' | 'bad' | 'lost';
+export enum LeadGradeValues {
+  BAD = -1,
+  NEUTRAL = 0,
+  GOOD = 1,
+}
+
+export const useLeads: BackendHook<
+  any,
+  any,
+  {
+    createLead: (campaignId: string, lead: any) => Promise<any>;
+    getLeadSummary: (filter: Record<string, unknown>) => Promise<any>;
+    getAvailableAsignees: (leadId: string) => Promise<any>;
+    assign: (leadId: string, userId: string) => Promise<any>;
+    archive: (leadId: string) => Promise<any>;
+    addLog: (leadId: string, log: { text: string; extra?: Record<string, unknown> }) => Promise<any>;
+    logHistory: (leadId: string, limit?: number) => Promise<any>;
+    assignmentHistory: (leadId: string, limit?: number) => Promise<any>;
+    actionHistory: (leadId: string, limit?: number) => Promise<any>;
+    commentsHistory: (leadId: string, limit?: number) => Promise<any>;
+    addAction: (leadId: string, action: Record<string, unknown>) => Promise<any>;
+    editAction: (leadId: string, actionId: string, action: Record<string, unknown>) => Promise<any>;
+    deleteAction: (leadId: string, actionId: string) => Promise<any>;
+    completeAction: (leadId: string, actionId: string, completed: boolean) => Promise<any>;
+    grade: (leadId: string, grade: { assessment: LeadGradeValues; description?: string }) => Promise<any>;
+  }
+> = (auth?: RequestorOptions['auth']) => {
+  const { requestor, ...endpoints } = useBackend(`leads`, { auth });
+
+  return {
+    requestor,
+    ...endpoints,
+    createLead: (campaignId: string, lead: any) => {
+      return requestor.makeRequest.post(`leads/${campaignId}`, lead).then((r: { data: any }) => r.data);
+    },
+    getLeadSummary: (filter: Record<string, unknown> = {}) => {
+      return requestor.makeRequest.get('leads/summary', { params: filter }).then((r: { data: any }) => r.data);
+    },
+    getAvailableAsignees: (leadId: string) => {
+      return requestor.makeRequest.get(`leads/${leadId}/available-assignees`).then((r: { data: any }) => r.data);
+    },
+    assign: (leadId: string, userId: string) => {
+      return requestor.makeRequest.post(`leads/${leadId}/assign/${userId}`, {}).then((r: { data: any }) => r.data);
+    },
+    manualAssign: (leadId: string, userId: string) => {
+      return requestor.makeRequest.post(`leads/${leadId}/assign/manual/${userId}`, {}).then((r: { data: any }) => r.data);
+    },
+    archive: (leadId: string) => {
+      return requestor.makeRequest.post(`leads/${leadId}/archive`).then((r: { data: any }) => r.data);
+    },
+    addLog: (leadId: string, log: { text: string; extra?: Record<string, unknown> }) => {
+      return requestor.makeRequest.post(`leads/${leadId}/log`, log).then((r) => r.data);
+    },
+    logHistory: (leadId: string, limit?: number) => {
+      return requestor.makeRequest.get(`leads/${leadId}/log/history`, { params: { limit } }).then((r) => r.data);
+    },
+    assignmentHistory: (leadId: string, limit?: number) => {
+      return requestor.makeRequest.get(`leads/${leadId}/assignment/history`, { params: { limit } }).then((r) => r.data);
+    },
+    actionHistory: (leadId: string, limit?: number) => {
+      return requestor.makeRequest.get(`leads/${leadId}/action/history`, { params: { limit } }).then((r) => r.data);
+    },
+    commentsHistory: (leadId: string, limit?: number) => {
+      return requestor.makeRequest.get(`leads/${leadId}/comment/history`, { params: { limit } }).then((r) => r.data);
+    },
+    addAction: (leadId: string, action: Record<string, unknown>) => {
+      return requestor.makeRequest.post(`leads/${leadId}/action`, action).then((r: { data: any }) => r.data);
+    },
+    editAction: (leadId: string, actionId: string, action: Record<string, unknown>) => {
+      return requestor.makeRequest.put(`leads/${leadId}/action/${actionId}`, action).then((r: { data: any }) => r.data);
+    },
+    deleteAction: (leadId: string, actionId: string) => {
+      return requestor.makeRequest.delete(`leads/${leadId}/action/${actionId}`).then((r: { data: any }) => r.data);
+    },
+    completeAction: (leadId: string, actionId: string, completed: boolean) => {
+      return requestor.makeRequest
+        .post(`leads/${leadId}/action/${actionId}/complete`, {
+          completed,
+        })
+        .then((r: { data: any }) => r.data);
+    },
+    grade: (
+      leadId: string,
+      grade: {
+        assessment: (typeof LeadGradeValues)[keyof typeof LeadGradeValues];
+        description?: string;
+      }
+    ) => {
+      return requestor.makeRequest.post(`leads/${leadId}/grade`, { ...grade }).then((r: { data: any }) => r.data);
+    },
+    createQuote: (leadId: string, quote: Record<string, unknown>) => {
+      return requestor.makeRequest.post(`leads/${leadId}/quote`, quote).then((r: { data: any }) => r.data);
+    },
+    createManualQuote: (leadId: string, quote: Record<string, unknown>) => {
+      return requestor.makeRequest.post(`leads/${leadId}/quote/manual`, quote).then((r: { data: any }) => r.data);
+    },
+    acceptQuote: (leadId: string, quoteId: string) => {
+      return requestor.makeRequest.post(`leads/${leadId}/quote/${quoteId}/accept`).then((r: { data: any }) => r.data);
+    },
+    linkToCustomer: (leadId: string, customerId: string) => {
+      return requestor.makeRequest
+        .post(`leads/${leadId}/link/customer/${customerId}`)
+        .then((r: { data: any }) => r.data);
+    },
+    changeLeadStatus: (leadId: string, request: { newStatus: string; reason?: string }) => {
+      return requestor.makeRequest.put(`leads/${leadId}/status`, request).then((r) => r.data);
+    },
+    closeLead: (leadId: string, request: { reason?: string }) => {
+      return requestor.makeRequest.post(`leads/${leadId}/close`, request).then((r) => r.data);
+    },
+    cancelLead: (leadId: string, request: { reason?: string }) => {
+      return requestor.makeRequest.post(`leads/${leadId}/cancel`, request).then((r) => r.data);
+    },
+    reevaluateLeadStatus: (leadId: string) => {
+      return requestor.makeRequest.post(`leads/${leadId}/reevaluate/status`).then((r) => r.data);
+    },
+    relocate: (leadId: string, { campaign, store }: { campaign?: string; store?: string }) => {
+      return requestor.makeRequest.put(`leads/${leadId}/relocate`, { campaign, store }).then((r) => r.data);
+    },
+    unassign: (leadId: string) => {
+      return requestor.makeRequest.post(`leads/${leadId}/unassign`).then((r) => r.data);
+    },
+    updateStore: (leadId: string, storeId: string) => {
+      return requestor.makeRequest.put(`leads/${leadId}/store/${storeId}`).then((r) => r.data);
+    },
+    bulkUpdateStore: (leadIds: string[], storeId: string) => {
+      return requestor.makeRequest.put(`leads/bulk/store/${storeId}`, { leadIds }).then((r) => r.data);
+    },
+    updateRotation: (leadId: string, rotationId: string) => {
+      return requestor.makeRequest.put(`leads/${leadId}/rotation/${rotationId}`).then((r) => r.data);
+    },
+    bulkUpdateRotation: (leadIds: string[], rotationId: string) => {
+      return requestor.makeRequest.put(`leads/bulk/rotation/${rotationId}`, { leadIds }).then((r) => r.data);
+    },
+    bulkAssign: (leadIds: string[], userId: string) => {
+      return requestor.makeRequest.put(`leads/bulk/assign/${userId}`, { leadIds }).then((r) => r.data);
+    },
+    bulkClose: (leadIds: string[], reason?: string) => {
+      return requestor.makeRequest.put(`leads/bulk/close`, { leadIds, reason }).then((r) => r.data);
+    },
+    getReport: (filters: Record<string, unknown>, options: Partial<{ sendEmail: boolean, email: string; format: 'csv' | 'xlsx' }> = {}) => {
+      return requestor.makeRequest.post(`leads/report/request`, { filters, options }).then((r) => r.data);
+    },
+  };
+};

package/src/hooks/useMedia/index.ts

@@ -0,0 +1,13 @@
+import { RequestorOptions } from 'models/Requestor';
+import { BackendHook, useBackend } from '../useBackend';
+
+export const useMedia: BackendHook<any, any> = (auth?: RequestorOptions['auth']) => {
+  const { requestor, ...rest } = useBackend('media', { auth });
+  return {
+    ...rest,
+    requestor,
+    getShareableLink: (entity: string, entityId: string) => {
+      return requestor.makeRequest.post(`media/share`, { entity, entityId }).then((r: { data: any }) => r.data);
+    },
+  };
+};

package/src/hooks/useOrders/index.ts

@@ -0,0 +1,74 @@
+import { RequestorOptions } from 'models/Requestor';
+import { BackendHook, useBackend } from '../useBackend';
+
+export const useOrders: BackendHook<any> = (auth?: RequestorOptions['auth']) => {
+  const { requestor, ...endpoints } = useBackend(`orders`, { auth });
+
+  return {
+    requestor,
+    ...endpoints,
+    createManual: (order: any) => {
+      return requestor.makeRequest.post(`orders/manual`, order).then((r) => r.data);
+    },
+    get: (orderId: string, skipProductDetails: boolean = true) => {
+      return requestor.makeRequest.get(`orders/${orderId}?skipProductDetails=${skipProductDetails}`).then((r) => r.data);
+    },
+    addLog: (orderId: string, log: { text: string; extra?: Record<string, unknown> }) => {
+      return requestor.makeRequest.post(`orders/${orderId}/notes`, log).then((r) => r.data);
+    },
+    logHistory: (orderId: string, limit?: number) => {
+      return requestor.makeRequest.get(`orders/${orderId}/log/history`, { params: { limit } }).then((r) => r.data);
+    },
+    deleteLog: (orderId: string, logId: string) => {
+      return requestor.makeRequest.delete(`orders/${orderId}/notes/${logId}`).then((r) => r.data);
+    },
+    commentsHistory: (orderId: string, limit?: number) => {
+      return requestor.makeRequest.get(`orders/${orderId}/notes`, { params: { limit } }).then((r) => r.data);
+    },
+    paymentHistory: (orderId: string, limit?: number) => {
+      return requestor.makeRequest.get(`orders/${orderId}/payment/history`, { params: { limit } }).then((r) => r.data);
+    },
+    getAvailableStock: (orderId: string, productId: string) => {
+      return requestor.makeRequest.get(`orders/${orderId}/stock/${productId}/available`).then((r) => r.data);
+    },
+    assignStock: (orderId: string, productId: string, stockId: string) => {
+      return requestor.makeRequest.post(`orders/${orderId}/stock/${productId}/assign/${stockId}`).then((r) => r.data);
+    },
+    unassignStock: (orderId: string, productId: string, stockId: string) => {
+      return requestor.makeRequest.post(`orders/${orderId}/stock/${productId}/unassign/${stockId}`).then((r) => r.data);
+    },
+    replaceStock: (orderId: string, productId: string, stockId: string, newStockId: string) => {
+      return requestor.makeRequest.post(`orders/${orderId}/stock/${productId}/replace/${stockId}/${newStockId}`).then((r) => r.data);
+    },
+    convertToDraft: (orderId: string) =>{
+      return requestor.makeRequest.post(`orders/${orderId}/draft`).then((r) => r.data);
+    },
+    convertToUndraft: (orderId: string) =>{
+      return requestor.makeRequest.post(`orders/${orderId}/undraft`).then((r) => r.data);
+    },
+    changeOrderStatus: (orderId: string, request: { newStatus: string, reason?: string }) =>{
+      return requestor.makeRequest.put(`orders/${orderId}/status`, request).then((r) => r.data);
+    },
+    closeOrder: (orderId: string, request: { reason?: string }) =>{
+      return requestor.makeRequest.post(`orders/${orderId}/close`, request).then((r) => r.data);
+    },
+    cancelOrder: (orderId: string, request: { reason?: string }) =>{
+      return requestor.makeRequest.post(`orders/${orderId}/cancel`, request).then((r) => r.data);
+    },
+    approveOrder: (orderId: string) =>{
+      return requestor.makeRequest.post(`orders/${orderId}/approve`).then((r) => r.data);
+    },
+    rejectOrder: (orderId: string) =>{
+      return requestor.makeRequest.post(`orders/${orderId}/reject`).then((r) => r.data);
+    },
+    reevaluateOrderStatus: (orderId: string) =>{
+      return requestor.makeRequest.post(`orders/${orderId}/reevaluate/status`).then((r) => r.data);
+    },
+    getPublic: (orderId: string) => {
+      return requestor.makeRequest.get(`orders/${orderId}/public`).then((r) => r.data);
+    },
+    getReport: (filters: Record<string, unknown>, options: Partial<{ sendEmail: boolean, email?: string; format?: 'csv' | 'xlsx' }> = {}) => {
+      return requestor.makeRequest.post(`orders/report/request`, { filters, options }).then((r) => r.data);
+    },
+  };
+};

package/src/hooks/usePaths/index.ts

@@ -0,0 +1,16 @@
+import { RequestorOptions } from 'models/Requestor';
+import { BackendHook, useBackend } from '../useBackend';
+
+export const usePaths: BackendHook<
+  Record<string, string>,
+  undefined
+> = (auth?: RequestorOptions['auth']) => {
+  const { requestor, ...rest } = useBackend('paths', { auth });
+  return {
+    ...rest,
+    requestor,
+    getByKey: (key: string) => {
+      return requestor.makeRequest.get(`paths/${key}`).then(({ data }) => data);
+    }
+  };
+};

package/src/hooks/usePermissions/index.ts

@@ -0,0 +1,16 @@
+import { BackendHook, useBackend } from '../useBackend';
+import { RequestorOptions } from 'models/Requestor';
+
+export const usePermissions: BackendHook = (auth?: RequestorOptions['auth']) => {
+  const { requestor, ...endpoints } = useBackend('permissions', { auth });
+  return {
+    requestor,
+    ...endpoints,
+    create: (data) =>
+      requestor.makeRequest.post(`permissions`, data).then(({ data }) => data),
+    update: (id: any, data: any) =>
+      requestor.makeRequest.put(`permissions/${id}`, data).then(({ data }) => data),
+    delete: (id: string) =>
+      requestor.makeRequest.delete(`permissions/${id}`).then(({ data }) => data),
+  };
+};

package/src/hooks/useProducts/index.ts

@@ -0,0 +1,18 @@
+import { BackendHook, useBackend } from '../useBackend';
+import { RequestorOptions } from 'models/Requestor';
+
+export const useProducts: BackendHook = (auth?: RequestorOptions['auth']) => {
+  const { requestor, ...endpoints } = useBackend('products', { auth });
+  return {
+    requestor,
+    ...endpoints,
+    create: (data) =>
+      requestor.makeRequest.post(`products`, data).then(({ data }) => data),
+    update: (id: any, data: any) =>
+      requestor.makeRequest.put(`products/${id}`, data).then(({ data }) => data),
+    delete: (id: string) =>
+      requestor.makeRequest.delete(`products/${id}`).then(({ data }) => data),
+    import: (userConnectionId: string, storeId: string | null) =>
+      requestor.makeRequest.post(`products/import`, { userConnectionId, storeId }).then(({ data }) => data),
+  };
+};

package/src/hooks/useProfile/index.ts

@@ -0,0 +1,20 @@
+import { BackendHook, useBackend } from '../useBackend';
+import { Chat } from '@wb/types/chats/chats.model';
+import { RequestorOptions } from 'models/Requestor';
+
+export const useProfile: BackendHook<Chat> = (auth?: RequestorOptions['auth']) => {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const { requestor, ...endpoints } = useBackend('users/profile', { auth });
+  return {
+    requestor,
+    ...endpoints,
+    updateProfile: (profile: { name: string }) => requestor.makeRequest.put(`users/profile`, profile).then(({ data }) => data),
+    requestPasswordChange: () => requestor.makeRequest.post(`users/profile/request-password-change`).then(({ data }) => data),
+    requestEmailChange: () => requestor.makeRequest.post(`users/profile/request-email-change`).then(({ data }) => data),
+    requestEmailVerification: () => requestor.makeRequest.post(`users/profile/request-email-verification`).then(({ data }) => data),
+    passwordRecovery: (emailOrUsername: string) => requestor.makeRequest.post(`users/profile/recover-password`, { emailOrUsername }).then(({ data }) => data),
+    changeEmail: (token: string, newEmail: string) => requestor.makeRequest.post(`users/profile/change-email`, { token, newEmail }).then(({ data }) => data),
+    changePassword: (token: string, newPassword: string) => requestor.makeRequest.post(`users/profile/change-password`, { token, newPassword }).then(({ data }) => data),
+    verifyEmail: (token: string) => requestor.makeRequest.post(`users/profile/verify-email`, { token }).then(({ data }) => data),
+  };
+};

package/src/hooks/useRenting/index.ts

@@ -0,0 +1,57 @@
+import { RequestorOptions } from 'models/Requestor';
+import { BackendHook, useBackend } from '../useBackend';
+
+type RentingDetails = {
+  startsAt: string,
+  endsAt: string,
+  pickUpStore?: string;
+  dropOffStore?: string;
+}
+
+type ListAvailableRentingDetails = RentingDetails & {
+  categories: string[];
+}
+
+type GetBugdetRentingDetails = RentingDetails & {
+  products: { product: string, variant?: { variant: string, orderedQty?: number }[], orderedQty?: number }[];
+}
+
+type PlaceRentRentingDetails = GetBugdetRentingDetails & { 
+  customer: {
+    name: string,
+    email: string
+  }
+}
+
+export const useRenting: BackendHook<any, any, {
+  listAvailable: (storeId: string, rentingDetails: ListAvailableRentingDetails) => Promise<RentingDetails>,
+  getBudget: (storeId: string, rentingDetails: GetBugdetRentingDetails) => Promise<{
+    price: number;
+    priceBeforeDiscounts: number;
+    priceInBase: number;
+    priceInBaseBeforeDiscounts: number;
+    endsAt: string;
+    startsAt: string;
+    pickUpStore: { store: string, name: Record<string, string> };
+    dropOffStore: { store: string, name: Record<string, string> };
+  }>,
+  rent: (storeId: string, rentingDetails: PlaceRentRentingDetails) => Promise<Record<string, unknown>>
+}> = (auth?: RequestorOptions['auth']) => {
+  const { requestor, ...rest } = useBackend('rentings', { auth });
+  return {
+    requestor,
+    ...rest,
+    listAvailable: (storeId: string, rentingDetails: ListAvailableRentingDetails) => {
+      return requestor.makeRequest.post(`rentings/available/${storeId}`, rentingDetails).then(({ data }) => data)
+    },
+    getBudget: (storeId: string, rentingDetails: GetBugdetRentingDetails) => {
+      return requestor.makeRequest.post(`rentings/getPrice/${storeId}`, rentingDetails).then(({ data }) => data)
+    },
+    rent: (storeId: string, rentingDetails: PlaceRentRentingDetails) => {
+      return requestor.makeRequest.post(`rentings/${storeId}`, rentingDetails).then(({ data }) => data)
+    },
+    getPublic: (rentingId: string) => {
+      return requestor.makeRequest.get(`rentings/${rentingId}/public`).then(({ data }) => data);
+    },
+  };
+};

package/src/hooks/useRoles/index.ts

@@ -0,0 +1,10 @@
+import { BackendHook, useBackend } from '../useBackend';
+import { RequestorOptions } from 'models/Requestor';
+
+export const useRoles: BackendHook<Record<string, string>, any> = (auth?: RequestorOptions['auth']) => {
+  const { requestor, ...rest } = useBackend('roles', { auth });
+  return {
+    ...rest,
+    requestor,
+  };
+};

package/src/hooks/useRoom/index.ts

@@ -0,0 +1,20 @@
+import { BackendHook, useBackend } from '../useBackend';
+import { Chat } from '@wb/types/chats/chats.model';
+import { RequestorOptions } from 'models/Requestor';
+
+export const useRooms: BackendHook<Chat> = (auth?: RequestorOptions['auth']) => {
+  const { requestor, ...endpoints } = useBackend('rooms', { auth });
+  return {
+    requestor,
+    ...endpoints,
+    createRoom: (chatId: string) =>
+      requestor.makeRequest.post(`rooms/${chatId}`).then(({ data }) => data),
+    message: (roomId: string, message: any) =>
+      requestor.makeRequest.post(`rooms/reply/${roomId}`, message).then(({ data }) => data),
+    reset: (roomId: string) => requestor.makeRequest.post(`rooms/${roomId}/reset`).then(({ data }) => data),
+    createRoomForUserConnection: (userConnectionId: string, identityId:string) =>
+      requestor.makeRequest.post(`rooms/${userConnectionId}/${identityId}`).then(({ data }) => data),
+    comment: (roomId: string, message: any) =>
+      requestor.makeRequest.post(`rooms/${roomId}/comment`, message).then(({ data }) => data),
+  };
+};

package/src/hooks/useRotations/index.ts

@@ -0,0 +1,13 @@
+import { RequestorOptions } from 'models/Requestor';
+import { BackendHook, useBackend } from '../useBackend';
+
+export const useRotations: BackendHook<any, any> = (auth?: RequestorOptions['auth']) => {
+  const { requestor, ...rest } = useBackend('rotations', { auth });
+  return {
+    ...rest,
+    requestor,
+    makeDefault: (rotationId: string) => {
+      return requestor.makeRequest.post(`rotations/${rotationId}/makeDefault`).then(({ data }) => data);
+    },
+  };
+};

package/src/hooks/useSiteConfig/index.ts

@@ -0,0 +1,13 @@
+import { CustomResponse } from '@wb/types/custom-response/custom-response.model';
+import { BackendHook, useBackend } from '../useBackend';
+import { RequestorOptions } from 'models/Requestor';
+
+export const useSiteConfig: BackendHook<any, any, { getForSession: () => Promise<CustomResponse> }> = (auth?: RequestorOptions['auth']) => {
+  // eslint-disable-next-line
+  const { requestor, ...rest } = useBackend('app-configs', { auth });
+  return {
+    requestor,
+    ...rest,
+    getForSession: () => requestor.makeRequest.get('app-configs').then(r => r.data)
+  };
+};

package/src/hooks/useStatuses/index.ts

@@ -0,0 +1,10 @@
+import { RequestorOptions } from 'models/Requestor';
+import { BackendHook, useBackend } from '../useBackend';
+
+export const useStatuses: BackendHook<any, any> = (auth?: RequestorOptions['auth']) => {
+  const { requestor, ...rest } = useBackend('statuses', { auth });
+  return {
+    ...rest,
+    requestor,
+  };
+};

package/src/hooks/useStock/index.ts

@@ -0,0 +1,48 @@
+import { RequestorOptions } from 'models/Requestor';
+import { BackendHook, useBackend } from '../useBackend';
+import { IProductStock } from '@wb/types/products/products.model';
+
+export const useStock: BackendHook<IProductStock, undefined, {
+  getStatus: (unitId: string) => Promise<IProductStock>;
+  addNote: (unitId: string, { text, extra }: { text: string; extra?: Record<string, unknown> }) => Promise<IProductStock>;
+  delete: (unitId: string) => Promise<boolean>;
+  logHistory: (unitId: string, limit?: number) => Promise<IProductStock>;
+  commentsHistory: (unitId: string, limit?: number) => Promise<IProductStock>;
+  changeStockStatus: (unitId: string, request: { newStatus: string, reason?: string }) => Promise<IProductStock>;
+  reevaluateStockStatus: (unitId: string) => Promise<IProductStock>;
+  markReceived: (unitId: string, request: { comment?: string }) => Promise<IProductStock>;
+}> = (auth?: RequestorOptions['auth']) => {
+  const { requestor, ...endpoints } = useBackend('products/stock', { auth });
+
+  return {
+    requestor,
+    ...endpoints,
+    delete: (unitId: string) => {
+      return requestor.makeRequest.delete(`products/stock/${unitId}`).then((r) => r.data);
+    },
+    getStatus: (unitId: string) => {
+      return requestor.makeRequest.get(`products/stock/status/${unitId}`).then((r) => r.data);
+    },
+    addNote: (unitId: string, { text, extra }: { text: string; extra?: Record<string, unknown> }) => {
+      return requestor.makeRequest.post(`products/stock/${unitId}/notes`, { text, extra }).then((r) => r.data);
+    },
+    logHistory: (unitId: string, limit?: number) => {
+      return requestor.makeRequest.get(`products/stock/${unitId}/log/history`, { params: { limit } }).then((r) => r.data);
+    },
+    commentsHistory: (unitId: string, limit?: number) => {
+      return requestor.makeRequest.get(`products/stock/${unitId}/comment/history`, { params: { limit } }).then((r) => r.data);
+    },
+    changeStockStatus: (unitId: string, request: { newStatus: string, reason?: string }) =>{
+      return requestor.makeRequest.put(`products/stock/${unitId}/status`, request).then((r) => r.data);
+    },
+    reevaluateStockStatus: (unitId: string) =>{
+      return requestor.makeRequest.post(`products/stock/${unitId}/reevaluate/status`).then((r) => r.data);
+    },
+    markReceived: (unitId: string, request: { comment?: string }) =>{
+      return requestor.makeRequest.post(`products/stock/${unitId}/mark-received`, request).then((r) => r.data);
+    },
+    bulkMarkReceived: (stockIds: string[], request: { comment?: string }) => {
+      return requestor.makeRequest.put(`products/stock/bulk/mark-received`, { unitIds: stockIds, ...request }).then((r) => r.data);
+    },
+  };
+};

package/src/hooks/useStores/index.ts

@@ -0,0 +1,23 @@
+import { RequestorOptions } from 'models/Requestor';
+import { BackendHook, useBackend } from '../useBackend';
+import { IStore } from '@wb/types/store/store.model';
+
+export const useStores: BackendHook<IStore> = (auth?: RequestorOptions['auth']) => {
+  const { requestor, ...rest } = useBackend<IStore>('stores', { auth });
+  return {
+    ...rest,
+    requestor,
+    delete: (id: string) =>
+      requestor.makeRequest.delete(`stores/${id}`).then(({ data }) => data),
+    delegate: (id: string, data: { userId: string } | { teamId: string }) =>
+      requestor.makeRequest.post(`stores/${id}/delegate`, data).then(({ data }) => data),
+    undelegate: (id: string, reason?: string) =>
+      requestor.makeRequest.post(`stores/${id}/undelegate`, { reason }).then(({ data }) => data),
+    inviteToManage: (storeId: string, data: { userEmail: string }) =>
+      requestor.makeRequest.post(`stores/${storeId}/invite-to-manage`, data).then(({ data }) => data),
+    acceptManagement: (requestToken: string) =>
+      requestor.makeRequest.post(`stores/accept-manage`, { requestToken }).then(({ data }) => data),
+    rejectManagement: (requestToken: string) =>
+      requestor.makeRequest.post(`stores/reject-manage`, { requestToken }).then(({ data }) => data),
+  };
+};

package/src/hooks/useSubscriptions/index.ts

@@ -0,0 +1,17 @@
+
+import { BackendHook, useBackend } from '../useBackend';
+import { RequestorOptions } from 'models/Requestor';
+
+export const useSubscriptions: BackendHook<
+  Record<string, string>,
+  any
+> = (auth?: RequestorOptions['auth']) => {
+  const { requestor, ...rest } = useBackend('subscriptions', { auth });
+  return {
+    ...rest,
+    requestor,
+    listPaymentMethods: () => {
+      return requestor.makeRequest.get(`subscriptions/payment-methods`).then(({ data }) => data);
+    },
+  };
+};

package/src/hooks/useTable/index.ts

@@ -0,0 +1,15 @@
+import { RequestorOptions } from 'models/Requestor';
+import { BackendHook, useBackend } from '../useBackend';
+import { IStore } from '@wb/types/store/store.model';
+
+export const useTables: BackendHook<IStore> = (auth?: RequestorOptions['auth']) => {
+  const { requestor, ...endpoints } = useBackend('tables', { auth });
+
+  return {
+    requestor,
+    ...endpoints,
+    list: () => {
+      return requestor.makeRequest.get(`tables/list`).then((r) => r.data);
+    },
+  };
+};

package/src/hooks/useTeams/index.ts

@@ -0,0 +1,29 @@
+import { RequestorOptions } from 'models/Requestor';
+import { BackendHook, useBackend } from '../useBackend';
+
+export const useTeams: BackendHook<
+  Record<string, string>,
+  undefined,
+  {
+    getTeamInfo: (teamId: string) => Promise<void>;
+    updateTeamName: (teamId: string, name: string) => Promise<void>;
+  }
+> = (auth?: RequestorOptions['auth']) => {
+  const { requestor, ...rest } = useBackend('teams', { auth });
+  return {
+    ...rest,
+    requestor,
+    updateTeamName: (teamId: string, name: string) => {
+      return requestor.makeRequest.put(`teams/${teamId}`, { name }).then(({ data }) => data);
+    },
+    getTeamInfo: (teamId: string) => {
+      return requestor.makeRequest.get(`teams/${teamId}`).then(({ data }) => data);
+    },
+    inviteToTeam: (invitation: { email: string; roles: string[]; store: string[] }) => {
+      return requestor.makeRequest.post(`teams/invite`, invitation).then(({ data }) => data);
+    },
+    subscriptionStatus: () => {
+      return requestor.makeRequest.get(`teams/subscription-status`).then(({ data }) => data);
+    },
+  };
+};