@bprotsyk/aso-core 2.1.142 → 2.1.180

package/lib/app/app.d.ts

@@ -1,5 +1,13 @@
 import { AppType } from "./app-type";
 import mongoose, { Document } from "mongoose";
+export interface IAppsflyerPostback {
+    campaign_id: number;
+    id: number;
+    method: "GET" | "POST";
+    statuses: string[];
+    url: string;
+    notes?: string;
+}
 export interface IApp extends Document {
     id: number;
     enabled: boolean;
@@ -34,6 +42,7 @@ export interface IApp extends Document {
     ech?: boolean;
     imageFormat: EImageFormat;
     policyPath: string;
+    postbacks?: IAppsflyerPostback[];
 }
 export declare enum EImageFormat {
     PNG = "png",
@@ -211,6 +220,28 @@ export declare const AppSchema: mongoose.Schema<any, mongoose.Model<any, any, an
     integrationVersion: IntegrationVersion;
     removeInfo: any;
     policyPath: string;
+    postbacks: mongoose.Types.DocumentArray<{
+        id: number;
+        campaign_id: number;
+        method: "GET" | "POST";
+        statuses: string[];
+        url: string;
+        notes?: string | null | undefined;
+    }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, any, {
+        id: number;
+        campaign_id: number;
+        method: "GET" | "POST";
+        statuses: string[];
+        url: string;
+        notes?: string | null | undefined;
+    }> & {
+        id: number;
+        campaign_id: number;
+        method: "GET" | "POST";
+        statuses: string[];
+        url: string;
+        notes?: string | null | undefined;
+    }>;
     name?: string | null | undefined;
     pushesEnabled?: boolean | null | undefined;
     publicationHistory?: any;
@@ -255,6 +286,28 @@ export declare const AppSchema: mongoose.Schema<any, mongoose.Model<any, any, an
     integrationVersion: IntegrationVersion;
     removeInfo: any;
     policyPath: string;
+    postbacks: mongoose.Types.DocumentArray<{
+        id: number;
+        campaign_id: number;
+        method: "GET" | "POST";
+        statuses: string[];
+        url: string;
+        notes?: string | null | undefined;
+    }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, any, {
+        id: number;
+        campaign_id: number;
+        method: "GET" | "POST";
+        statuses: string[];
+        url: string;
+        notes?: string | null | undefined;
+    }> & {
+        id: number;
+        campaign_id: number;
+        method: "GET" | "POST";
+        statuses: string[];
+        url: string;
+        notes?: string | null | undefined;
+    }>;
     name?: string | null | undefined;
     pushesEnabled?: boolean | null | undefined;
     publicationHistory?: any;
@@ -299,6 +352,28 @@ export declare const AppSchema: mongoose.Schema<any, mongoose.Model<any, any, an
     integrationVersion: IntegrationVersion;
     removeInfo: any;
     policyPath: string;
+    postbacks: mongoose.Types.DocumentArray<{
+        id: number;
+        campaign_id: number;
+        method: "GET" | "POST";
+        statuses: string[];
+        url: string;
+        notes?: string | null | undefined;
+    }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, any, {
+        id: number;
+        campaign_id: number;
+        method: "GET" | "POST";
+        statuses: string[];
+        url: string;
+        notes?: string | null | undefined;
+    }> & {
+        id: number;
+        campaign_id: number;
+        method: "GET" | "POST";
+        statuses: string[];
+        url: string;
+        notes?: string | null | undefined;
+    }>;
     name?: string | null | undefined;
     pushesEnabled?: boolean | null | undefined;
     publicationHistory?: any;

package/lib/app/app.js

@@ -215,5 +215,32 @@ exports.AppSchema = new mongoose_1.Schema({
     policyPath: {
         type: String,
         default: "none"
-    }
+    },
+    postbacks: [{
+            campaign_id: {
+                type: Number,
+                required: true
+            },
+            id: {
+                type: Number,
+                required: true
+            },
+            method: {
+                type: String,
+                enum: ["GET", "POST"],
+                required: true
+            },
+            statuses: [{
+                    type: String,
+                    required: true
+                }],
+            url: {
+                type: String,
+                required: true
+            },
+            notes: {
+                type: String,
+                required: false
+            }
+        }]
 });

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 { IAdjustEventIds, IntegrationVersion, IApp, AppSchema, PlugType, IAppKeitaroData, IExternalParams, IPlatformParams, EPlatform, AppStatus, IPublicationHistory, IRemovalInfo, EDirectType } from "./app/app";
+export { IAdjustEventIds, IntegrationVersion, IApp, AppSchema, PlugType, IAppKeitaroData, IExternalParams, IPlatformParams, EPlatform, AppStatus, IPublicationHistory, IRemovalInfo, EDirectType, IAppsflyerPostback } 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-conversions.d.ts

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,27 @@
+"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

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

package/lib/keitaro/keitaro-utils.js

@@ -0,0 +1,108 @@
+"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

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

package/lib/keitaro-utils.js

@@ -0,0 +1,136 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayComparisonResults = void 0;
+const keitaro_service_1 = require("./network/keitaro/keitaro-service");
+const keitaro_conversions_1 = require("./keitaro/keitaro-conversions");
+const path = __importStar(require("path"));
+const comparing_1 = require("./utils/comparing");
+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);
+    // Находим разницу
+    const totalDiff = keitaroTotalSum - wpTotalSum;
+    console.log('\n\x1b[1mЗагальна статистика:\x1b[0m');
+    console.log(`WP сума: $${wpTotalSum.toFixed(2)}`);
+    console.log(`Keitaro сума: $${keitaroTotalSum.toFixed(2)}`);
+    console.log(`Різниця: $${totalDiff.toFixed(2)}`);
+    // Получаем конверсии, которые есть в Keitaro, но нет в WP
+    const extraKeitaroConversions = comparison.mismatches.onlyInKeitaro
+        .filter(conv => isValidStatus(conv.status))
+        .sort((a, b) => (parseFloat(b.revenue) || 0) - (parseFloat(a.revenue) || 0));
+    // Группируем по офферам для удобства
+    const byOffer = new Map();
+    extraKeitaroConversions.forEach(conv => {
+        const offer = conv.offer || 'Unknown Offer';
+        if (!byOffer.has(offer)) {
+            byOffer.set(offer, { count: 0, sum: 0, conversions: [] });
+        }
+        const stats = byOffer.get(offer);
+        const revenue = parseFloat(conv.revenue) || 0;
+        stats.count++;
+        stats.sum += revenue;
+        stats.conversions.push(conv);
+    });
+    console.log('\n\x1b[1mКонверсії, які є в Keitaro, але відсутні в WP:\x1b[0m');
+    let totalExtraSum = 0;
+    for (const [offer, stats] of byOffer) {
+        console.log(`\n\x1b[33m${offer}:\x1b[0m`);
+        console.log(`Кількість: ${stats.count}, Сума: $${stats.sum.toFixed(2)}`);
+        stats.conversions.forEach(conv => {
+            if (conv.sub_id && conv.revenue) {
+                console.log(`  ${conv.sub_id} | ${conv.revenue}`);
+                totalExtraSum += parseFloat(conv.revenue) || 0;
+            }
+        });
+    }
+    console.log('\n\x1b[1mПідсумок:\x1b[0m');
+    console.log(`Загальна сума "зайвих" конверсій: \x1b[33m$${totalExtraSum.toFixed(2)}\x1b[0m`);
+    console.log('Це конверсії, які потрібно видалити з Keitaro, щоб суми співпадали з WP');
+}
+exports.displayComparisonResults = displayComparisonResults;
+// Self-executing function to fetch and compare conversions
+(async () => {
+    const request = {
+        range: {
+            from: '2025-01-01',
+            to: '2025-01-31',
+            timezone: 'Europe/Kyiv'
+        },
+        filters: [
+            {
+                name: 'status',
+                operator: keitaro_conversions_1.KeitaroOperator.IN_LIST,
+                expression: ['sale', 'rejected']
+            },
+            {
+                name: 'affiliate_network_id',
+                operator: keitaro_conversions_1.KeitaroOperator.EQUALS,
+                expression: 2
+            }
+        ],
+        columns: [
+            'sign', 'version', 'campaign', 'campaign_group', 'landing_group', 'offer_group',
+            'landing', 'offer', 'affiliate_network', 'ts', 'stream', 'source',
+            'x_requested_with', 'referrer', 'search_engine', 'keyword', 'click_id',
+            'sub_id', 'visitor_code', 'campaign_id', 'campaign_group_id', 'offer_group_id',
+            'landing_group_id', 'landing_id', 'offer_id', 'affiliate_network_id', 'ts_id',
+            'stream_id', 'ad_campaign_id', 'external_id', 'creative_id',
+            'sub_id_1', 'sub_id_2', 'sub_id_3', 'sub_id_4', 'sub_id_5',
+            'sub_id_6', 'sub_id_7', 'sub_id_8', 'sub_id_9', 'sub_id_10',
+            'sub_id_11', 'sub_id_12', 'sub_id_13', 'sub_id_14', 'sub_id_15',
+            'sub_id_16', 'sub_id_17', 'sub_id_18', 'sub_id_19', 'sub_id_20',
+            'sub_id_21', 'sub_id_22', 'sub_id_23', 'sub_id_24', 'sub_id_25',
+            'sub_id_26', 'sub_id_27', 'sub_id_28', 'sub_id_29', 'sub_id_30',
+            'connection_type', 'operator', 'isp', 'country_code', 'country_flag',
+            'country', 'region', 'region_code', 'city', 'language', 'device_type',
+            'user_agent', 'os_icon', 'os', 'os_version', 'browser', 'browser_version',
+            'device_model', 'browser_icon', 'ip', 'ip_mask1', 'ip_mask2', 'ipv4only',
+            'ipv6only', 'cost', 'postback_datetime', 'sale_datetime', 'click_datetime',
+            'sale_period', 'status', 'previous_status', 'original_status',
+            'previous_conversion_id', 'params', 'conversion_id', 'tid',
+            'profitability', 'revenue', 'profit'
+        ],
+        sort: [{
+                name: 'sale_datetime',
+                order: 'DESC'
+            }]
+    };
+    try {
+        const conversions = await keitaro_service_1.KeitaroService.getConversions(request);
+        const wpFilePath = path.join(process.cwd(), 'src', 'utils', 'wp-january.csv');
+        const comparison = await (0, comparing_1.compareConversions)(wpFilePath, conversions);
+        // Use our improved display function
+        displayComparisonResults(comparison);
+    }
+    catch (error) {
+        console.error('Error fetching conversions:', error);
+    }
+})();

