@up-im/medotvet_sdk 0.0.1

package/src/api/content.ts

@@ -0,0 +1,258 @@
+import { apiRouteBannerGetRand, apiRouteCheckAppVersion, apiRouteEnv, apiRouteGetCloudVersion, apiRouteItemById, apiRouteList, apiRouteNode, apiRouteNodeTree } from "../http/apiRoute"
+import { iArticle } from "../interfaces/iArticle"
+import { iBank } from "../interfaces/iBank"
+import { iBanner } from "../interfaces/iBanner"
+import { BannerType, BannerTypeKeys } from "../interfaces/BannerType"
+import { iCity } from "../interfaces/iCity"
+import { iContentItem } from "../interfaces/iContentItem"
+import { iFilter } from "../interfaces/iFilter"
+import { iInstruction } from "../interfaces/iInstruction"
+import { iNode } from "../interfaces/iNode"
+import { iNodeTree } from "../interfaces/iNodeTree"
+import { iPagingItems } from "../interfaces/iPagingItems"
+import { iSearchParams } from "../interfaces/iSearchParams"
+import { iText } from "../interfaces/iText"
+import { ApiAbstract } from "./abstract"
+import { iStories } from "../interfaces/iStories"
+import { iEnv } from "../interfaces/iEnv"
+import { iIntro } from "../interfaces/iIntro"
+import { iAppStore } from "../interfaces/iAppStore"
+import { iSpecialization } from "../interfaces/iSpecialization"
+
+export class ApiContent extends ApiAbstract {
+    /**
+     * получение настроек, включая размер реферальных вознаграждений
+     */
+    async getEnv() {
+        return this.fetcher<iEnv>({ route: apiRouteEnv })
+    }
+    /**
+    * проверка актуальности версии приложения
+    * @param {number} params.appStore - магазин приложения  "App Store" или "Google Play"
+    * @param {boolean} params.appVersion - версия приложения, например 1.0.0
+    */
+    async checkAppVersion({ appStore, appVersion }: { appStore: iAppStore, appVersion: string }) {
+        return this.fetcher<{ isActual: boolean }>({ route: apiRouteCheckAppVersion(appStore, appVersion) })
+    }
+    /**
+    * получение версии приложения для конкретной операционной системы
+    * @param {string} os - операционная система "ios" или "android"
+    */
+    async getCloudVersion(appStore: iAppStore) {
+        return this.fetcher<any>({ route: apiRouteGetCloudVersion(appStore) })
+    }
+    /**
+     * получение дерева категорий. не обязательный параметр 
+     * @param {string} parent id категории от которой строится вложенность
+     */
+    async getNodeTree(parent?: number) {
+        return this.fetcher<iNodeTree[]>({ route: apiRouteNodeTree(parent) })
+    }
+    /**
+     * получение раздела
+     */
+    private async getNodeByCode<T>(nodeCode: string) {
+        return this.fetcher<iNode<T>>({
+            route: apiRouteNode(nodeCode)
+        })
+    }
+    /**
+    * получение списка статей
+    */
+    async getArticleList<Keys extends keyof iArticle>({
+        select,
+        page = 1,//отсчет страниц с первой, чтобы не было путаницы
+        filters,
+        sorters,
+        perPage = 10,
+    }: iSearchParams<iArticle, Keys>) {
+        return this.fetcher<iPagingItems<Pick<iArticle, Keys> & { url?: string }>>({
+            route: apiRouteList({
+                nodeCode: "articles",
+                page,
+                select,
+                filters,
+                sorters,
+                perPage,
+            })
+        })
+    }
+    /**
+    * получение одной статьи
+    */
+    async getArticleOne({ id }: { id: number }) {
+        return this.fetcher<iContentItem<iArticle>>({
+            route: apiRouteItemById("articles", id)
+        })
+    }
+    /**
+    * политика конфиденциальности
+    */
+    async getPolicy() {
+        return this.getNodeByCode<iText>("policy")
+    }
+    /**
+   * оферта
+   */
+    async getTerms() {
+        return this.getNodeByCode<iText>("terms")
+    }
+    /**
+   * Правила программы лояльности
+   */
+    async getLoyalty() {
+        return this.getNodeByCode<iText>("loyalty")
+    }
+    /**
+    * как получить деньги
+    */
+    async getInstruction() {
+        return await this.fetcher<iPagingItems<iInstruction>>({
+            route: apiRouteList({
+                nodeCode: "instruction",
+                select: ["id", "title", "text", "image"],
+                sorters: ["sorter asc"],
+                perPage: 100,
+            })
+        })
+
+    }
+    /**
+  * Согласие на обработку персональных данных
+  */
+    async getAgreement() {
+        return this.getNodeByCode<iText>("agreement")
+    }
+    /**
+   * банки для выбора при запросе на вывод средств
+   * @param {number} props.page - страница. Отсчет страниц с первой, чтобы не было путаницы
+   * @param {string} props.searchTitle - поисковая строка по началу названия банка
+   */
+    async getBanks({ page, searchTitle }: { page: number, searchTitle?: string }) {
+        const filters: iFilter<iBank> = {}
+        if (searchTitle?.length) filters.title = [searchTitle + "%"]
+        return await this.fetcher<iPagingItems<iInstruction>>({
+            route: apiRouteList({
+                nodeCode: "bank",
+                select: ["id", "title"],
+                sorters: ["sorter asc", "title asc"],
+                perPage: 10,
+                filters,
+                page
+            })
+        })
+    }
+    /**
+   * получение списка специализаций врачей
+   * @param {number} props.page - страница. Отсчет страниц с первой, чтобы не было путаницы
+   * @param {string} props.searchTitle - поисковая строка по началу названия банка
+   */
+    async getSpecializationList({ page, searchTitle }: { page: number, searchTitle?: string }) {
+        const filters: iFilter<iSpecialization> = {}
+        if (searchTitle?.length) filters.title = [searchTitle + "%"]
+        return await this.fetcher<iPagingItems<iInstruction>>({
+            route: apiRouteList({
+                nodeCode: "specialization",
+                select: ["id", "title"],
+                sorters: ["sorter asc", "title asc"],
+                perPage: 10,
+                filters,
+                page
+            })
+        })
+    }
+    /**
+   * поиск города
+   * @param {number} props.page - страница. Отсчет страниц с первой, чтобы не было путаницы
+   * @param {string} props.searchTitle - поисковая строка по началу названия банка
+   */
+    async getCityList({ page, searchTitle }: { page: number, searchTitle?: string }) {
+        const filters: iFilter<iCity> = {}
+        if (searchTitle?.length) filters.title = [searchTitle + "%"]
+        return await this.fetcher<iPagingItems<iCity>>({
+            route: apiRouteList({
+                nodeCode: "city",
+                select: ["id", "title"],
+                sorters: ["sorter asc"],
+                perPage: 20,
+                filters,
+                page
+            })
+        })
+    }
+    /**
+    * получение одного города
+    */
+    async getCityOne({ id }: { id: number }) {
+        return this.fetcher<iContentItem<iArticle>>({
+            route: apiRouteItemById("city", id)
+        })
+    }
+    /**
+     * баннер
+     * @param {number} props.type - тип баннера
+     */
+    async getBannerRand({ type, signal }: { type: typeof BannerType[BannerTypeKeys], signal?: AbortSignal }) {
+        return await this.fetcher<{ item: iBanner | undefined }>({
+            route: apiRouteBannerGetRand(type),
+            options: { addToken: true, signal }
+        })
+    }
+    /**
+    * получение списка сторисов
+    */
+    async getStoriesList<Keys extends keyof iStories>({
+        select,
+        page = 1,//отсчет страниц с первой, чтобы не было путаницы
+        perPage = 10,
+    }: iSearchParams<iStories, Keys>): Promise<iPagingItems<Pick<iStories, Keys>>> {
+        const data = await this.fetcher<iPagingItems<Pick<iStories, Keys> & { sku: { id: number, title: string } | null }>>({
+            route: apiRouteList({
+                nodeCode: "stories",
+                page,
+                select,
+                perPage,
+            }),
+            options: { addToken: true }
+        })
+        return {
+            ...data,
+            items: data.items.map(it => ({
+                ...it,
+                sku: it?.sku
+                    ? { id: it.sku.id, title: it.sku.title }
+                    : null
+            }))
+        }
+    }
+    /**
+    * получение одного сториса
+    */
+    async getStoriesOne({ id }: { id: number }): Promise<iContentItem<iStories>> {
+        const data = await this.fetcher<iContentItem<iStories>>({
+            route: apiRouteItemById("stories", id)
+        })
+        return {
+            ...data,
+            item: {
+                ...data.item,
+                sku: data.item?.sku
+                    ? { id: data.item.sku.id, title: data.item.sku.title }
+                    : null
+            }
+        }
+    }
+    /**
+   * получение списка интро (приветственная инструкция)
+   */
+    async getIntro() {
+        return this.fetcher<iPagingItems<iIntro>>({
+            route: apiRouteList({
+                nodeCode: "intro",
+                select: ["id", "title", "image"],
+                sorters: ["sorter asc"],
+                perPage: 50,
+            })
+        })
+    }
+}

