itube-specs 0.0.779 → 0.0.781

package/services/api/videos.service.ts

@@ -0,0 +1,558 @@
+import type { Language } from '../../runtime';
+import { ApiHelper, toHeaderLanguage } from '../../runtime';
+import type { RequestPagination, PaginatedResponse, IRequestVideoFilter, IReportForm, IVideoData, IVideoCard, IPopularTags  } from '../../types';
+
+function getSafeReferrer(): string {
+  if (!document.referrer) return '';
+  try {
+    const url = new URL(document.referrer);
+    return url.origin + url.pathname;
+  } catch {
+    return '';
+  }
+}
+
+/** Сервис для работы с API видеороликов */
+/** Сервис для работы с API видеороликов */
+export class VideosApiService {
+  static async getSearchByNiche(
+    pagination: RequestPagination,
+    lang: Language,
+    phrase: string,
+    niche = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<PaginatedResponse<IVideoCard>> {
+    return await ApiHelper.fetch(
+      '/videos/video-search-by-niche',
+      {
+        method: 'POST',
+        headers: {
+          'X-Niche': niche,
+          'X-Language': toHeaderLanguage(lang),
+          'X-Cache-Time': '259200',
+          'Content-Type': 'application/json',
+        },
+        params: {
+          ...pagination,
+        },
+        body: {
+          query: phrase,
+        }
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static getSearchByNicheFiltered(phrase: string) {
+    return async (
+      lang: Language,
+      pagination: RequestPagination,
+      videosFilter: IRequestVideoFilter,
+      order: string,
+      niche = NicheHelper.getSiteDefaultNiche(),
+    ): Promise<PaginatedResponse<IVideoCard>> => {
+      return await ApiHelper.fetch(
+        '/videos/video-search-by-niche',
+        {
+          method: 'POST',
+          headers: {
+            'X-Niche': niche,
+            'X-Language': toHeaderLanguage(lang),
+            'X-Cache-Time': '259200',
+            'Content-Type': 'application/json',
+          },
+          params: {
+            ...pagination,
+            order,
+          },
+          body: {
+            query: phrase,
+            filter_request: videosFilter,
+          }
+        },
+      useRuntimeConfig(),
+      );
+    };
+  }
+  static async sendVideoAbuse(
+    data: IReportForm,
+    videoGuid: string,
+    niche = NicheHelper.getSiteDefaultNiche(),
+  ) {
+    return await ApiHelper.fetch(
+      `/videos/send-video-abuse/${videoGuid}`,
+      {
+        method: 'POST',
+        headers: {
+          'X-Niche': niche,
+          'X-Cache-Time': '259200',
+          'Content-Type': 'application/json',
+        },
+        body: data
+      },
+    useRuntimeConfig(),
+    );
+  }
+  static async refererPhrasesById(
+    lang: Language,
+    id: string,
+    niche = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<string[]> {
+    return await ApiHelper.fetch(
+      `/videos/referer-phrases-by-id/${id}`,
+      {
+        method: 'GET',
+        headers: {
+          'X-Niche': niche,
+          'X-Language': toHeaderLanguage(lang),
+          'X-Cache-Time': '259200',
+          'Content-Type': 'application/json',
+        },
+      },
+    useRuntimeConfig(),
+    );
+  }
+  static async refererPhrasesByUrl(
+    lang: Language,
+    id: string,
+    niche = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<string[]> {
+    return await ApiHelper.fetch(
+      `/videos/referer-phrases-by-url/${id}`,
+      {
+        method: 'GET',
+        headers: {
+          'X-Niche': niche,
+          'X-Language': toHeaderLanguage(lang),
+          'X-Cache-Time': '259200',
+          'Content-Type': 'application/json',
+        },
+      },
+    useRuntimeConfig(),
+    );
+  }
+  static async getRelatedVideosById(
+    pagination: RequestPagination,
+    lang: Language,
+    id: string,
+    niche = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<PaginatedResponse<IVideoCard>> {
+    return await ApiHelper.fetch(
+      `/videos/get-related-videos-by-id/${id}`,
+      {
+        method: 'GET',
+        headers: {
+          'X-Niche': niche,
+          'X-Language': toHeaderLanguage(lang),
+          'X-Cache-Time': '259200',
+          'Content-Type': 'application/json',
+        },
+        params: {
+          ...pagination,
+        },
+      },
+    useRuntimeConfig(),
+    );
+  }
+  static async getRelatedVideosByUrl(
+    pagination: RequestPagination,
+    lang: Language,
+    url: string,
+    niche = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<PaginatedResponse<IVideoCard>> {
+    return await ApiHelper.fetch(
+      `/videos/get-related-videos-by-url/${url}`,
+      {
+        method: 'GET',
+        headers: {
+          'X-Niche': niche,
+          'X-Language': toHeaderLanguage(lang),
+          'X-Cache-Time': '259200',
+          'Content-Type': 'application/json',
+        },
+        params: {
+          ...pagination,
+        },
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async getVideoById(
+    lang: Language,
+    id: string,
+    niche = NicheHelper.getSiteDefaultNiche(),
+    headers = {} as HeadersInit,
+  ): Promise<IVideoData> {
+    return await ApiHelper.fetch(
+      `/videos/get-video-by-id/${id}`,
+      {
+        method: 'GET',
+        headers: {
+          ...headers,
+          'X-Niche': niche,
+          'X-Language': toHeaderLanguage(lang),
+          'X-Cache-Time': '259200',
+          'Content-Type': 'application/json',
+        },
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async getVideoByUrl(
+    lang: Language,
+    url: string,
+    niche = NicheHelper.getSiteDefaultNiche(),
+    headers = {} as HeadersInit,
+  ): Promise<IVideoData> {
+    return await ApiHelper.fetch(
+      `/videos/get-video-by-url/${url}`,
+      {
+        method: 'GET',
+        headers: {
+          ...headers,
+          'X-Niche': niche,
+          'X-Language': toHeaderLanguage(lang),
+          'X-Cache-Time': '259200',
+          'Content-Type': 'application/json',
+        },
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async videoLike(
+    md: string,
+    niche = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<IVideoData> {
+    return await ApiHelper.fetch(
+      `/videos/video-like/${md}`,
+      {
+        method: 'POST',
+        headers: {
+          'X-Niche': niche,
+          'X-Cache-Time': '259200',
+          'Content-Type': 'application/json',
+        },
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async videoDislike(
+    md: string,
+    niche = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<IVideoData> {
+    return await ApiHelper.fetch(
+      `/videos/video-dislike/${md}`,
+      {
+        method: 'POST',
+        headers: {
+          'X-Niche': niche,
+          'X-Cache-Time': '259200',
+          'Content-Type': 'application/json',
+        },
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async videoView(
+    md: string,
+    niche = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<IVideoData> {
+    return await ApiHelper.fetch(
+      `/videos/video-view/${md}`,
+      {
+        method: 'POST',
+        headers: {
+          'X-Niche': niche,
+          'X-Cache-Time': '259200',
+          'Content-Type': 'application/json',
+        },
+        body: {
+          referer: getSafeReferrer(),
+        }
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async getListByNiche(
+    lang: Language,
+    pagination: RequestPagination,
+    videosFilter: IRequestVideoFilter,
+    order: string,
+    niche = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<PaginatedResponse<IVideoCard>> {
+    return await ApiHelper.fetch(
+      '/videos/list-by-niche',
+      {
+        method: 'POST',
+        headers: {
+          'X-Niche': niche,
+          'X-Language': toHeaderLanguage(lang),
+          'X-Cache-Time': '259200',
+          'Content-Type': 'application/json',
+          'X-Country-Code': useState<string>('clientCountryCode').value || '',
+        },
+        params: {
+          ...pagination,
+          order,
+        },
+        body: {
+          filter_request: videosFilter,
+          max_limit: 0,
+        }
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async getListByNicheAndCategory(
+    lang: Language,
+    pagination: RequestPagination,
+    videosFilter: IRequestVideoFilter,
+    category: string,
+    order: string,
+    niche = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<PaginatedResponse<IVideoCard>> {
+    return await ApiHelper.fetch(
+      '/videos/list-by-niche-and-category',
+      {
+        method: 'POST',
+        headers: {
+          'X-Niche': niche,
+          'X-Language': toHeaderLanguage(lang),
+          'X-Cache-Time': '259200',
+          'Content-Type': 'application/json',
+        },
+        params: {
+          ...pagination,
+          order,
+        },
+        body: {
+          filter_request: videosFilter,
+          category: category,
+          max_limit: 100,
+        }
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async getListByNicheAndModel(
+    pagination: RequestPagination,
+    videosFilter: IRequestVideoFilter,
+    model: string,
+    lang: Language,
+    order: string,
+    niche = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<PaginatedResponse<IVideoCard>> {
+    return await ApiHelper.fetch(
+      '/videos/list-by-niche-and-model',
+      {
+        method: 'POST',
+        headers: {
+          'X-Niche': niche,
+          'X-Language': toHeaderLanguage(lang),
+          'X-Cache-Time': '259200',
+          'Content-Type': 'application/json',
+        },
+        params: {
+          ...pagination,
+          order,
+        },
+        body: {
+          filter_request: videosFilter,
+          model: model,
+          max_limit: 100,
+        }
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async getListByNicheAndModelAndTag(
+    pagination: RequestPagination,
+    videosFilter: IRequestVideoFilter,
+    model: string,
+    tag: string,
+    lang: Language,
+    order: string,
+    niche = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<PaginatedResponse<IVideoCard>> {
+    return await ApiHelper.fetch(
+      '/videos/list-by-niche-and-model-and-tag',
+      {
+        method: 'POST',
+        headers: {
+          'X-Niche': niche,
+          'X-Language': toHeaderLanguage(lang),
+          'X-Cache-Time': '259200',
+          'Content-Type': 'application/json',
+        },
+        params: {
+          ...pagination,
+          order,
+        },
+        body: {
+          filter_request: videosFilter,
+          model: model,
+          tag: tag,
+          max_limit: 100,
+        }
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async getListByNicheAndModelAndChannel(
+    pagination: RequestPagination,
+    videosFilter: IRequestVideoFilter,
+    model: string,
+    channel: string,
+    lang: Language,
+    order: string,
+    niche = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<PaginatedResponse<IVideoCard>> {
+    return await ApiHelper.fetch(
+      '/videos/list-by-niche-and-model-and-channel',
+      {
+        method: 'POST',
+        headers: {
+          'X-Niche': niche,
+          'X-Language': toHeaderLanguage(lang),
+          'X-Cache-Time': '259200',
+          'Content-Type': 'application/json',
+        },
+        params: {
+          ...pagination,
+          order,
+        },
+        body: {
+          filter_request: videosFilter,
+          model: model,
+          channel: channel,
+          max_limit: 100,
+        }
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async getListByNicheAndTag(
+    pagination: RequestPagination,
+    videosFilter: IRequestVideoFilter,
+    tag: string,
+    lang: Language,
+    order: string,
+    niche = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<PaginatedResponse<IVideoCard>> {
+    return await ApiHelper.fetch(
+      '/videos/list-by-niche-and-tag',
+      {
+        method: 'POST',
+        headers: {
+          'X-Niche': niche,
+          'X-Language': toHeaderLanguage(lang),
+          'X-Cache-Time': '259200',
+          'Content-Type': 'application/json',
+        },
+        params: {
+          ...pagination,
+          order,
+        },
+        body: {
+          filter_request: {
+              ...videosFilter,
+          },
+          tag,
+        }
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async getListByNicheAndChannel(
+    pagination: RequestPagination,
+    videosFilter: IRequestVideoFilter,
+    channel: string,
+    lang: Language,
+    order: string,
+    niche = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<PaginatedResponse<IVideoCard>> {
+    return await ApiHelper.fetch(
+      '/videos/list-by-niche-and-channel',
+      {
+        method: 'POST',
+        headers: {
+          'X-Niche': niche,
+          'X-Language': toHeaderLanguage(lang),
+          'X-Cache-Time': '259200',
+          'Content-Type': 'application/json',
+        },
+        params: {
+          ...pagination,
+          order,
+        },
+        body: {
+          filter_request: videosFilter,
+          channel,
+          max_limit: 100,
+        }
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async popularTagsByModelName(
+    lang: Language,
+    model: string,
+    limit = 25,
+    niche = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<IPopularTags[]> {
+    return await ApiHelper.fetch(
+      '/videos/popular-tags-by-model-name',
+      {
+        method: 'GET',
+        headers: {
+          'X-Niche': niche,
+          'X-Language': toHeaderLanguage(lang),
+          'X-Cache-Time': '259200',
+          'Content-Type': 'application/json',
+        },
+        params: {
+          limit,
+          model,
+        },
+      },
+    useRuntimeConfig(),
+    );
+  }
+
+  static async popularTagsByChannelName(
+    lang: Language,
+    channel: string,
+    limit = 25,
+    niche = NicheHelper.getSiteDefaultNiche(),
+  ): Promise<IPopularTags[]> {
+    return await ApiHelper.fetch(
+      '/videos/popular-tags-by-channel-name',
+      {
+        method: 'GET',
+        headers: {
+          'X-Niche': niche,
+          'X-Language': toHeaderLanguage(lang),
+          'X-Cache-Time': '259200',
+          'Content-Type': 'application/json',
+        },
+        params: {
+          limit,
+          channel,
+        },
+      },
+    useRuntimeConfig(),
+    );
+  }
+}

package/services/site-data.service.ts

@@ -0,0 +1,72 @@
+import type {
+  ISiteData,
+  ISiteLanguageItem,
+  ISiteLanguagesResponse,
+  ISiteNicheItem,
+  ISiteNichesResponse,
+  ISiteResponse
+} from '../types';
+
+/** Класс для работы с данными сайта */
+export class SiteDataService {
+  private static readonly _serviceName = 'SiteDataService';
+  private static siteData: ISiteData = {} as ISiteData;
+  private static updated: string;
+
+  public static getServiceName() {
+    return this._serviceName;
+  }
+
+  /** Метод для получения списка антиадблок доменов из админки */
+  public static getAntiAdblokDomains(): Array<string> {
+    return SiteDataService.siteData?.siteData?.antiAdblockDomains || [];
+  }
+
+  /** Метод для флага из админки */
+  public static isSiteEnabled(): boolean {
+    return this.siteData.siteData.enabled;
+  }
+
+  /** Метод для флага из админки */
+  public static getSiteLanguages(): Array<ISiteLanguageItem> {
+    return this.siteData.languages || [];
+  }
+
+  /** Метод для флага из админки */
+  public static getSiteNiches(): Array<ISiteNicheItem> {
+    return this.siteData.niches || [];
+  }
+
+  /** Метод для получения данных в сервис */
+  public static async fetchSiteData() {
+    const apiUrl = process.env.NUXT_PUBLIC_API_DOMAIN;
+    const xDomain = process.env.NUXT_PUBLIC_X_DOMAIN || '';
+
+    try {
+      const fetchOptions = {
+        method: 'GET' as const,
+        headers: { 'X-Domain': xDomain },
+        responseType: 'json' as const,
+      };
+
+      const [siteData, languagesResponse, nichesResponse] = await Promise.all([
+        $fetch<{ data: ISiteResponse }>(`${apiUrl}/v1/site`, fetchOptions).then(r => r.data),
+        $fetch<{ data: ISiteLanguagesResponse }>(`${apiUrl}/v1/site/languages`, fetchOptions).then(r => r.data),
+        $fetch<{ data: ISiteNichesResponse }>(`${apiUrl}/v1/site/niches`, fetchOptions).then(r => r.data),
+      ]);
+
+      SiteDataService.siteData = {
+        siteData: siteData,
+        languages: languagesResponse?.items || [],
+        niches: nichesResponse?.items || [],
+      };
+    } catch (e) {
+      console.error('Failed to fetch site data: ', e);
+    }
+  }
+
+  /** Метод для получения данных о времени последнего обновления */
+  public static getLastUpdate() {
+    return this.updated;
+  }
+}

package/utils/__tests__/get-sorted-filter-groups.test.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest';
+import { getSortedFilterGroups } from '../get-sorted-filter-groups';
+
+describe('getSortedFilterGroups', () => {
+  it('возвращает уникальные группы, отсортированные по order', () => {
+    const filters = [
+      { group: { title: 'B', order: 2 } },
+      { group: { title: 'A', order: 1 } },
+      { group: { title: 'B', order: 2 } },
+    ];
+    const result = getSortedFilterGroups(filters);
+    expect(result.map(g => g.title)).toEqual(['A', 'B']);
+  });
+
+  it('дедуплицирует по title (первое вхождение группы)', () => {
+    const filters = [
+      { group: { title: 'A', order: 1, name: 'a1' } },
+      { group: { title: 'A', order: 1, name: 'a2' } },
+    ];
+    const result = getSortedFilterGroups(filters);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe('a1');
+  });
+
+  it('пустой список → []', () => {
+    expect(getSortedFilterGroups([])).toEqual([]);
+  });
+});

package/utils/__tests__/parse-filter-categories.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest';
+import { parseFilterCategories } from '../parse-filter-categories';
+
+describe('parseFilterCategories', () => {
+  it('пустой query → []', () => {
+    expect(parseFilterCategories({})).toEqual([]);
+  });
+
+  it('строка разбивается по запятой', () => {
+    expect(parseFilterCategories({ categories: 'age_18,body_slim' })).toEqual(['age_18', 'body_slim']);
+  });
+
+  it('отбрасывает пустые сегменты', () => {
+    expect(parseFilterCategories({ categories: 'age_18,,body_slim,' })).toEqual(['age_18', 'body_slim']);
+  });
+
+  it('массив строк разворачивается', () => {
+    expect(parseFilterCategories({ categories: ['age_18', 'body_slim,hair_dark'] }))
+        .toEqual(['age_18', 'body_slim', 'hair_dark']);
+  });
+});

package/utils/__tests__/sort-filter-radio-options.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { sortFilterRadioOptions } from '../sort-filter-radio-options';
+
+describe('sortFilterRadioOptions', () => {
+  it('ставит all, затем yes в начало', () => {
+    const result = sortFilterRadioOptions([{ name: 'yes' }, { name: 'no' }, { name: 'all' }]);
+    expect(result.map(o => o.name)).toEqual(['all', 'yes', 'no']);
+  });
+
+  it('отбрасывает unspecified', () => {
+    const result = sortFilterRadioOptions([{ name: 'all' }, { name: 'unspecified' }, { name: 'yes' }]);
+    expect(result.map(o => o.name)).toEqual(['all', 'yes']);
+  });
+
+  it('сохраняет порядок прочих опций между собой', () => {
+    const result = sortFilterRadioOptions([{ name: 'b' }, { name: 'a' }, { name: 'all' }]);
+    expect(result.map(o => o.name)).toEqual(['all', 'b', 'a']);
+  });
+
+  it('пустой массив → []', () => {
+    expect(sortFilterRadioOptions([])).toEqual([]);
+  });
+});