package/lib/utils/comparing.d.ts

@@ -0,0 +1,31 @@
+export interface WPConversion {
+    status: string;
+    regDate: Date;
+    qualDate: Date;
+    approveOrRejectDate: Date;
+    project: string;
+    offerName: string;
+    sum: number;
+    currency: string;
+    geo: string;
+    subId?: string;
+    clickId: string;
+}
+export interface ConversionComparison {
+    wpConversions: WPConversion[];
+    keitaroConversions: any[];
+    matches: {
+        wp: WPConversion;
+        keitaro: any;
+    }[];
+    mismatches: {
+        onlyInWP: WPConversion[];
+        onlyInKeitaro: any[];
+    };
+    rejected: {
+        wp: WPConversion[];
+        keitaro: any[];
+    };
+}
+export declare function parseWPConversions(filePath: string): Promise<WPConversion[]>;
+export declare function compareConversions(wpFilePath: string, keitaroConversions: any[]): Promise<ConversionComparison>;

package/lib/utils/comparing.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareConversions = exports.parseWPConversions = void 0;
+const sync_1 = require("csv-parse/sync");
+const fs = __importStar(require("fs"));
+function parseDate(dateStr) {
+    const [month, day, year] = dateStr.split('/').map(num => parseInt(num));
+    return new Date(2000 + year, month - 1, day);
+}
+async function parseWPConversions(filePath) {
+    const fileContent = fs.readFileSync(filePath, 'utf-8');
+    const records = (0, sync_1.parse)(fileContent, {
+        delimiter: ';',
+        columns: true,
+        skip_empty_lines: true
+    });
+    return records.map((record) => ({
+        status: record.Status,
+        regDate: parseDate(record.RegDate),
+        qualDate: parseDate(record.QualDate),
+        approveOrRejectDate: parseDate(record.Approve_or_Reject_Date),
+        project: record.Project,
+        offerName: record.Offer_Name,
+        sum: parseFloat(record.Sum),
+        currency: record.Currency,
+        geo: record.Geo,
+        subId: record.Sub_ID || undefined,
+        clickId: record.Click_ID
+    }));
+}
+exports.parseWPConversions = parseWPConversions;
+async function compareConversions(wpFilePath, keitaroConversions) {
+    const wpConversions = await parseWPConversions(wpFilePath);
+    const matches = [];
+    const onlyInWP = [];
+    const onlyInKeitaro = [];
+    const rejectedWP = [];
+    const rejectedKeitaro = [];
+    // Create a map of Keitaro conversions by their sub_id to match with WP's Click_ID
+    const keitaroMap = new Map(keitaroConversions.map(conv => [conv.sub_id, conv]));
+    // First, find matches and conversions only in WP
+    for (const wpConv of wpConversions) {
+        // Skip rejected conversions
+        if (wpConv.status === 'Удержан') {
+            rejectedWP.push(wpConv);
+            continue;
+        }
+        const keitaroMatch = keitaroMap.get(wpConv.clickId);
+        if (keitaroMatch) {
+            matches.push({ wp: wpConv, keitaro: keitaroMatch });
+            keitaroMap.delete(wpConv.clickId);
+        }
+        else {
+            onlyInWP.push(wpConv);
+        }
+    }
+    // Remaining conversions in keitaroMap are only in Keitaro
+    // We need to check their status before adding them to onlyInKeitaro
+    for (const [_, conv] of keitaroMap) {
+        if (conv.status === 'rejected') {
+            rejectedKeitaro.push(conv);
+        }
+        else {
+            onlyInKeitaro.push(conv);
+        }
+    }
+    return {
+        wpConversions: wpConversions.filter(conv => conv.status !== 'Удержан'),
+        keitaroConversions: keitaroConversions.filter(conv => conv.status !== 'rejected'),
+        matches,
+        mismatches: {
+            onlyInWP,
+            onlyInKeitaro
+        },
+        rejected: {
+            wp: rejectedWP,
+            keitaro: rejectedKeitaro
+        }
+    };
+}
+exports.compareConversions = compareConversions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bprotsyk/aso-core",
-  "version": "2.1.142",
+  "version": "2.1.180",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "scripts": {

package/src/app/app.ts

@@ -4,6 +4,15 @@ import mongoose, { Document, Model, model, PipelineStage, Schema, UpdateQuery, U
 import { AlternativeFullscreen } from "app/app-integration";
 const util = require("util")
 
+export interface IAppsflyerPostback {
+    campaign_id: number
+    id: number
+    method: "GET" | "POST"
+    statuses: string[]
+    url: string
+    notes?: string
+}
+
 export interface IApp extends Document {
     id: number
     enabled: boolean,
@@ -42,6 +51,7 @@ export interface IApp extends Document {
     ech?: boolean,
     imageFormat: EImageFormat
     policyPath: string
+    postbacks?: IAppsflyerPostback[]
 }
 
 export enum EImageFormat {
@@ -390,7 +400,34 @@ export const AppSchema = new Schema({
     policyPath: {
         type: String,
         default: "none"
-    }
+    },
+    postbacks: [{
+        campaign_id: {
+            type: Number,
+            required: true
+        },
+        id: {
+            type: Number,
+            required: true
+        },
+        method: {
+            type: String,
+            enum: ["GET", "POST"],
+            required: true
+        },
+        statuses: [{
+            type: String,
+            required: true
+        }],
+        url: {
+            type: String,
+            required: true
+        },
+        notes: {
+            type: String,
+            required: false
+        }
+    }]
 })
 
 

package/src/index.ts

@@ -4,7 +4,7 @@ export { IOffer, IPartner, IOfferType } from "./offers/offer"
 export { IOffersSection, OffersSectionSchema, DefaultSectionId } from "./offers/section"
 export { IAppOffersSection, ISectionsList, SectionsListSchema, IOfferState } from "./offers/list"
 
-export { IAdjustEventIds, IntegrationVersion, IApp, AppSchema, PlugType, IAppKeitaroData, IExternalParams, IPlatformParams, EPlatform, AppStatus, IPublicationHistory, IRemovalInfo, EDirectType } from "./app/app"
+export { IAdjustEventIds, IntegrationVersion, IApp, AppSchema, PlugType, IAppKeitaroData, IExternalParams, IPlatformParams, EPlatform, AppStatus, IPublicationHistory, IRemovalInfo, EDirectType, IAppsflyerPostback } 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/templates/words.txt

@@ -1,212 +0,0 @@
-apple
-banana
-cherry
-dragon
-eagle
-forest
-garden
-hammer
-island
-jungle
-kitten
-lemon
-mountain
-ocean
-pencil
-queen
-river
-sunset
-tiger
-umbrella
-village
-window
-xylophone
-yellow
-zebra
-adventure
-beautiful
-creative
-delicious
-excellent
-fantastic
-gorgeous
-handsome
-incredible
-joyful
-knowledge
-luminous
-magnificent
-natural
-outstanding
-perfect
-quality
-radiant
-spectacular
-tremendous
-ultimate
-valuable
-wonderful
-amazing
-brilliant
-charming
-delightful
-elegant
-fascinating
-graceful
-harmonious
-inspiring
-jubilant
-kindhearted
-loving
-mysterious
-nurturing
-optimistic
-peaceful
-quintessential
-radiant
-serene
-tranquil
-uplifting
-vibrant
-whimsical
-abundant
-blessed
-cheerful
-dazzling
-energetic
-friendly
-generous
-hopeful
-imaginative
-jovial
-knowledgeable
-lively
-majestic
-noble
-outstanding
-passionate
-quintessential
-remarkable
-splendid
-treasured
-unique
-valuable
-warmhearted
-authentic
-benevolent
-charismatic
-determined
-enthusiastic
-faithful
-gracious
-humble
-inspiring
-joyful
-kind
-loyal
-magnificent
-nurturing
-optimistic
-patient
-quintessential
-resilient
-sincere
-trustworthy
-understanding
-virtuous
-wise
-zealous
-abundant
-blessed
-cheerful
-dazzling
-energetic
-friendly
-generous
-hopeful
-imaginative
-jovial
-knowledgeable
-lively
-majestic
-noble
-outstanding
-passionate
-quintessential
-remarkable
-splendid
-treasured
-unique
-valuable
-warmhearted
-authentic
-benevolent
-charismatic
-determined
-enthusiastic
-faithful
-gracious
-humble
-inspiring
-joyful
-kind
-loyal
-magnificent
-nurturing
-optimistic
-patient
-quintessential
-resilient
-sincere
-trustworthy
-understanding
-virtuous
-wise
-zealous
-abundant
-blessed
-cheerful
-dazzling
-energetic
-friendly
-generous
-hopeful
-imaginative
-jovial
-knowledgeable
-lively
-majestic
-noble
-outstanding
-passionate
-quintessential
-remarkable
-splendid
-treasured
-unique
-valuable
-warmhearted
-authentic
-benevolent
-charismatic
-determined
-enthusiastic
-faithful
-gracious
-humble
-inspiring
-joyful
-kind
-loyal
-magnificent
-nurturing
-optimistic
-patient
-quintessential
-resilient
-sincere
-trustworthy
-understanding
-virtuous
-wise
-zealous