package/src/api/geoIp.ts

@@ -0,0 +1,12 @@
+import { apiRouteGeoDetect } from "../http/apiRoute";
+import { iCity } from "../interfaces/iCity";
+import { ApiAbstract } from "./abstract";
+
+export class ApiGeoIp extends ApiAbstract {
+    /**
+    * определение города по ip
+    */
+    async detect() {
+        return this.fetcher<iCity>({ route: apiRouteGeoDetect })
+    }
+}

package/src/api/index.ts

@@ -0,0 +1,38 @@
+import { iStorage } from "../interfaces/iStorage";
+import { storageDefault } from "../storage/default";
+import { UserStorage } from "../storage/user";
+import { ApiBookmarks } from "./bookmarks";
+import { ApiChat } from "./chat";
+import { ApiContent } from "./content";
+import { ApiGeoIp } from "./geoIp";
+import { ApiPayment } from "./payment";
+import { ApiPromocode } from "./promocode";
+import { ApiPush } from "./push";
+import { ApiSurvey } from "./survey";
+import { ApiStat } from "./stat";
+import { ApiUser } from "./user";
+
+export function createClient({
+    host,
+    wsHost,
+    storage
+}: {
+    host: string,
+    wsHost: string,
+    storage?: iStorage
+}) {
+    const userStorage = new UserStorage(storage || storageDefault)
+    const constructorProps = { host, wsHost, userStorage }
+    return {
+        user: new ApiUser(constructorProps),
+        content: new ApiContent(constructorProps),
+        geoIp: new ApiGeoIp(constructorProps),
+        survey: new ApiSurvey(constructorProps),
+        payment: new ApiPayment(constructorProps),
+        stat: new ApiStat(constructorProps),
+        chat: new ApiChat(constructorProps),
+        bookmarks: new ApiBookmarks(constructorProps),
+        push: new ApiPush(constructorProps),
+        promocode: new ApiPromocode(constructorProps),
+    }
+}

