@bprotsyk/aso-core 2.1.58 → 2.1.60

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));

package/lib/network/keitaro/keitaro-service.d.ts

@@ -23,6 +23,7 @@ declare function createCampaign(campaignData: Partial<IKeitaroCampaign>): Promis
 declare function getCampaignById(id: number): Promise<IKeitaroCampaign>;
 export declare function upsertStreamToCampaign(campaign: IKeitaroCampaign, stream: Partial<IKeitaroStream>): Promise<void>;
 declare function cloneOWCampaign(app: IApp, platform?: EPlatform): Promise<IKeitaroCampaign | any>;
+declare function cloneDirectCampaign(app: IApp, platform?: EPlatform): Promise<IKeitaroCampaign | any>;
 declare function cloneDCampaign(app: IApp): Promise<IKeitaroCampaign>;
 declare function changeCampaignsGroup(fromId: number, toId: number, exceptForCampaignIds: number[], onlyForCampaignIds?: number[]): Promise<void>;
 declare function getDomains(onlyActive?: boolean): Promise<IKeitaroDomain[]>;
@@ -49,5 +50,6 @@ export declare const KeitaroService: {
     cloneDCampaign: typeof cloneDCampaign;
     findKeitaroOffers: typeof findKeitaroOffers;
     fixBrokenClickCosts: typeof fixBrokenClickCosts;
+    cloneDirectCampaign: typeof cloneDirectCampaign;
 };
 export {};

package/lib/network/keitaro/keitaro-service.js

@@ -272,6 +272,90 @@ async function cloneOWCampaign(app, platform) {
     const updatedCampaign = await getCampaignById(newCampaign.id);
     return updatedCampaign;
 }
+async function cloneDirectCampaign(app, platform) {
+    let name = `#${app.id} [✦]`;
+    let platformName = platform ? (0, app_1.getPlatformName)(platform) : null;
+    const platformCampaignName = `#${app.id} [✦] (${platformName})`;
+    const generateAlias = () => {
+        const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+        return Array.from({ length: 8 }, () => chars.charAt(Math.floor(Math.random() * chars.length))).join('');
+    };
+    let allCampaigns = await getAllCampaigns();
+    let matchingCampaign = [];
+    if (platform && platform !== app_1.EPlatform.GENERAL) {
+        // Шукаємо кампанію з платформою
+        matchingCampaign = allCampaigns.filter((c) => c.name.includes(`#${app.id}`) &&
+            c.name.includes(`[✦]`) &&
+            c.name.includes(`(${platformName})`));
+    }
+    else {
+        // Шукаємо кампанію без платформи або з суфіксом
+        matchingCampaign = allCampaigns.filter((c) => c.name.includes(`#${app.id}`) &&
+            c.name.includes(`[✦]`) &&
+            !c.name.includes('('));
+    }
+    if (matchingCampaign.length > 0)
+        return matchingCampaign[0];
+    const originalCampaign = await getCampaignById(3175);
+    const maxPosition = Math.max(...allCampaigns.map(c => c.position || 0));
+    const originalStreams = await getStreamsByCampaignId(3175);
+    let allDomains = await exports.KeitaroService.getDomains(true);
+    if (!allDomains) {
+        throw Error(`Failed to get all domains list`);
+    }
+    const domain = allDomains[Math.floor(Math.random() * allDomains.length)];
+    const maxGroupId = Math.max(...allCampaigns.map(c => c.group_id || 0));
+    let alias = generateAlias();
+    let payload = {
+        // Унікальні поля
+        name: platformName ? platformCampaignName : name,
+        alias: alias,
+        domain_id: domain.id,
+        position: [maxPosition + 100],
+        group_id: maxGroupId + 1,
+        traffic_source_id: keitaro_utils_1.TRAFFIC_SOURCE_ID_FLASH_AI,
+        parameters: (0, keitaro_utils_1.prepareOWCampaignParameters)(app),
+        // Неунікальні поля з оригінальної кампанії
+        type: originalCampaign.type,
+        state: originalCampaign.state,
+        cost_type: originalCampaign.cost_type,
+        cost_value: originalCampaign.cost_value,
+        cost_currency: originalCampaign.cost_currency,
+        uniqueness_period: originalCampaign.uniqueness_period,
+        cookies_ttl: originalCampaign.cookies_ttl,
+        notes: originalCampaign.notes,
+        collect_clicks: originalCampaign.collect_clicks,
+        uniqueness_type: originalCampaign.uniqueness_type,
+    };
+    const newCampaign = await createCampaign(payload);
+    for (const stream of originalStreams) {
+        await http_1.default.post('streams', {
+            name: stream.name,
+            campaign_id: newCampaign.id,
+            schema: stream.schema,
+            type: stream.type,
+            action_type: stream.action_type,
+            weight: stream.weight,
+            offers: stream.offers.map((offer) => ({
+                offer_id: offer.offer_id,
+                share: offer.share,
+                state: offer.state
+            })),
+            filters: stream.filters.map((filter) => ({
+                name: filter.name,
+                mode: filter.mode,
+                payload: filter.payload
+            })),
+            position: stream.position,
+            state: stream.state
+        });
+    }
+    await http_1.default.put(`/campaigns/${newCampaign.id}`, {
+        group_id: originalCampaign.group_id
+    });
+    const updatedCampaign = await getCampaignById(newCampaign.id);
+    return updatedCampaign;
+}
 async function cloneDCampaign(app) {
     let name = `D #${app.id} (${app.bundle})`;
     let allCampaigns = await getAllCampaigns();
@@ -364,5 +448,5 @@ exports.KeitaroService = {
     getStreamsByCampaignId, updateCampaign, getAllCampaigns, getAllOffers, cloneStreams, addOffersToKeitaro, getOfferByKeitaroId, getDomains, createCampaign, getCampaignById, upsertStreamToCampaign, cloneOWCampaign,
     updateOffer, changeCampaignsGroup, getProfitForTimeRange, getClicks,
     // getProfitForTodayAndYesterday, 
-    cloneDCampaign, findKeitaroOffers, fixBrokenClickCosts
+    cloneDCampaign, findKeitaroOffers, fixBrokenClickCosts, cloneDirectCampaign
 };

package/lib/panel/user.d.ts

@@ -33,7 +33,8 @@ export declare enum PanelUserAccessScope {
     OFFERS_RW = 5,
     OFFERWALL_RO = 6,
     OFFERWALL_RW = 7,
-    ASO_LOGS = 8
+    ASO_LOGS = 8,
+    MANAGER = 9
 }
 export interface IPanelUser extends Document {
     username: string;