@bprotsyk/aso-core 2.1.59 → 2.1.61

package/lib/app/app.d.ts

@@ -1,7 +1,5 @@
-import { AlternativeLayoutType, AlternativeLogicType, AlternativeNavigation, AlternativeNetworkTool, AlternativeOnActivityResult, AlternativeOnBackPressed, AlternativeSourceType, AlternativeStorageType } from "index";
 import { AppType } from "./app-type";
 import mongoose, { Document } from "mongoose";
-import { AlternativeFullscreen } from "app/app-integration";
 export interface IApp extends Document {
     id: number;
     enabled: boolean;
@@ -11,14 +9,12 @@ export interface IApp extends Document {
     pushesEnabled?: boolean;
     policyUrl?: string;
     type: AppType;
-    geos: string;
     geo: string[];
     onesignalAppId: string;
     onesignalRestApiKey: string;
     appmetricaApiKey?: string;
     appmetricaAppId?: number;
     webInterfaceName: string;
-    generationOptions: IAppGenerationOptions;
     keitaroData: IAppKeitaroData | null;
     integrationVersion: IntegrationVersion;
     offersStubParams?: IOffersStubParams;
@@ -53,12 +49,15 @@ export declare const getPlatformName: (platform: EPlatform | undefined) => strin
 export interface IPlatformParams {
     enabled: boolean;
     geo: string[];
-    customCampaignData?: IAppKeitaroData;
     trackingUrl?: string;
     adjustParams?: {
         appId: string;
         eventIds: IAdjustEventIds;
     };
+    direct: {
+        enabled: boolean;
+        keitaroData: IAppKeitaroData | boolean;
+    };
     metricaParams?: {
         appId: number;
         postApiKey: string;
@@ -129,33 +128,11 @@ export declare enum IntegrationVersion {
     NONE = "MVVM",
     POLICY = "POLICY",
     OFFER_STUB = "OFFER_STUB",
-    DIRECT = "DIRECT",
     WEB = "WEB",
     WEB_DIRECT = "WEB_DIRECT",
     BANNER = "BANNER",
     PWA = "PWA"
 }
-export interface IntegrationAlterations {
-    networkTool: AlternativeNetworkTool;
-    logicType: AlternativeLogicType;
-    navigation: AlternativeNavigation;
-    storageType: AlternativeStorageType;
-    sourceType: AlternativeSourceType;
-    onBackPressed: AlternativeOnBackPressed;
-    onActivityResult: AlternativeOnActivityResult;
-    layoutType: AlternativeLayoutType;
-    fullscreen: AlternativeFullscreen;
-}
-export interface IAppGenerationOptions {
-    splashName: string;
-    webViewName: string;
-    linkName: string;
-}
-export interface IDeveloperParams {
-    name: string;
-    email: string;
-    organization: string;
-}
 export interface IAppKeitaroData {
     trackingCampaignId: number;
     trackingCampaignName: string;
@@ -178,7 +155,6 @@ export declare const AppSchema: mongoose.Schema<any, mongoose.Model<any, any, an
     bundle: string;
     trackingUrl: string;
     integrationVersion: string;
-    geos: string;
     name?: string | null | undefined;
     pushesEnabled?: boolean | null | undefined;
     removeDataParams?: any;
@@ -217,7 +193,6 @@ export declare const AppSchema: mongoose.Schema<any, mongoose.Model<any, any, an
     bundle: string;
     trackingUrl: string;
     integrationVersion: string;
-    geos: string;
     name?: string | null | undefined;
     pushesEnabled?: boolean | null | undefined;
     removeDataParams?: any;
@@ -256,7 +231,6 @@ export declare const AppSchema: mongoose.Schema<any, mongoose.Model<any, any, an
     bundle: string;
     trackingUrl: string;
     integrationVersion: string;
-    geos: string;
     name?: string | null | undefined;
     pushesEnabled?: boolean | null | undefined;
     removeDataParams?: any;

package/lib/app/app.js

@@ -49,7 +49,6 @@ var IntegrationVersion;
     IntegrationVersion["NONE"] = "MVVM";
     IntegrationVersion["POLICY"] = "POLICY";
     IntegrationVersion["OFFER_STUB"] = "OFFER_STUB";
-    IntegrationVersion["DIRECT"] = "DIRECT";
     IntegrationVersion["WEB"] = "WEB";
     IntegrationVersion["WEB_DIRECT"] = "WEB_DIRECT";
     IntegrationVersion["BANNER"] = "BANNER";
@@ -103,10 +102,6 @@ exports.AppSchema = new mongoose_1.Schema({
         enum: app_type_1.AppType,
         default: app_type_1.AppType.GAMBLING
     },
-    geos: {
-        type: String,
-        required: true
-    },
     geo: {
         type: [String]
     },

package/lib/index.d.ts

@@ -2,7 +2,7 @@ export { IPush } from "./general/push";
 export { IOffer, IPartner, IOfferType } from "./offers/offer";
 export { IOffersSection, OffersSectionSchema, DefaultSectionId } from "./offers/section";
 export { IAppOffersSection, ISectionsList, SectionsListSchema, IOfferState } from "./offers/list";
-export { IntegrationAlterations, IAdjustEventIds, IntegrationVersion, IApp, AppSchema, PlugType, IAppKeitaroData, IExternalParams, IPlatformParams, EPlatform } from "./app/app";
+export { IAdjustEventIds, IntegrationVersion, IApp, AppSchema, PlugType, IAppKeitaroData, IExternalParams, IPlatformParams, EPlatform } from "./app/app";
 export { IAppListItem } from "./app/app-list-item";
 export { AppType } from "./app/app-type";
 export { AlternativeLayoutType, AlternativeSourceType, AlternativeLogicType, AlternativeNetworkTool, AlternativeStorageType, AlternativeNavigation, AlternativeOnBackPressed, AlternativeOnActivityResult, IAppIntegration as IFlashIntegration } from "./app/app-integration";

package/lib/keitaro/keitaro-streams.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Додає всі унікальні потоки з усіх кампаній до кампанії з ID 888
+ */
+export declare function addAllStreamsToTestCampaign(): Promise<void>;
+/**
+ * Додає всі унікальні потоки з усіх кампаній до вказаної кампанії
+ */
+export declare function addAllStreamsToCampaign(targetCampaignId: number): Promise<void>;
+/**
+ * Синхронізує потоки між усіма кампаніями з символом ◈ в назві
+ */
+export declare function synchronizeStreamsAcrossAllCampaigns(): Promise<void>;
+/**
+ * Додає всі потоки з усіх кампаній до кампанії з назвою "888" з символом [◈]
+ */
+export declare function addAllStreamsToMarkedCampaign(): Promise<void>;
+/**
+ * Вирівнює потоки між усіма кампаніями.
+ * Збирає всі унікальні потоки з усіх кампаній та додає відсутні потоки в кожну кампанію.
+ */
+export declare function equalizeStreamsBetweenAllCampaigns(): Promise<void>;
+export declare const KeitaroStreamsService: {
+    addAllStreamsToTestCampaign: typeof addAllStreamsToTestCampaign;
+    addAllStreamsToCampaign: typeof addAllStreamsToCampaign;
+    synchronizeStreamsAcrossAllCampaigns: typeof synchronizeStreamsAcrossAllCampaigns;
+    addAllStreamsToMarkedCampaign: typeof addAllStreamsToMarkedCampaign;
+    equalizeStreamsBetweenAllCampaigns: typeof equalizeStreamsBetweenAllCampaigns;
+};

package/lib/keitaro/keitaro-streams.js

@@ -0,0 +1,510 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeitaroStreamsService = exports.equalizeStreamsBetweenAllCampaigns = exports.addAllStreamsToMarkedCampaign = exports.synchronizeStreamsAcrossAllCampaigns = exports.addAllStreamsToCampaign = exports.addAllStreamsToTestCampaign = void 0;
+const http_1 = __importDefault(require("../network/keitaro/http"));
+/**
+ * Отримує всі кампанії з Keitaro
+ */
+async function getAllCampaigns() {
+    const { data: campaigns } = await http_1.default.get('campaigns');
+    return campaigns;
+}
+/**
+ * Отримує всі потоки для конкретної кампанії
+ */
+async function getStreamsByCampaignId(campaignId) {
+    const { data: streams } = await http_1.default.get(`campaigns/${campaignId}/streams`);
+    return streams;
+}
+/**
+ * Додає всі унікальні потоки з усіх кампаній до кампанії з ID 888
+ */
+async function addAllStreamsToTestCampaign() {
+    const TARGET_CAMPAIGN_ID = 888; // ID цільової кампанії для тесту
+    // Перевіряємо, чи існує цільова кампанія
+    try {
+        await http_1.default.get(`campaigns/${TARGET_CAMPAIGN_ID}`);
+    }
+    catch (error) {
+        console.error(`Кампанія з ID ${TARGET_CAMPAIGN_ID} не знайдена`);
+        return;
+    }
+    console.log(`Починаємо збір усіх унікальних потоків...`);
+    // Отримуємо всі кампанії
+    const allCampaigns = await getAllCampaigns();
+    console.log(`Знайдено ${allCampaigns.length} кампаній`);
+    // Створюємо мапу для зберігання всіх унікальних потоків
+    const allUniqueStreams = new Map();
+    // Збираємо всі унікальні потоки з усіх кампаній
+    for (const campaign of allCampaigns) {
+        if (campaign.id === TARGET_CAMPAIGN_ID)
+            continue; // Пропускаємо цільову кампанію
+        console.log(`Обробка кампанії ${campaign.id} (${campaign.name})...`);
+        const streams = await getStreamsByCampaignId(campaign.id);
+        for (const stream of streams) {
+            // Визначаємо унікальний ключ для потоку
+            // Використовуємо filter payload, якщо він є, інакше використовуємо назву потоку
+            const streamKey = stream.filters && stream.filters.length > 0 &&
+                stream.filters[0].payload && stream.filters[0].payload.length > 0
+                ? `filter:${stream.filters[0].name}:${stream.filters[0].payload[0]}`
+                : `name:${stream.name}`;
+            if (!allUniqueStreams.has(streamKey)) {
+                allUniqueStreams.set(streamKey, stream);
+                console.log(`Додано унікальний потік: ${stream.name} (ключ: ${streamKey})`);
+            }
+        }
+    }
+    console.log(`Знайдено ${allUniqueStreams.size} унікальних потоків`);
+    // Отримуємо існуючі потоки цільової кампанії
+    const existingStreams = await getStreamsByCampaignId(TARGET_CAMPAIGN_ID);
+    // Створюємо множину існуючих ключів потоків
+    const existingStreamKeys = new Set();
+    for (const stream of existingStreams) {
+        const streamKey = stream.filters && stream.filters.length > 0 &&
+            stream.filters[0].payload && stream.filters[0].payload.length > 0
+            ? `filter:${stream.filters[0].name}:${stream.filters[0].payload[0]}`
+            : `name:${stream.name}`;
+        existingStreamKeys.add(streamKey);
+    }
+    console.log(`Кампанія ${TARGET_CAMPAIGN_ID} вже має ${existingStreamKeys.size} потоків`);
+    // Додаємо відсутні потоки до цільової кампанії
+    let addedStreamsCount = 0;
+    let errorCount = 0;
+    for (const [streamKey, sourceStream] of allUniqueStreams.entries()) {
+        if (!existingStreamKeys.has(streamKey)) {
+            try {
+                await http_1.default.post('streams', {
+                    name: sourceStream.name,
+                    campaign_id: TARGET_CAMPAIGN_ID,
+                    schema: sourceStream.schema,
+                    type: sourceStream.type,
+                    action_type: sourceStream.action_type,
+                    weight: sourceStream.weight,
+                    offers: sourceStream.offers.map((offer) => ({
+                        offer_id: offer.offer_id,
+                        share: offer.share,
+                        state: offer.state
+                    })),
+                    filters: sourceStream.filters.map((filter) => ({
+                        name: filter.name,
+                        mode: filter.mode,
+                        payload: filter.payload
+                    })),
+                    position: sourceStream.position,
+                    state: sourceStream.state
+                });
+                addedStreamsCount++;
+                console.log(`Додано потік ${addedStreamsCount}: ${sourceStream.name}`);
+            }
+            catch (error) {
+                errorCount++;
+                console.error(`Помилка при додаванні потоку "${sourceStream.name}":`, error);
+            }
+        }
+    }
+    console.log(`Результат: додано ${addedStreamsCount} потоків, помилок: ${errorCount}`);
+    console.log(`Всього потоків у кампанії ${TARGET_CAMPAIGN_ID} тепер: ${existingStreamKeys.size + addedStreamsCount}`);
+}
+exports.addAllStreamsToTestCampaign = addAllStreamsToTestCampaign;
+/**
+ * Додає всі унікальні потоки з усіх кампаній до вказаної кампанії
+ */
+async function addAllStreamsToCampaign(targetCampaignId) {
+    // Перевіряємо, чи існує цільова кампанія
+    try {
+        await http_1.default.get(`campaigns/${targetCampaignId}`);
+    }
+    catch (error) {
+        console.error(`Кампанія з ID ${targetCampaignId} не знайдена`);
+        return;
+    }
+    console.log(`Починаємо збір усіх унікальних потоків...`);
+    // Отримуємо всі кампанії
+    const allCampaigns = await getAllCampaigns();
+    console.log(`Знайдено ${allCampaigns.length} кампаній`);
+    // Створюємо мапу для зберігання всіх унікальних потоків
+    const allUniqueStreams = new Map();
+    // Збираємо всі унікальні потоки з усіх кампаній
+    for (const campaign of allCampaigns) {
+        if (campaign.id === targetCampaignId)
+            continue; // Пропускаємо цільову кампанію
+        console.log(`Обробка кампанії ${campaign.id} (${campaign.name})...`);
+        const streams = await getStreamsByCampaignId(campaign.id);
+        for (const stream of streams) {
+            // Пропускаємо потоки, які мають фільтр за країною, крім "Bot Protection"
+            if (stream.name !== "Bot Protection" &&
+                stream.filters && stream.filters.length > 0 &&
+                stream.filters.some(filter => filter.name === 'country')) {
+                console.log(`Пропущено потік: ${stream.name} (фільтр за країною)`);
+                continue;
+            }
+            // Визначаємо унікальний ключ для потоку
+            const streamKey = stream.filters && stream.filters.length > 0 &&
+                stream.filters[0].payload && stream.filters[0].payload.length > 0
+                ? `filter:${stream.filters[0].name}:${stream.filters[0].payload[0]}`
+                : `name:${stream.name}`;
+            if (!allUniqueStreams.has(streamKey)) {
+                allUniqueStreams.set(streamKey, stream);
+                console.log(`Знайдено унікальний потік: ${stream.name} (ключ: ${streamKey})`);
+            }
+        }
+    }
+    console.log(`Знайдено ${allUniqueStreams.size} унікальних потоків`);
+    // Отримуємо існуючі потоки цільової кампанії
+    const existingStreams = await getStreamsByCampaignId(targetCampaignId);
+    // Створюємо множину існуючих ключів потоків
+    const existingStreamKeys = new Set();
+    for (const stream of existingStreams) {
+        const streamKey = stream.filters && stream.filters.length > 0 &&
+            stream.filters[0].payload && stream.filters[0].payload.length > 0
+            ? `filter:${stream.filters[0].name}:${stream.filters[0].payload[0]}`
+            : `name:${stream.name}`;
+        existingStreamKeys.add(streamKey);
+    }
+    console.log(`Кампанія ${targetCampaignId} вже має ${existingStreamKeys.size} потоків`);
+    // Додаємо відсутні потоки до цільової кампанії
+    let addedStreamsCount = 0;
+    let errorCount = 0;
+    for (const [streamKey, sourceStream] of allUniqueStreams.entries()) {
+        if (!existingStreamKeys.has(streamKey)) {
+            try {
+                await http_1.default.post('streams', {
+                    name: sourceStream.name,
+                    campaign_id: targetCampaignId,
+                    schema: sourceStream.schema,
+                    type: sourceStream.type,
+                    action_type: sourceStream.action_type,
+                    weight: sourceStream.weight,
+                    offers: sourceStream.offers.map((offer) => ({
+                        offer_id: offer.offer_id,
+                        share: offer.share,
+                        state: offer.state
+                    })),
+                    filters: sourceStream.filters.map((filter) => ({
+                        name: filter.name,
+                        mode: filter.mode,
+                        payload: filter.payload
+                    })),
+                    position: sourceStream.position,
+                    state: sourceStream.state
+                });
+                addedStreamsCount++;
+                console.log(`Додано потік ${addedStreamsCount}: ${sourceStream.name}`);
+            }
+            catch (error) {
+                errorCount++;
+                console.error(`Помилка при додаванні потоку "${sourceStream.name}":`, error);
+            }
+        }
+    }
+    console.log(`Результат: додано ${addedStreamsCount} потоків, помилок: ${errorCount}`);
+    console.log(`Всього потоків у кампанії ${targetCampaignId} тепер: ${existingStreamKeys.size + addedStreamsCount}`);
+}
+exports.addAllStreamsToCampaign = addAllStreamsToCampaign;
+/**
+ * Синхронізує потоки між усіма кампаніями з символом ◈ в назві
+ */
+async function synchronizeStreamsAcrossAllCampaigns() {
+    // Отримуємо всі кампанії з символом ◈
+    const allCampaigns = await getAllCampaigns();
+    const targetCampaigns = allCampaigns.filter(campaign => /◈/.test(campaign.name));
+    console.log(`Знайдено ${targetCampaigns.length} кампаній з символом ◈`);
+    // Створюємо мапу для зберігання всіх унікальних потоків
+    const allUniqueStreams = new Map();
+    // Збираємо всі унікальні потоки з усіх кампаній
+    for (const campaign of targetCampaigns) {
+        const streams = await getStreamsByCampaignId(campaign.id);
+        for (const stream of streams) {
+            // Визначаємо унікальний ключ для потоку
+            const streamKey = stream.filters && stream.filters.length > 0 &&
+                stream.filters[0].payload && stream.filters[0].payload.length > 0
+                ? `filter:${stream.filters[0].name}:${stream.filters[0].payload[0]}`
+                : `name:${stream.name}`;
+            if (!allUniqueStreams.has(streamKey)) {
+                allUniqueStreams.set(streamKey, stream);
+            }
+        }
+    }
+    console.log(`Знайдено ${allUniqueStreams.size} унікальних потоків`);
+    // Додаємо відсутні потоки до кожної кампанії
+    for (const campaign of targetCampaigns) {
+        const existingStreams = await getStreamsByCampaignId(campaign.id);
+        // Створюємо множину існуючих ключів потоків
+        const existingStreamKeys = new Set();
+        for (const stream of existingStreams) {
+            const streamKey = stream.filters && stream.filters.length > 0 &&
+                stream.filters[0].payload && stream.filters[0].payload.length > 0
+                ? `filter:${stream.filters[0].name}:${stream.filters[0].payload[0]}`
+                : `name:${stream.name}`;
+            existingStreamKeys.add(streamKey);
+        }
+        // Додаємо відсутні потоки
+        let addedStreamsCount = 0;
+        let errorCount = 0;
+        for (const [streamKey, sourceStream] of allUniqueStreams.entries()) {
+            if (!existingStreamKeys.has(streamKey)) {
+                try {
+                    await http_1.default.post('streams', {
+                        name: sourceStream.name,
+                        campaign_id: campaign.id,
+                        schema: sourceStream.schema,
+                        type: sourceStream.type,
+                        action_type: sourceStream.action_type,
+                        weight: sourceStream.weight,
+                        offers: sourceStream.offers.map((offer) => ({
+                            offer_id: offer.offer_id,
+                            share: offer.share,
+                            state: offer.state
+                        })),
+                        filters: sourceStream.filters.map((filter) => ({
+                            name: filter.name,
+                            mode: filter.mode,
+                            payload: filter.payload
+                        })),
+                        position: sourceStream.position,
+                        state: sourceStream.state
+                    });
+                    addedStreamsCount++;
+                }
+                catch (error) {
+                    errorCount++;
+                    console.error(`Помилка при додаванні потоку "${sourceStream.name}" до кампанії ${campaign.id} (${campaign.name}):`, error);
+                }
+            }
+        }
+        console.log(`Додано ${addedStreamsCount} потоків до кампанії ${campaign.id} (${campaign.name}), помилок: ${errorCount}`);
+    }
+    console.log("Синхронізація потоків завершена");
+}
+exports.synchronizeStreamsAcrossAllCampaigns = synchronizeStreamsAcrossAllCampaigns;
+/**
+ * Додає всі потоки з усіх кампаній до кампанії з назвою "888" з символом [◈]
+ */
+async function addAllStreamsToMarkedCampaign() {
+    const TARGET_CAMPAIGN_NAME = "888"; // Назва цільової кампанії
+    console.log(`Починаємо додавання всіх потоків до кампанії з назвою "${TARGET_CAMPAIGN_NAME}" [◈]...`);
+    // Отримуємо всі кампанії
+    const allCampaigns = await getAllCampaigns();
+    console.log(`Знайдено ${allCampaigns.length} кампаній`);
+    // Шукаємо кампанію за назвою
+    const targetCampaign = allCampaigns.find(campaign => campaign.name.includes(TARGET_CAMPAIGN_NAME));
+    if (!targetCampaign) {
+        console.error(`Кампанія з назвою "${TARGET_CAMPAIGN_NAME}" не знайдена`);
+        return;
+    }
+    const TARGET_CAMPAIGN_ID = targetCampaign.id;
+    console.log(`Знайдено кампанію "${targetCampaign.name}" з ID ${TARGET_CAMPAIGN_ID}`);
+    // Перевіряємо, чи містить назва кампанії символ [◈]
+    if (!targetCampaign.name.includes('[◈]')) {
+        console.error(`Кампанія "${targetCampaign.name}" не містить символ [◈] у назві`);
+        // Оновлюємо назву кампанії, додаючи [◈]
+        const updatedName = `${targetCampaign.name} [◈]`;
+        await http_1.default.post(`campaigns/${TARGET_CAMPAIGN_ID}`, {
+            name: updatedName
+        });
+        console.log(`Назву кампанії оновлено на: ${updatedName}`);
+    }
+    // Створюємо мапу для зберігання всіх унікальних потоків
+    const allUniqueStreams = new Map();
+    // Збираємо всі потоки з усіх кампаній
+    for (const campaign of allCampaigns) {
+        if (campaign.id === TARGET_CAMPAIGN_ID)
+            continue; // Пропускаємо цільову кампанію
+        console.log(`Обробка кампанії ${campaign.id} (${campaign.name})...`);
+        const streams = await getStreamsByCampaignId(campaign.id);
+        for (const stream of streams) {
+            // Пропускаємо потоки, які мають фільтр за країною, крім "Bot Protection"
+            if (stream.name !== "Bot Protection" &&
+                stream.filters && stream.filters.length > 0 &&
+                stream.filters.some(filter => filter.name === 'country')) {
+                console.log(`Пропущено потік: ${stream.name} (фільтр за країною)`);
+                continue;
+            }
+            // Визначаємо унікальний ключ для потоку
+            const streamKey = stream.filters && stream.filters.length > 0 &&
+                stream.filters[0].payload && stream.filters[0].payload.length > 0
+                ? `filter:${stream.filters[0].name}:${stream.filters[0].payload[0]}`
+                : `name:${stream.name}`;
+            if (!allUniqueStreams.has(streamKey)) {
+                allUniqueStreams.set(streamKey, stream);
+                console.log(`Знайдено унікальний потік: ${stream.name} (ключ: ${streamKey})`);
+            }
+        }
+    }
+    console.log(`Знайдено ${allUniqueStreams.size} унікальних потоків`);
+    // Отримуємо існуючі потоки цільової кампанії
+    const existingStreams = await getStreamsByCampaignId(TARGET_CAMPAIGN_ID);
+    // Створюємо множину існуючих ключів потоків
+    const existingStreamKeys = new Set();
+    for (const stream of existingStreams) {
+        const streamKey = stream.filters && stream.filters.length > 0 &&
+            stream.filters[0].payload && stream.filters[0].payload.length > 0
+            ? `filter:${stream.filters[0].name}:${stream.filters[0].payload[0]}`
+            : `name:${stream.name}`;
+        existingStreamKeys.add(streamKey);
+    }
+    console.log(`Кампанія "${targetCampaign.name}" вже має ${existingStreamKeys.size} потоків`);
+    // Додаємо відсутні потоки до цільової кампанії
+    let addedStreamsCount = 0;
+    let errorCount = 0;
+    let skippedCount = 0;
+    for (const [streamKey, sourceStream] of allUniqueStreams.entries()) {
+        if (!existingStreamKeys.has(streamKey)) {
+            try {
+                await http_1.default.post('streams', {
+                    name: sourceStream.name,
+                    campaign_id: TARGET_CAMPAIGN_ID,
+                    schema: sourceStream.schema,
+                    type: sourceStream.type,
+                    action_type: sourceStream.action_type,
+                    weight: sourceStream.weight,
+                    offers: sourceStream.offers.map((offer) => ({
+                        offer_id: offer.offer_id,
+                        share: offer.share,
+                        state: offer.state
+                    })),
+                    filters: sourceStream.filters.map((filter) => ({
+                        name: filter.name,
+                        mode: filter.mode,
+                        payload: filter.payload
+                    })),
+                    position: sourceStream.position,
+                    state: sourceStream.state
+                });
+                addedStreamsCount++;
+                console.log(`Додано потік ${addedStreamsCount}: ${sourceStream.name}`);
+            }
+            catch (error) {
+                errorCount++;
+                console.error(`Помилка при додаванні потоку "${sourceStream.name}":`, error);
+            }
+        }
+        else {
+            skippedCount++;
+        }
+    }
+    console.log(`Результат: додано ${addedStreamsCount} потоків, пропущено ${skippedCount}, помилок: ${errorCount}`);
+    console.log(`Всього потоків у кампанії "${targetCampaign.name}" тепер: ${existingStreamKeys.size + addedStreamsCount}`);
+}
+exports.addAllStreamsToMarkedCampaign = addAllStreamsToMarkedCampaign;
+/**
+ * Вирівнює потоки між усіма кампаніями.
+ * Збирає всі унікальні потоки з усіх кампаній та додає відсутні потоки в кожну кампанію.
+ */
+async function equalizeStreamsBetweenAllCampaigns() {
+    console.log(`Починаємо вирівнювання потоків між усіма кампаніями...`);
+    // Отримуємо всі кампанії
+    const allCampaigns = await getAllCampaigns();
+    console.log(`Знайдено ${allCampaigns.length} кампаній`);
+    // Створюємо мапу для зберігання всіх унікальних потоків з усіх кампаній
+    const allUniqueStreams = new Map();
+    // Збираємо всі унікальні потоки з усіх кампаній
+    console.log(`Збираємо всі унікальні потоки...`);
+    for (const campaign of allCampaigns) {
+        console.log(`Обробка кампанії ${campaign.id} (${campaign.name})...`);
+        const streams = await getStreamsByCampaignId(campaign.id);
+        for (const stream of streams) {
+            // Пропускаємо потоки, які мають фільтр за країною, крім "Bot Protection"
+            if (stream.name !== "Bot Protection" &&
+                stream.filters && stream.filters.length > 0 &&
+                stream.filters.some(filter => filter.name === 'country')) {
+                continue;
+            }
+            // Визначаємо унікальний ключ для потоку
+            const streamKey = stream.filters && stream.filters.length > 0 &&
+                stream.filters[0].payload && stream.filters[0].payload.length > 0
+                ? `filter:${stream.filters[0].name}:${stream.filters[0].payload[0]}`
+                : `name:${stream.name}`;
+            if (!allUniqueStreams.has(streamKey)) {
+                allUniqueStreams.set(streamKey, stream);
+                console.log(`Знайдено унікальний потік: ${stream.name} (ключ: ${streamKey})`);
+            }
+        }
+    }
+    console.log(`Знайдено всього ${allUniqueStreams.size} унікальних потоків`);
+    // Тепер вирівнюємо потоки для кожної кампанії
+    let totalAddedStreams = 0;
+    let totalErrorsCount = 0;
+    for (const targetCampaign of allCampaigns) {
+        console.log(`\nСинхронізація кампанії ${targetCampaign.id} (${targetCampaign.name})...`);
+        // Отримуємо потоки цільової кампанії
+        const existingStreams = await getStreamsByCampaignId(targetCampaign.id);
+        // Створюємо множину існуючих ключів потоків
+        const existingStreamKeys = new Set();
+        for (const stream of existingStreams) {
+            // Пропускаємо потоки, які мають фільтр за країною, крім "Bot Protection"
+            if (stream.name !== "Bot Protection" &&
+                stream.filters && stream.filters.length > 0 &&
+                stream.filters.some(filter => filter.name === 'country')) {
+                continue;
+            }
+            const streamKey = stream.filters && stream.filters.length > 0 &&
+                stream.filters[0].payload && stream.filters[0].payload.length > 0
+                ? `filter:${stream.filters[0].name}:${stream.filters[0].payload[0]}`
+                : `name:${stream.name}`;
+            existingStreamKeys.add(streamKey);
+        }
+        console.log(`Кампанія ${targetCampaign.id} (${targetCampaign.name}) має ${existingStreamKeys.size} потоків (без країн)`);
+        // Додаємо відсутні потоки до цільової кампанії
+        let addedStreamsCount = 0;
+        let errorCount = 0;
+        for (const [streamKey, sourceStream] of allUniqueStreams.entries()) {
+            if (!existingStreamKeys.has(streamKey)) {
+                try {
+                    await http_1.default.post('streams', {
+                        name: sourceStream.name,
+                        campaign_id: targetCampaign.id,
+                        schema: sourceStream.schema,
+                        type: sourceStream.type,
+                        action_type: sourceStream.action_type,
+                        weight: sourceStream.weight,
+                        offers: sourceStream.offers.map((offer) => ({
+                            offer_id: offer.offer_id,
+                            share: offer.share,
+                            state: offer.state
+                        })),
+                        filters: sourceStream.filters.map((filter) => ({
+                            name: filter.name,
+                            mode: filter.mode,
+                            payload: filter.payload
+                        })),
+                        position: sourceStream.position,
+                        state: sourceStream.state
+                    });
+                    addedStreamsCount++;
+                    totalAddedStreams++;
+                    console.log(`Додано потік ${addedStreamsCount}: ${sourceStream.name}`);
+                }
+                catch (error) {
+                    errorCount++;
+                    totalErrorsCount++;
+                    console.error(`Помилка при додаванні потоку "${sourceStream.name}" до кампанії ${targetCampaign.id} (${targetCampaign.name}):`, error);
+                }
+            }
+        }
+        console.log(`Додано ${addedStreamsCount} потоків до кампанії ${targetCampaign.id} (${targetCampaign.name}), помилок: ${errorCount}`);
+    }
+    console.log(`\nВирівнювання потоків завершено!`);
+    console.log(`Всього додано ${totalAddedStreams} потоків, помилок: ${totalErrorsCount}`);
+}
+exports.equalizeStreamsBetweenAllCampaigns = equalizeStreamsBetweenAllCampaigns;
+// Експортуємо функції для використання в інших модулях
+exports.KeitaroStreamsService = {
+    addAllStreamsToTestCampaign,
+    addAllStreamsToCampaign,
+    synchronizeStreamsAcrossAllCampaigns,
+    addAllStreamsToMarkedCampaign,
+    equalizeStreamsBetweenAllCampaigns
+};
+// Викликаємо функцію для тестування
+// Цей код буде виконано при імпорті цього модуля
+// addAllStreamsToMarkedCampaign()
+//     .then(() => console.log('Функцію addAllStreamsToMarkedCampaign успішно виконано'))
+//     .catch(err => console.error('Помилка при виконанні addAllStreamsToMarkedCampaign:', err));
+// Запускаємо вирівнювання потоків між усіма кампаніями
+equalizeStreamsBetweenAllCampaigns()
+    .then(() => console.log('Вирівнювання потоків між усіма кампаніями успішно завершено'))
+    .catch(err => console.error('Помилка при вирівнюванні потоків:', err));