package/src/api/payment.ts

@@ -0,0 +1,105 @@
+import { ApiAbstract } from "./abstract"
+import {
+	apiRoutePaymentAdd,
+	apiRoutePaymentBalance,
+	apiRoutePaymentList,
+	apiRoutePaymentVerificationUrl,
+	apiRoutePaymentVerificationStatus
+} from "../http/apiRoute"
+import { iPagingItems } from "../interfaces/iPagingItems"
+import { iPayment } from "../interfaces/iPayment"
+import { PayoutType } from "../interfaces/payoutType"
+import { ApiError } from "../http/apiError"
+import { iBalance } from "../interfaces/iBalance"
+
+export class ApiPayment extends ApiAbstract {
+    /**
+     * добавление запроса на выплату по системе быстрых платежей
+     * * @param {number} props.sum - сумма выплаты
+     * * @param {number} props.bank - id банка из справочника content.getBanks
+     */
+    async addSBP(props: { sum: number, bank: number }) {
+        if (!await this.userStorage.isAuth()) throw new ApiError(401, "Пользователь не авторизован")
+        const data = await this.fetcher<{ payment: iPayment }>({
+            route: apiRoutePaymentAdd,
+            postBody: { ...props, type: PayoutType.sbp },
+            options: { addToken: true }
+        })
+        return data.payment
+    }
+    /**
+    * добавление запроса на выплату по номеру карты
+    * * @param {number} props.sum - сумма выплаты
+    * * @param {number} props.card_number - номер карты
+    */
+    async addCard(props: { sum: number, card_number: number }) {
+        if (!await this.userStorage.isAuth()) throw new ApiError(401, "Пользователь не авторизован")
+        const data = await this.fetcher<{ payment: iPayment }>({
+            route: apiRoutePaymentAdd,
+            postBody: { ...props, type: PayoutType.card },
+            options: { addToken: true }
+        })
+        return data.payment
+    }
+    /**
+     * список начислений
+     * * @param {number} page - отсчет страниц с первой, чтобы не было путаницы
+     */
+    async getList<Keys extends keyof iPayment>({
+        page = 1,
+        select,
+    }: {
+        page: number
+        select: Keys[],
+    }) {
+        if (!await this.userStorage.isAuth()) throw new ApiError(401, "Пользователь не авторизован")
+        return await this.fetcher<iPagingItems<Pick<iPayment, Keys>>>({
+            route: apiRoutePaymentList({
+                page,
+                sorters: ["id desc"],
+                select
+            }),
+            options: { addToken: true }
+        })
+    }
+    /**
+     * баланс пользователя
+     */
+    async balance() {
+        if (!await this.userStorage.isAuth()) throw new ApiError(401, "Пользователь не авторизован")
+        return await this.fetcher<iBalance>({
+            route: apiRoutePaymentBalance,
+            options: { addToken: true }
+        })
+    }
+
+    /**
+     * Получить URL для верификации в SolarStaff
+     * Необходимо для получения выплат
+     */
+    async getVerificationUrl() {
+        if (!await this.userStorage.isAuth()) throw new ApiError(401, "Пользователь не авторизован")
+        return await this.fetcher<{
+            url: string,
+            verified: boolean
+        }>({
+            route: apiRoutePaymentVerificationUrl,
+            options: { addToken: true }
+        })
+    }
+
+    /**
+     * Проверить статус верификации пользователя в SolarStaff
+     */
+    async checkVerificationStatus() {
+        if (!await this.userStorage.isAuth()) throw new ApiError(401, "Пользователь не авторизован")
+        return await this.fetcher<{
+            verified: boolean,
+            status: "not_started" | "pending" | "active" | "blocked",
+            message: string
+        }>({
+            route: apiRoutePaymentVerificationStatus,
+            options: { addToken: true }
+        })
+    }
+}

