@bprotsyk/aso-core 2.1.99 → 2.1.101

package/src/network/keitaro/traffle/traffle-keitaro-service.ts

@@ -10,6 +10,7 @@ import { IKeitaroOffer, IKeitaroOffersFilter } from "index";
 import { IKeitaroClicksRequest, IKeitaroClicksRangeRequest, KeitaroClicksInterval } from "../../../keitaro/keitaro-clicks";
 import { OpenAI } from "../../../network/openai/openai";
 import { off } from "process";
+import { IKeitaroCampaignParameters } from "../../../keitaro/keitaro-campaign";
 
 async function getAllOffers(): Promise<IKeitaroOffer[]> {
     const { data: offers } = await keitaroApi.get<IKeitaroOffer[]>('offers')
@@ -43,6 +44,12 @@ export interface IAffiliateNetwork {
     offers: number;
 }
 
+interface IParamsGenerationsOpenAIResponse {
+    naming: string;
+    advertisingid: string;
+    appsflyerDeviceID: string;
+}
+
 async function getTraffleOffersGroups(): Promise<any[]> {
     try {
         const response  = await keitaroApi.get('/groups?type=offers');
@@ -147,6 +154,302 @@ async function updateOfferLinkById(id: number, action_payload: string | object):
 }
 
 
+async function getCampaignById(id: number): Promise<IKeitaroCampaign> {
+    const { data: campaign } = await keitaroApi.get(`/campaigns/${id}`);
+    return campaign
+}
+
+async function getAllCampaigns(): Promise<IKeitaroCampaign[]> {
+    const { data: campaigns } = await keitaroApi.get<IKeitaroCampaign[]>('campaigns');
+    return campaigns
+}
+async function getDomains(onlyActive?: boolean): Promise<IKeitaroDomain[]> {
+    const { data: domains } = await keitaroApi.get<IKeitaroDomain[]>(`/domains`)
+    return onlyActive ? domains.filter((d) => d.network_status == "active") : domains
+}
+
+async function getStreamsByCampaignId(campaignId: number): Promise<IKeitaroStream[]> {
+    const { data: streams } = await keitaroApi.get<IKeitaroStream[]>(`campaigns/${campaignId}/streams`);
+
+    return streams
+}
+async function createCampaign(campaignData: Partial<IKeitaroCampaign>): Promise<IKeitaroCampaign> {
+    let { data: campaign } = await keitaroApi.post(`/campaigns`, campaignData)
+
+    return campaign
+}
+
+
+async function TrafleKeitaroParameters(parameters: any) {
+    const {bundle, appsflyerDevKey, name} = parameters
+
+    let openAIResponse = await OpenAI.requestOpenAI({
+        model: "o3-mini",
+        messages: [
+            { role: "user", content: `sid for ${bundle} ${name} generations Generate **one** random English word in full lowercase (still lowercase, no numbers or special characters) for the parameters "naming", "advertisingid", "appsflyerDeviceID". Return **ONLY** an JSON object: { "naming": "word", "advertisingid": "word", "appsflyerDeviceID": "word"}`},
+        ]
+    })
+
+    if (!openAIResponse) {
+        return null;
+    }
+
+    let ParamsGenerationsOpenAIResponse: IParamsGenerationsOpenAIResponse | null = null;
+    try {
+        ParamsGenerationsOpenAIResponse = JSON.parse(openAIResponse);
+    } catch (error) {
+        console.error("Failed to parse OpenAI response:", error);
+        return null;
+    }
+
+    console.log(`ParamsGenerationsOpenAIResponse: ${JSON.stringify(ParamsGenerationsOpenAIResponse)}`)
+
+
+    return {
+        parameters: {
+            keyword: { name: 'keyword', placeholder: '', alias: '' },
+            cost: { name: 'cost', placeholder: '', alias: '' },
+            currency: { name: 'currency', placeholder: '', alias: '' },
+            external_id: { name: 'external_id', placeholder: '', alias: '' },
+            creative_id: { name: 'creative_id', placeholder: '', alias: '' },
+            ad_campaign_id: { name: 'ad_campaign_id', placeholder: '', alias: '' },
+            source: { name: 'source', placeholder: '', alias: '' },
+            sub_id_1: { name: 'uqID', placeholder: '', alias: '' },
+            sub_id_2: { name: 'AD_ID', placeholder: '', alias: '' },
+            sub_id_3: { name: 'USB', placeholder: '', alias: '' },
+            sub_id_4: { name: 'DEV', placeholder: '', alias: '' },
+            sub_id_5: { name: 'LANG', placeholder: '', alias: '' },
+            sub_id_10: { name: 'market', placeholder: '', alias: '' },
+            sub_id_15: { name: ParamsGenerationsOpenAIResponse?.naming, placeholder: '{naming}', alias: 'Naming' },
+            sub_id_16: {
+                name: 'bundle_id',
+                placeholder: bundle,
+                alias: 'Bundle ID'
+            },
+            sub_id_17: {
+                name: ParamsGenerationsOpenAIResponse?.advertisingid,
+                placeholder: '{advertising_id}',
+                alias: 'Advertising ID'
+            },
+            sub_id_18: {
+                name: ParamsGenerationsOpenAIResponse?.appsflyerDeviceID,
+                placeholder: '{appsflyer_device_id}',
+                alias: 'Appsflyer Device ID'
+            },
+            sub_id_19: {
+                name: 'appsflyer_dev_key',
+                placeholder: appsflyerDevKey,
+                alias: 'Appsflyer Dev Key'
+            }
+        }
+    }
+}
+
+async function cloneTraffleCampaign(app: IApp, platform: EPlatform, addDefaultStreams?: boolean): Promise<IKeitaroCampaign | any> {
+
+    const ORIGINAL_CLONE_CAMPAIGN_ID = 1925;
+    const appsflyerAvailability = app.platforms[platform].appsflyerParams?.apiToken ? "[AF]" : "";
+    let name = `[${app.id}] ${app.name} ET [${app.bundle}] [Android] ${appsflyerAvailability} ${app.domainParams.name}`
+    let platformName = platform ? 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: IKeitaroCampaign[] = [];
+
+    if (platform && platform !== EPlatform.GENERAL) {
+        // Для конкретної платформи
+        const platformName = getPlatformName(platform);
+        matchingCampaign = allCampaigns.filter((c) => {
+            // Точна перевірка ID з межами слів
+            const idPattern = new RegExp(`${app.id}\\b`);
+            const hasId = idPattern.test(c.name);
+            const hasBundle = c.name.includes(`[${app.bundle}]`);
+            
+            // Перевіряємо наявність платформи в дужках в кінці назви
+            const platformPattern = new RegExp(`\\(.*${platformName}.*\\)\\s*$`);
+            const hasPlatform = platformPattern.test(c.name);
+            return hasId  && hasBundle && hasPlatform;
+        });
+    } else {
+        // Для General платформи
+        matchingCampaign = allCampaigns.filter((c) => {
+            // Точна перевірка ID з межами слів
+            const idPattern = new RegExp(`${app.id}\\b`);
+            const hasId = idPattern.test(c.name);
+            const hasBundle = c.name.includes(`[${app.bundle}]`);
+          
+            // Перевіряємо відсутність платформи в дужках в кінці
+            // Дозволяємо будь-які інші дужки (як для гео або опису)
+            const noPlatformAtEnd = !/\(.*(?:iOS|Android|Desktop|Mobile).*\)\s*$/.test(c.name);
+            return hasId && hasBundle && noPlatformAtEnd;
+        });
+    }
+
+
+
+    const originalCampaign: IKeitaroCampaign = await getCampaignById(ORIGINAL_CLONE_CAMPAIGN_ID);
+    const maxPosition = Math.max(...allCampaigns.map(c => c.position || 0));
+
+    let allDomains = await getDomains(true);
+    if (!allDomains) {
+        throw Error(`Failed to get all domains list`);
+    }
+
+    
+    const maxGroupId = Math.max(...allCampaigns.map(c => c.group_id || 0));
+    const originalStreams = await getStreamsByCampaignId(ORIGINAL_CLONE_CAMPAIGN_ID);
+
+    let parameters = await TrafleKeitaroParameters({bundle: app.bundle, appsflyerDevKey: app.platforms[platform].appsflyerParams?.apiToken, name: name})
+
+    const createStreamWithoutIds = async (stream: IKeitaroStream, campaignId: number) => {
+        // Створюємо базовий об'єкт потоку без ID
+        const newStream = {
+            type: stream.type,
+            name: stream.name,
+            campaign_id: campaignId,
+            position: stream.position,
+            state: stream.state,
+            action_type: stream.action_type,
+            action_payload: stream.action_payload || "",
+            schema: stream.schema,
+            collect_clicks: stream.collect_clicks,
+            filter_or: stream.filter_or,
+            weight: stream.weight,
+            filters: stream.filters.map(filter => ({
+                name: filter.name,
+                mode: filter.mode,
+                payload: filter.payload
+            })),
+            offers: stream.offers.map(offer => ({
+                offer_id: offer.offer_id,
+                state: offer.state,
+                share: offer.share
+            }))
+        };
+
+        // Створюємо новий потік
+        await keitaroApi.post('streams', newStream);
+    };
+
+    const updateOrCreateCLOStream = async (campaignId: number, existingStreams?: IKeitaroStream[]) => {
+        const cloTemplate = originalStreams.find(s => s.name === "CLO");
+        if (!cloTemplate) return;
+
+        const cloStream = {
+            type: cloTemplate.type,
+            name: "CLO",
+            campaign_id: campaignId,
+            position: cloTemplate.position,
+            state: cloTemplate.state,
+            action_type: cloTemplate.action_type,
+            action_payload: cloTemplate.action_payload || "",
+            schema: cloTemplate.schema,
+            collect_clicks: cloTemplate.collect_clicks,
+            filter_or: cloTemplate.filter_or,
+            weight: cloTemplate.weight,
+            filters: [
+                {
+                    name: "country",
+                    mode: "reject",
+                    payload: app.platforms[platform].geo || []
+                },
+                {
+                    name: "bot",
+                    mode: "accept",
+                    payload: null
+                }
+            ],
+            offers: []
+        };
+
+        if (existingStreams) {
+            const existingCLO = existingStreams.find(s => s.name === "CLO");
+            if (existingCLO) {
+                await keitaroApi.put(`streams/${existingCLO.id}`, cloStream);
+                return;
+            }
+        }
+
+        await keitaroApi.post('streams', cloStream);
+    };
+
+    // Якщо знайдена існуюча кампанія
+    if (matchingCampaign.length > 0) {
+        const existingCampaign = matchingCampaign[0];
+        const existingStreams = await getStreamsByCampaignId(existingCampaign.id);
+        
+        // Завжди оновлюємо CLO потік
+        await updateOrCreateCLOStream(existingCampaign.id, existingStreams);
+        
+        // Для інших потоків
+        if (addDefaultStreams) {
+            for (const stream of originalStreams) {
+                if (stream.name === "CLO") continue; // Пропускаємо CLO
+                
+                const existingStream = existingStreams.find(s => s.name === stream.name);
+                if (!existingStream) {
+                    await createStreamWithoutIds(stream, existingCampaign.id);
+                }
+            }
+        }
+        
+        return existingCampaign;
+    }
+
+    // Створення нової кампанії
+    let alias = generateAlias();
+
+    let payload: Partial<IKeitaroCampaign> = {
+        // Унікальні поля
+        name: platformName ? platformCampaignName : name,
+        alias: alias,
+        domain_id: originalCampaign.domain_id,
+        position: [maxPosition + 100],
+        group_id: maxGroupId + 1,
+        traffic_source_id: 17,
+        parameters: (parameters ? parameters.parameters : originalCampaign.parameters) as IKeitaroCampaignParameters,
+        source: originalCampaign.source,
+        bind_visitors: "slo",
+        // Неунікальні поля з оригінальної кампанії
+        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: IKeitaroCampaign = await createCampaign(payload);
+
+    // Спочатку створюємо CLO потік з оновленими гео
+    await updateOrCreateCLOStream(newCampaign.id);
+
+    // Потім клонуємо всі інші потоки
+    for (const stream of originalStreams) {
+        if (stream.name === "CLO") continue; // Пропускаємо CLO потік
+        await createStreamWithoutIds(stream, newCampaign.id);
+    }
+
+    await keitaroApi.put(`/campaigns/${newCampaign.id}`, {
+        group_id: originalCampaign.group_id
+    });
+
+    const updatedCampaign = await getCampaignById(newCampaign.id);
+    return updatedCampaign;
+}
+
+
 export const TraffleKeitaroService = {
-    addOffersToTraffleKeitaro, getTraffleOffersGroups, getTraffleAffiliateNetworks, createGroup, deleteOfferById, getAllOffers, updateOfferLinkById
+    addOffersToTraffleKeitaro, getTraffleOffersGroups, getTraffleAffiliateNetworks, createGroup, deleteOfferById, getAllOffers, updateOfferLinkById, cloneTraffleCampaign
 }

package/test-keitaro.js

@@ -1,8 +1,33 @@
-const { KeitaroService } = require('./lib/network/keitaro/keitaro-service');
+const { TraffleKeitaroService } = require('./lib/network/keitaro/traffle/traffle-keitaro-service');
+const { EPlatform } = require('./lib/app/app');
 
 async function testClone() {
     try {
-        const result = await KeitaroService.cloneDirectCampaign({ id: 901} );
+        // Тестові дані для створення кампанії
+        const testApp = {
+            id: 901,
+            bundle: "com.test.app",
+            name: "Test App",
+            platforms: {
+                '@': {
+                    geo: ["UA", "RU"],
+                    appsflyerParams: {
+                        apiToken: "test_token"
+                    }
+                }
+            },
+            domainParams: {
+                name: "test.com"
+            }
+        };
+
+        // Створюємо Traffle кампанію
+        const result = await TraffleKeitaroService.cloneTraffleCampaign(
+            testApp,
+            EPlatform.GENERAL,
+            true // addDefaultStreams
+        );
+        
         console.log('Cloned campaign:', result);
     } catch (error) {
         console.error('Error:', error);

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

@@ -1,52 +0,0 @@
-import { KeitaroClicksInterval } from './keitaro-clicks';
-export declare enum KeitaroOperator {
-    EQUALS = "EQUALS",
-    NOT_EQUAL = "NOT_EQUAL",
-    EQUALS_OR_GREATER_THAN = "EQUALS_OR_GREATER_THAN",
-    EQUALS_OR_LESS_THAN = "EQUALS_OR_LESS_THAN",
-    GREATER_THAN = "GREATER_THAN",
-    LESS_THAN = "LESS_THAN",
-    MATCH_REGEXP = "MATCH_REGEXP",
-    NOT_MATCH_REGEXP = "NOT_MATCH_REGEXP",
-    BEGINS_WITH = "BEGINS_WITH",
-    ENDS_WITH = "ENDS_WITH",
-    CONTAINS = "CONTAINS",
-    NOT_CONTAIN = "NOT_CONTAIN",
-    IN_LIST = "IN_LIST",
-    NOT_IN_LIST = "NOT_IN_LIST",
-    BETWEEN = "BETWEEN",
-    IS_SET = "IS_SET",
-    IS_NOT_SET = "IS_NOT_SET",
-    IS_TRUE = "IS_TRUE",
-    IS_FALSE = "IS_FALSE",
-    HAS_LABEL = "HAS_LABEL",
-    NOT_HAS_LABEL = "NOT_HAS_LABEL"
-}
-export interface IKeitaroConversionRangeRequest {
-    from?: string;
-    to?: string;
-    timezone?: string;
-    interval?: KeitaroClicksInterval;
-}
-export interface IKeitaroConversionFilterRequest {
-    name: string;
-    operator: KeitaroOperator;
-    expression?: string | number | Array<string | number>;
-}
-export interface IKeitaroConversionSortRequest {
-    name: string;
-    order: 'ASC' | 'DESC';
-}
-export interface IKeitaroConversionsRequest {
-    range: IKeitaroConversionRangeRequest;
-    limit?: number;
-    offset?: number;
-    columns?: string[];
-    filters?: IKeitaroConversionFilterRequest[];
-    sort?: IKeitaroConversionSortRequest[];
-}
-export interface IKeitaroConversionsResponse {
-    rows: any[];
-    total: number;
-    meta: string[];
-}

package/lib/keitaro/keitaro-conversions.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KeitaroOperator = void 0;
-var KeitaroOperator;
-(function (KeitaroOperator) {
-    KeitaroOperator["EQUALS"] = "EQUALS";
-    KeitaroOperator["NOT_EQUAL"] = "NOT_EQUAL";
-    KeitaroOperator["EQUALS_OR_GREATER_THAN"] = "EQUALS_OR_GREATER_THAN";
-    KeitaroOperator["EQUALS_OR_LESS_THAN"] = "EQUALS_OR_LESS_THAN";
-    KeitaroOperator["GREATER_THAN"] = "GREATER_THAN";
-    KeitaroOperator["LESS_THAN"] = "LESS_THAN";
-    KeitaroOperator["MATCH_REGEXP"] = "MATCH_REGEXP";
-    KeitaroOperator["NOT_MATCH_REGEXP"] = "NOT_MATCH_REGEXP";
-    KeitaroOperator["BEGINS_WITH"] = "BEGINS_WITH";
-    KeitaroOperator["ENDS_WITH"] = "ENDS_WITH";
-    KeitaroOperator["CONTAINS"] = "CONTAINS";
-    KeitaroOperator["NOT_CONTAIN"] = "NOT_CONTAIN";
-    KeitaroOperator["IN_LIST"] = "IN_LIST";
-    KeitaroOperator["NOT_IN_LIST"] = "NOT_IN_LIST";
-    KeitaroOperator["BETWEEN"] = "BETWEEN";
-    KeitaroOperator["IS_SET"] = "IS_SET";
-    KeitaroOperator["IS_NOT_SET"] = "IS_NOT_SET";
-    KeitaroOperator["IS_TRUE"] = "IS_TRUE";
-    KeitaroOperator["IS_FALSE"] = "IS_FALSE";
-    KeitaroOperator["HAS_LABEL"] = "HAS_LABEL";
-    KeitaroOperator["NOT_HAS_LABEL"] = "NOT_HAS_LABEL";
-})(KeitaroOperator = exports.KeitaroOperator || (exports.KeitaroOperator = {}));

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

@@ -1,2 +0,0 @@
-import { ConversionComparison } from '../utils/comparing';
-export declare function displayComparisonResults(comparison: ConversionComparison): void;

package/lib/keitaro/keitaro-utils.js

@@ -1,108 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.displayComparisonResults = void 0;
-function displayComparisonResults(comparison) {
-    const isValidStatus = (status) => ['sale', 'rebill'].includes(status);
-    let wpTotalSum = comparison.wpConversions
-        .reduce((sum, conv) => sum + conv.sum, 0);
-    let keitaroTotalSum = comparison.keitaroConversions
-        .filter(conv => isValidStatus(conv.status))
-        .reduce((sum, conv) => sum + (parseFloat(conv.revenue) || 0), 0);
-    // Get all Keitaro rejected conversions
-    const allKeitaroRejected = [
-        ...comparison.rejected.keitaro,
-        ...comparison.matches
-            .filter(match => match.keitaro.status === 'rejected')
-            .map(match => match.keitaro)
-    ];
-    // Group mismatches by project/offer
-    const wpMismatchesByProject = new Map();
-    const keitaroMismatchesByOffer = new Map();
-    const rejectedByOffer = new Map();
-    comparison.mismatches.onlyInWP.forEach(conv => {
-        if (!wpMismatchesByProject.has(conv.project)) {
-            wpMismatchesByProject.set(conv.project, { count: 0, sum: 0, conversions: [] });
-        }
-        const projectStats = wpMismatchesByProject.get(conv.project);
-        projectStats.count++;
-        projectStats.sum += conv.sum;
-        projectStats.conversions.push(conv);
-    });
-    // Include all conversions in mismatches, including rejected ones
-    [...comparison.mismatches.onlyInKeitaro, ...allKeitaroRejected].forEach(conv => {
-        if (!keitaroMismatchesByOffer.has(conv.offer)) {
-            keitaroMismatchesByOffer.set(conv.offer, { count: 0, sum: 0, conversions: [] });
-        }
-        const offerStats = keitaroMismatchesByOffer.get(conv.offer);
-        offerStats.count++;
-        offerStats.sum += parseFloat(conv.revenue) || 0;
-        offerStats.conversions.push(conv);
-    });
-    // Group rejected conversions by offer
-    allKeitaroRejected.forEach(conv => {
-        if (!rejectedByOffer.has(conv.offer)) {
-            rejectedByOffer.set(conv.offer, { count: 0, sum: 0, conversions: [] });
-        }
-        const offerStats = rejectedByOffer.get(conv.offer);
-        offerStats.count++;
-        offerStats.sum += parseFloat(conv.revenue) || 0;
-        offerStats.conversions.push(conv);
-    });
-    console.log('\n\x1b[1mЗагальна статистика:\x1b[0m');
-    console.log(`Всього конверсій у WP: ${comparison.wpConversions.length} (Сума: \x1b[33m$${wpTotalSum.toFixed(2)}\x1b[0m)`);
-    console.log(`Всього конверсій у Keitaro: ${comparison.keitaroConversions.filter(conv => isValidStatus(conv.status)).length} (Сума: \x1b[33m$${keitaroTotalSum.toFixed(2)}\x1b[0m)`);
-    console.log(`Співпадінь: ${comparison.matches.length}`);
-    console.log(`Відхилених конверсій: ${allKeitaroRejected.length}`);
-    const totalDiff = Math.abs(wpTotalSum - keitaroTotalSum);
-    console.log(`\x1b[1mЗагальна різниця:\x1b[0m \x1b[33m$${totalDiff.toFixed(2)}\x1b[0m`);
-    // Always show rejected conversions first if there are any
-    if (allKeitaroRejected.length > 0) {
-        const rejectedTotal = allKeitaroRejected.reduce((sum, conv) => sum + (parseFloat(conv.revenue) || 0), 0);
-        console.log('\n\x1b[1mВідхилені конверсії в Keitaro за офферами:\x1b[0m');
-        console.log(`Загальна кількість: ${allKeitaroRejected.length}`);
-        console.log(`Загальна сума: \x1b[33m$${rejectedTotal.toFixed(2)}\x1b[0m`);
-        for (const [offer, stats] of rejectedByOffer.entries()) {
-            console.log(`\n\x1b[33m${offer}:\x1b[0m`);
-            console.log(`Кількість: ${stats.count}, Сума: $${stats.sum.toFixed(2)}`);
-            stats.conversions.forEach(conv => {
-                const matchMark = comparison.matches.some(match => match.keitaro.sub_id === conv.sub_id) ? '[matched] ' : '';
-                console.log(`  ${matchMark}${conv.sub_id} | ${conv.sale_datetime.split(' ')[0]} | $${conv.revenue}`);
-            });
-        }
-    }
-    console.log('\n\x1b[1mВідсутні в Keitaro за проектами:\x1b[0m');
-    for (const [project, stats] of wpMismatchesByProject) {
-        console.log(`\n\x1b[31m${project}:\x1b[0m`);
-        console.log(`Кількість: ${stats.count}, Сума: $${stats.sum.toFixed(2)}`);
-        stats.conversions.forEach(conv => {
-            console.log(`  ${conv.clickId} | ${conv.regDate.toISOString().split('T')[0]} | $${conv.sum}`);
-        });
-    }
-    console.log('\n\x1b[1mВідсутні в WP за офферами:\x1b[0m');
-    for (const [offer, stats] of keitaroMismatchesByOffer) {
-        console.log(`\n\x1b[32m${offer}:\x1b[0m`);
-        console.log(`Кількість: ${stats.count}, Сума: $${stats.sum.toFixed(2)}`);
-        stats.conversions.forEach(conv => {
-            const statusMark = conv.status === 'rejected' ? '(rejected) ' : '';
-            const matchMark = comparison.matches.some(match => match.keitaro.sub_id === conv.sub_id) ? '[matched] ' : '';
-            console.log(`  ${statusMark}${matchMark}${conv.sub_id} | ${conv.sale_datetime.split(' ')[0]} | $${conv.revenue}`);
-        });
-    }
-    let mismatchWPSum = comparison.mismatches.onlyInWP
-        .reduce((sum, conv) => sum + conv.sum, 0);
-    let mismatchKeitaroSum = [...comparison.mismatches.onlyInKeitaro, ...allKeitaroRejected]
-        .reduce((sum, conv) => sum + (parseFloat(conv.revenue) || 0), 0);
-    console.log('\n\x1b[1mПідсумок розбіжностей:\x1b[0m');
-    console.log(`Сума відсутніх в Keitaro: \x1b[31m$${mismatchWPSum.toFixed(2)}\x1b[0m`);
-    console.log(`Сума відсутніх в WP: \x1b[32m$${mismatchKeitaroSum.toFixed(2)}\x1b[0m`);
-    console.log(`Різниця у відсутніх конверсіях: \x1b[33m$${Math.abs(mismatchWPSum - mismatchKeitaroSum).toFixed(2)}\x1b[0m`);
-    // Debug information
-    const matchingRejected = comparison.matches.filter(match => match.keitaro.status === 'rejected').length;
-    console.log('\n\x1b[1mДебаг інформація:\x1b[0m');
-    console.log(`Кількість конверсій відсутніх в WP: ${comparison.mismatches.onlyInKeitaro.length + comparison.rejected.keitaro.length + matchingRejected}`);
-    console.log(`З них:`);
-    console.log(`- Активних: ${comparison.mismatches.onlyInKeitaro.length}`);
-    console.log(`- Відхилених (унікальних): ${comparison.rejected.keitaro.length}`);
-    console.log(`- Відхилених (що є в WP): ${matchingRejected}`);
-}
-exports.displayComparisonResults = displayComparisonResults;

package/lib/keitaro-utils.d.ts

@@ -1,2 +0,0 @@
-import { ConversionComparison } from './utils/comparing';
-export declare function displayComparisonResults(comparison: ConversionComparison): void;