package/src/api/promocode.ts

@@ -0,0 +1,18 @@
+import { ApiAbstract } from "./abstract";
+import { apiRoutePromocodeActivate } from "../http/apiRoute";
+import { ApiError } from "../http/apiError";
+
+export class ApiPromocode extends ApiAbstract {
+    /**
+     * активация промокода
+     */
+    async activate(code: string) {
+        if (!await this.userStorage.isAuth()) throw new ApiError(401, "Пользователь не авторизован")
+        const { sum } = await this.fetcher<{ sum: number }>({
+            route: apiRoutePromocodeActivate,
+            postBody: { code },
+            options: { addToken: true }
+        })
+        return { sum }
+    }
+}

package/src/api/push.ts

@@ -0,0 +1,102 @@
+import { ApiAbstract } from "./abstract";
+import { apiRoutePushCountNew, apiRoutePushIsSubscribed, apiRoutePushList, apiRoutePushRegister, apiRoutePushUnsubscribe, apiRoutePushView, apiRoutePushViewAll } from "../http/apiRoute";
+import { iPagingItems } from "../interfaces/iPagingItems";
+import { ApiError } from "../http/apiError";
+import { iPush } from "../interfaces/iPush";
+import { iFilter } from "../interfaces/iFilter";
+import { iAppStore } from "../interfaces/iAppStore";
+
+export class ApiPush extends ApiAbstract {
+    /**
+     * список пушей
+     * * @param {number} page - отсчет страниц с первой, чтобы не было путаницы
+     */
+    async getList<Keys extends keyof iPush>({
+        page = 1,
+        filters,
+        select,
+    }: {
+        page: number
+        filters?: iFilter<iPush>,
+        select: Keys[],
+    }) {
+        if (!await this.userStorage.isAuth()) throw new ApiError(401, "Пользователь не авторизован")
+        return await this.fetcher<iPagingItems<Pick<iPush, Keys>>>({
+            route: apiRoutePushList({
+                page,
+                filters,
+                sorters: ["id desc"],
+                select
+            }),
+            options: { addToken: true }
+        })
+    }
+    /**
+     * количество непрочитанных пушей
+     */
+    async countNew() {
+        if (!await this.userStorage.isAuth()) throw new ApiError(401, "Пользователь не авторизован")
+        return await this.fetcher<{ totalItems: number }>({
+            route: apiRoutePushCountNew,
+            options: { addToken: true }
+        })
+    }
+    /**
+     * Пометить пуш просмотренным
+     * * @param {number} props.pushId - id пуша
+     */
+    async view({ pushId }: { pushId: number }) {
+        if (!await this.userStorage.isAuth()) throw new ApiError(401, "Пользователь не авторизован")
+        await this.fetcher({
+            route: apiRoutePushView,
+            postBody: { id: pushId },
+            options: { addToken: true }
+        })
+    }
+    /**
+     * Пометить все пуши просмотренными
+     */
+    async viewAll() {
+        if (!await this.userStorage.isAuth()) throw new ApiError(401, "Пользователь не авторизован")
+        await this.fetcher({
+            route: apiRoutePushViewAll,
+            postBody: { view: true },
+            options: { addToken: true }
+        })
+    }
+
+    /**
+     * добавления токена для пуш уведомления
+     * * @param {number} props.token - сумма выплаты
+     * * @param {number} props.appStore - магазин приложений
+     */
+    async register(props: { token: string, appStore: iAppStore }) {
+        if (!await this.userStorage.isAuth()) throw new ApiError(401, "Пользователь не авторизован")
+        await this.fetcher({
+            route: apiRoutePushRegister,
+            postBody: props,
+            options: { addToken: true }
+        })
+    }
+    /**
+     * отписка от пуш уведомлений
+     */
+    async unsubscribe() {
+        if (!await this.userStorage.isAuth()) throw new ApiError(401, "Пользователь не авторизован")
+        await this.fetcher({
+            route: apiRoutePushUnsubscribe,
+            postBody: { unsubscribe: 1 },
+            options: { addToken: true }
+        })
+    }
+    /**
+     * статус подписки на пуш уведомления
+     */
+    async isSubscribed() {
+        if (!await this.userStorage.isAuth()) throw new ApiError(401, "Пользователь не авторизован")
+        return await this.fetcher<{ subscribed: boolean }>({
+            route: apiRoutePushIsSubscribed,
+            options: { addToken: true }
+        })
+    }
+}

package/src/api/stat.ts

@@ -0,0 +1,74 @@
+import { ApiAbstract } from "./abstract";
+import { apiRouteStatAdd, apiRouteStatGet, apiRouteViewAdd } from "../http/apiRoute";
+import { UserStatEvent } from "../interfaces/userStatEvent";
+import { iUserStat } from "../interfaces/iUserStat";
+import { ApiError } from "../http/apiError";
+import { ItemType } from "../interfaces/itemType";
+import { ViewEventType } from "../interfaces/viewEventType";
+import { apiStatEvents } from "../interfaces/apiStatEvents";
+
+export class ApiStat extends ApiAbstract {
+    /**
+     * добавление события открытия товара, бренда, статьи
+     * @param {number} props.itemId - id элемента
+     * @param {AddViewEvent} props.event - тип события
+     */
+    async add({
+        itemId,
+        event,
+    }: {
+        itemId: number,
+        event: typeof apiStatEvents[number],
+    }) {
+        if (typeof itemId != "number" || itemId <= 0) throw new ApiError(400, "ApiStat не корректный id элемента")
+        if (!apiStatEvents.includes(event)) throw new ApiError(400, "ApiStat Не правильный тип статистики")
+        const itemType = ItemType[event.split("/")[0] as keyof typeof ItemType]
+        const eventType = ViewEventType[event.split("/")[1] as keyof typeof ViewEventType]
+        if (!itemType) throw new ApiError(400, `ApiStat Не верный тип элемента ${event.split("/")[0]} - ${itemType}`)
+        if (!eventType) throw new ApiError(400, `ApiStat Не верный тип события ${event.split("/")[1]} - ${eventType}`)
+        //повышаем кэшбек - просмотр презентации
+        if (itemType == ItemType.CATALOG_SKU && eventType == ViewEventType.PRESENTATION_SUCCESS) {
+            await this.fetcher({
+                route: apiRouteStatAdd,
+                postBody: {
+                    sku: itemId,
+                    event: UserStatEvent.presentation
+                },
+                options: { addToken: true }
+            })
+        }
+        //повышаем кэшбек - квиз
+        if (itemType == ItemType.CATALOG_SKU && eventType == ViewEventType.QUESTIONS_SUCCESS) {
+            await this.fetcher({
+                route: apiRouteStatAdd,
+                postBody: {
+                    sku: itemId,
+                    event: UserStatEvent.quiz
+                },
+                options: { addToken: true }
+            })
+        }
+        await this.fetcher({
+            route: apiRouteViewAdd,
+            postBody: {
+                itemType,
+                itemId,
+                eventType
+            },
+            options: { addToken: true }
+        })
+    }
+    /**
+     * получения события просмотра презентации или прохождения квиза
+     * @param {number} props.sku - массив id акции (не товара) до 50 элементов.
+     */
+    async getEvent(props: { sku: number[] }) {
+        if (!await this.userStorage.isAuth()) throw new ApiError(401, "Пользователь не авторизован")
+        const data = await this.fetcher<{ items: iUserStat[] }>({
+            route: apiRouteStatGet,
+            postBody: props,
+            options: { addToken: true }
+        })
+        return data.items
+    }
+}