@bprotsyk/aso-core 2.1.87 → 2.1.97

package/lib/general/domain.d.ts

@@ -22,7 +22,6 @@
 /// <reference types="mongoose/types/validation" />
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
-/// <reference types="mongoose/types/inferrawdoctype" />
 import { ICloudflareDomainType } from "general/cloudflare-domain";
 import { Document, Model, Schema } from "mongoose";
 export interface IDomain extends Document {

package/lib/general/namecheap-domain.d.ts

@@ -22,7 +22,6 @@
 /// <reference types="mongoose/types/validation" />
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
-/// <reference types="mongoose/types/inferrawdoctype" />
 import { Schema, Document } from "mongoose";
 export interface INamecheapDomain {
     ID: string;

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/network/keitaro/traffle/http.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("axios").AxiosInstance;
+export default _default;

package/lib/network/keitaro/traffle/http.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+exports.default = axios_1.default.create({
+    baseURL: 'https://traffle-tech.com/admin_api/v1/',
+    headers: {
+        "Api-Key": `3e80a8fcf1ceb01a761457d017e43a0a`,
+    },
+});

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

@@ -0,0 +1,47 @@
+import { IOffer } from "../../../offers/offer";
+import { IKeitaroOffer } from "index";
+declare function getAllOffers(): Promise<IKeitaroOffer[]>;
+export declare enum ITraffleTrafficType {
+    ASO = "ASO",
+    INAPP = "INAPP"
+}
+export interface ITraffleOffer {
+    offer: Partial<IOffer>;
+    link: string;
+    partnerName: string;
+    trafficType: ITraffleTrafficType;
+}
+export interface IAffiliateNetwork {
+    id: number;
+    name: string;
+    postback_url: string;
+    offer_param: string;
+    state: "active" | "deleted";
+    template_name: string;
+    notes: string;
+    pull_api_options: string;
+    created_at: string;
+    updated_at: string;
+    offers: number;
+}
+declare function getTraffleOffersGroups(): Promise<any[]>;
+declare function createGroup(name: string, type: "campaigns" | "offers" | "landings" | "domains"): Promise<{
+    id: number;
+    name: string;
+    position: number;
+    type: string;
+}>;
+declare function getTraffleAffiliateNetworks(): Promise<IAffiliateNetwork[]>;
+declare function deleteOfferById(id: number): Promise<any>;
+declare function addOffersToTraffleKeitaro(offers: ITraffleOffer[]): Promise<void>;
+declare function updateOfferLinkById(id: number, action_payload: string | object): Promise<any>;
+export declare const TraffleKeitaroService: {
+    addOffersToTraffleKeitaro: typeof addOffersToTraffleKeitaro;
+    getTraffleOffersGroups: typeof getTraffleOffersGroups;
+    getTraffleAffiliateNetworks: typeof getTraffleAffiliateNetworks;
+    createGroup: typeof createGroup;
+    deleteOfferById: typeof deleteOfferById;
+    getAllOffers: typeof getAllOffers;
+    updateOfferLinkById: typeof updateOfferLinkById;
+};
+export {};

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

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraffleKeitaroService = exports.ITraffleTrafficType = void 0;
+const http_1 = __importDefault(require("./http"));
+const openai_1 = require("../../../network/openai/openai");
+async function getAllOffers() {
+    const { data: offers } = await http_1.default.get('offers');
+    return offers;
+}
+var ITraffleTrafficType;
+(function (ITraffleTrafficType) {
+    ITraffleTrafficType["ASO"] = "ASO";
+    ITraffleTrafficType["INAPP"] = "INAPP";
+})(ITraffleTrafficType = exports.ITraffleTrafficType || (exports.ITraffleTrafficType = {}));
+async function getTraffleOffersGroups() {
+    try {
+        const response = await http_1.default.get('/groups?type=offers');
+        console.log(response.config.url);
+        return response.data;
+    }
+    catch (error) {
+        console.error("Error fetching groups:", error);
+        throw error;
+    }
+}
+async function createGroup(name, type) {
+    try {
+        const response = await http_1.default.post('/groups', {
+            name: name,
+            type: type
+        });
+        return response.data;
+    }
+    catch (error) {
+        console.error("Error creating group:", error);
+        throw error;
+    }
+}
+async function getTraffleAffiliateNetworks() {
+    try {
+        const { data: networks } = await http_1.default.get('/affiliate_networks');
+        return networks;
+    }
+    catch (error) {
+        console.error("Error fetching affiliate networks:", error);
+        throw error;
+    }
+}
+async function findMatchingAffiliateId(affiliateNetworks, offer) {
+    let affialiateOpenAIResponse = await openai_1.OpenAI.requestOpenAI({
+        model: "o3-mini",
+        messages: [
+            { role: "user", content: `Find id of affialiate with name [${offer.partnerName}] (can be slightly different, case or typing) in [${JSON.stringify(affiliateNetworks.map(affiliateNetwork => { return { name: affiliateNetwork.name, id: affiliateNetwork.id }; }))}]; Respond with raw JSON object of affiliate network` },
+        ]
+    });
+    if (!affialiateOpenAIResponse) {
+        console.error("No response from OpenAI");
+        return 0;
+    }
+    let network = JSON.parse(affialiateOpenAIResponse);
+    console.log(network);
+    return network.id;
+}
+function findMatchingOffersGroup(offersGroups, offer) {
+    return 1037;
+}
+async function deleteOfferById(id) {
+    const response = await http_1.default.delete(`/offers/${id}/archive`);
+    return response.data;
+}
+async function addOffersToTraffleKeitaro(offers) {
+    const allOffers = await getAllOffers();
+    let offersGroups = await getTraffleOffersGroups();
+    let affiliateNetworks = await getTraffleAffiliateNetworks();
+    for (let i = 0; i < offers.length; i++) {
+        const offer = offers[i];
+        let name = `${offer.offer.caption} ${offer.offer.geo} [el trafico] ${offer.trafficType}`;
+        const identicalOffer = allOffers.find(o => o.name.includes(name));
+        let offersGroupId = findMatchingOffersGroup(offersGroups, offer);
+        let affiliateId = await findMatchingAffiliateId(affiliateNetworks, offer);
+        if (!identicalOffer) {
+            const offerPayload = {
+                name: name,
+                group_id: offersGroupId || 1,
+                action_payload: offer.link,
+                affiliate_network_id: affiliateId,
+                country: [offer.offer.geo],
+                action_type: "http",
+                offer_type: "external",
+                payout_auto: true,
+                payout_upsell: true,
+            };
+            await http_1.default.post('offers', offerPayload);
+        }
+    }
+}
+async function updateOfferLinkById(id, action_payload) {
+    const updateData = { action_payload };
+    const response = await http_1.default.put(`/offers/${id}`, updateData);
+    return response.data;
+}
+exports.TraffleKeitaroService = {
+    addOffersToTraffleKeitaro, getTraffleOffersGroups, getTraffleAffiliateNetworks, createGroup, deleteOfferById, getAllOffers, updateOfferLinkById
+};

package/lib/network/openai/openai.d.ts

@@ -0,0 +1,5 @@
+declare function requestOpenAI(data: any): Promise<string | undefined>;
+export declare const OpenAI: {
+    requestOpenAI: typeof requestOpenAI;
+};
+export {};

package/lib/network/openai/openai.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAI = void 0;
+const axios_1 = __importDefault(require("axios"));
+const OPENAI_API_KEY = "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";
+async function requestOpenAI(data) {
+    try {
+        const response = await axios_1.default.post('https://api.openai.com/v1/chat/completions', data, {
+            headers: {
+                Authorization: `Bearer ${OPENAI_API_KEY}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: 120000,
+            responseType: 'json',
+        });
+        return response.data.choices[0].message.content;
+    }
+    catch (e) {
+        console.error(e);
+    }
+}
+exports.OpenAI = {
+    requestOpenAI
+};

package/lib/offers/list.d.ts

@@ -22,10 +22,10 @@
 /// <reference types="mongoose/types/validation" />
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
-/// <reference types="mongoose/types/inferrawdoctype" />
 import { Schema } from "mongoose";
 export interface ISectionsList {
     id: number;
+    name: string;
     content: IAppOffersSection[];
 }
 export interface IOfferState {
@@ -40,6 +40,7 @@ export interface IAppOffersSection {
 }
 export declare const SectionsListSchema: Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, {
     id: number;
+    name: string;
     content: import("mongoose").Types.DocumentArray<{
         prototype?: {
             constructor: {
@@ -172,6 +173,7 @@ export declare const SectionsListSchema: Schema<any, import("mongoose").Model<an
     }>;
 }, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
     id: number;
+    name: string;
     content: import("mongoose").Types.DocumentArray<{
         prototype?: {
             constructor: {
@@ -304,6 +306,7 @@ export declare const SectionsListSchema: Schema<any, import("mongoose").Model<an
     }>;
 }>> & import("mongoose").FlatRecord<{
     id: number;
+    name: string;
     content: import("mongoose").Types.DocumentArray<{
         prototype?: {
             constructor: {

package/lib/offers/list.js

@@ -8,5 +8,9 @@ exports.SectionsListSchema = new mongoose_1.Schema({
         unique: true,
         required: true
     },
+    name: {
+        type: String,
+        required: true
+    },
     content: [Object],
 });

package/lib/offers/offer.d.ts

@@ -22,7 +22,6 @@
 /// <reference types="mongoose/types/validation" />
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
-/// <reference types="mongoose/types/inferrawdoctype" />
 import { Document, Model, Schema } from "mongoose";
 export interface IOffer extends Document {
     id: number;

package/lib/offers/section.d.ts

@@ -22,7 +22,6 @@
 /// <reference types="mongoose/types/validation" />
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
-/// <reference types="mongoose/types/inferrawdoctype" />
 import { Schema } from "mongoose";
 export interface IOffersSection {
     id: number;

package/lib/panel/user.d.ts

@@ -22,7 +22,6 @@
 /// <reference types="mongoose/types/validation" />
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
-/// <reference types="mongoose/types/inferrawdoctype" />
 import { Document, Schema } from "mongoose";
 export declare enum PanelUserAccessScope {
     ADMIN = 0,

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/lib/utils/keitaro-utils.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendPostbacks = exports.createOWCampaign = exports.createDirectCampaign = exports.prepareOWCampaignParameters = exports.removeGeosFromAllRedirectCampaigns = exports.addGeosToAllRedirectCampaigns = exports.TRAFFIC_SOURCE_ID_FLASH_AI = void 0;
 const keitaro_service_1 = require("../network/keitaro/keitaro-service");
-const sleep = require('sleep-promise');
 const axios_1 = __importDefault(require("axios"));
 const keitaro_clicks_1 = require("../keitaro/keitaro-clicks");
 const FLASH_REDIRECT_GROUP_ID = 82;
@@ -59,6 +58,10 @@ const COST_CURRENCY_USD = "USD";
 //         offerIdParameterName: "i",
 //     }
 // } as IFlashApp
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+``;
 let addGeosToAllRedirectCampaigns = async (geosToAdd) => {
     let allCampaigns = await keitaro_service_1.KeitaroService.getAllCampaigns();
     let regexp = new RegExp(`^F #`);

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

@@ -0,0 +1 @@
+export {};

package/lib/utils/traffle-keitaro-utils.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sleep = require('sleep-promise');
+const traffle_keitaro_service_1 = require("../network/keitaro/traffle/traffle-keitaro-service");
+(async () => {
+    await traffle_keitaro_service_1.TraffleKeitaroService.addOffersToTraffleKeitaro([
+    // {
+    //     offer: {
+    //         caption: "4rabet (aviator)",
+    //         geo: "IN"
+    //     },
+    //     link: "https://click.traffprogo7.com/GUU0LPNx?landing=684&sub_id3=aviator",
+    //     partnerName: "4rabet",
+    //     trafficType: ITraffleTrafficType.ASO
+    // },
+    // {
+    //     offer: {
+    //         caption: "4rabet (regpage)",
+    //         geo: "IN"
+    //     },
+    //     link: "https://click.traffprogo7.com/GUU0LPNx?landing=54&sub_id3=reg_form",
+    //     partnerName: "4rabet",
+    //     trafficType: ITraffleTrafficType.ASO
+    // },
+    // {
+    //     offer: {
+    //         caption: "4rabet (chicken #1)",
+    //         geo: "IN"
+    //     },
+    //     link: "https://click.traffprogo7.com/GUU0LPNx?landing=1803&sub_id3=chicken1",
+    //     partnerName: "4rabet",
+    //     trafficType: ITraffleTrafficType.ASO
+    // },
+    // {
+    //     offer: {
+    //         caption: "4rabet (chicken #2)",
+    //         geo: "IN"
+    //     },
+    //     link: "https://click.traffprogo7.com/GUU0LPNx?landing=2689&sub_id3=chicken2",
+    //     partnerName: "4rabet",
+    //     trafficType: ITraffleTrafficType.ASO
+    // }
+    ]);
+    // await TraffleKeitaroService.deleteOfferById(2070)
+    await traffle_keitaro_service_1.TraffleKeitaroService.updateOfferLinkById(2074, "https://click.traffprogo7.com/GUU0LPNx?landing=2689&sub_id3=chicken");
+    // await TraffleKeitaroService.updateOfferLinkById(2073, "https://click.traffprogo7.com/GUU0LPNx?landing=1803&sub_id3=chicken")
+    let offers = await traffle_keitaro_service_1.TraffleKeitaroService.getAllOffers();
+    console.log(offers);
+})();
+// Offers group: { name: '[from] El Trafico', position: 79, type: 'offers', id: 1037 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bprotsyk/aso-core",
-  "version": "2.1.87",
+  "version": "2.1.97",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "scripts": {
@@ -8,6 +8,7 @@
     "build": "tsc",
     "test": "echo \"Error: no test specified\" && exit 1",
     "keitaro": "tsc; node lib/utils/keitaro-utils.js",
+    "traffle": "tsc; node lib/utils/traffle-keitaro-utils.js",
     "server": "tsc; node lib/utils/server-util.js"
   },
   "author": "bprotsyk",

package/src/network/keitaro/traffle/http.ts

@@ -0,0 +1,8 @@
+import axios from "axios";
+
+export default axios.create({
+    baseURL: 'https://traffle-tech.com/admin_api/v1/',
+    headers: {
+        "Api-Key": `3e80a8fcf1ceb01a761457d017e43a0a`,
+    },
+});

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

@@ -0,0 +1,152 @@
+import { IKeitaroStream } from "../../../keitaro/keitaro-stream";
+import { IOffer } from "../../../offers/offer"
+import keitaroApi from "./http"
+import { IKeitaroCampaign } from "../../../keitaro/keitaro-campaign";
+import { IKeitaroDomain } from "../../../keitaro/keitaro-domain";
+import { EPlatform, getPlatformName, IApp } from "../../../app/app";
+import { TRAFFIC_SOURCE_ID_FLASH_AI, prepareOWCampaignParameters } from "../../../utils/keitaro-utils";
+import { convertMillisToDate, getTimestampsForTodayAndYesterday } from "../../../utils/general";
+import { IKeitaroOffer, IKeitaroOffersFilter } from "index";
+import { IKeitaroClicksRequest, IKeitaroClicksRangeRequest, KeitaroClicksInterval } from "../../../keitaro/keitaro-clicks";
+import { OpenAI } from "../../../network/openai/openai";
+import { off } from "process";
+
+async function getAllOffers(): Promise<IKeitaroOffer[]> {
+    const { data: offers } = await keitaroApi.get<IKeitaroOffer[]>('offers')
+
+    return offers
+}
+
+export enum ITraffleTrafficType {
+    ASO = "ASO",
+    INAPP = "INAPP"
+}
+
+export interface ITraffleOffer {
+    offer: Partial<IOffer>,
+    link: string,
+    partnerName: string,
+    trafficType: ITraffleTrafficType
+}
+
+export interface IAffiliateNetwork {
+    id: number;
+    name: string;
+    postback_url: string;
+    offer_param: string;
+    state: "active" | "deleted";
+    template_name: string;
+    notes: string;
+    pull_api_options: string;
+    created_at: string;
+    updated_at: string;
+    offers: number;
+}
+
+async function getTraffleOffersGroups(): Promise<any[]> {
+    try {
+        const response  = await keitaroApi.get('/groups?type=offers');
+        console.log(response.config.url)
+        return response.data;
+    } catch (error) {
+        console.error("Error fetching groups:", error);
+        throw error;
+    }
+}
+
+
+async function createGroup(name: string, type: "campaigns" | "offers" | "landings" | "domains"): Promise<{ id: number, name: string, position: number, type: string }> {
+    try {
+        const response = await keitaroApi.post('/groups', {
+            name: name,
+            type: type
+        });
+
+        return response.data;
+    } catch (error) {
+        console.error("Error creating group:", error);
+        throw error;
+    }
+}
+
+async function getTraffleAffiliateNetworks(): Promise<IAffiliateNetwork[]> {
+    try {
+        const { data: networks } = await keitaroApi.get<IAffiliateNetwork[]>('/affiliate_networks');
+        return networks;
+    } catch (error) {
+        console.error("Error fetching affiliate networks:", error);
+        throw error;
+    }
+}
+
+async function findMatchingAffiliateId(affiliateNetworks: IAffiliateNetwork[], offer: ITraffleOffer): Promise<number> {
+    let affialiateOpenAIResponse = await OpenAI.requestOpenAI({
+        model: "o3-mini",
+        messages: [
+            { role: "user", content: `Find id of affialiate with name [${offer.partnerName}] (can be slightly different, case or typing) in [${JSON.stringify(affiliateNetworks.map(affiliateNetwork => {return {name: affiliateNetwork.name, id: affiliateNetwork.id}}))}]; Respond with raw JSON object of affiliate network`},
+        ]
+    })
+
+    if (!affialiateOpenAIResponse){
+        console.error("No response from OpenAI")
+        return 0
+    }
+
+    let network: { id: number, name: string } = JSON.parse(affialiateOpenAIResponse)
+
+    console.log(network)
+    return network.id
+}
+
+function findMatchingOffersGroup(offersGroups: any[], offer: ITraffleOffer): number | null {
+    return 1037;
+}
+
+async function deleteOfferById(id: number): Promise<any> {
+    const response = await keitaroApi.delete(`/offers/${id}/archive`);
+    return response.data;
+}
+
+async function addOffersToTraffleKeitaro(offers: ITraffleOffer[]) {
+    const allOffers = await getAllOffers();
+    
+    let offersGroups = await getTraffleOffersGroups()
+    let affiliateNetworks = await getTraffleAffiliateNetworks()
+    
+    for (let i = 0; i < offers.length; i++) {
+        const offer = offers[i];
+
+        let name = `${offer.offer.caption} ${offer.offer.geo} [el trafico] ${offer.trafficType}`
+        
+        const identicalOffer = allOffers.find(o => o.name.includes(name));
+
+        let offersGroupId = findMatchingOffersGroup(offersGroups, offer)
+        let affiliateId = await findMatchingAffiliateId(affiliateNetworks, offer)
+        if (!identicalOffer) {
+            const offerPayload = {
+                name: name,
+                group_id: offersGroupId || 1,
+                action_payload: offer.link,
+                affiliate_network_id: affiliateId,
+                country: [offer.offer.geo],
+                action_type: "http",
+                offer_type: "external",
+                payout_auto: true,
+                payout_upsell: true,
+            };
+            
+            await keitaroApi.post('offers', offerPayload);
+        }
+    }
+}
+
+async function updateOfferLinkById(id: number, action_payload: string | object): Promise<any> {
+    const updateData = { action_payload };
+    const response = await keitaroApi.put(`/offers/${id}`, updateData);
+    return response.data;
+}
+
+
+export const TraffleKeitaroService = {
+    addOffersToTraffleKeitaro, getTraffleOffersGroups, getTraffleAffiliateNetworks, createGroup, deleteOfferById, getAllOffers, updateOfferLinkById
+}

package/src/network/openai/openai.ts

@@ -0,0 +1,26 @@
+import axios from "axios";
+
+const OPENAI_API_KEY = "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";
+
+async function requestOpenAI(
+    data: any,
+): Promise<string | undefined> {
+    try {
+        const response = await axios.post('https://api.openai.com/v1/chat/completions', data, {
+            headers: {
+                Authorization: `Bearer ${OPENAI_API_KEY}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: 120000,
+            responseType: 'json',
+        })
+
+        return response.data.choices[0].message.content
+    } catch (e) {
+        console.error(e)
+    }
+}
+
+export const OpenAI = {
+    requestOpenAI
+}

package/src/offers/list.ts

@@ -2,6 +2,7 @@ import { Schema } from "mongoose"
 
 export interface ISectionsList {
     id: number
+    name: string
     content: IAppOffersSection[]
 }
 
@@ -21,5 +22,9 @@ export const SectionsListSchema = new Schema({
         unique: true,
         required: true
     },
+    name: {
+        type: String,
+        required: true
+    },
     content: [Object],
 })

package/src/utils/keitaro-utils.ts

@@ -4,7 +4,6 @@ import { AppType } from "../app/app-type"
 import { IKeitaroCampaign, IKeitaroCampaignParameters } from "../keitaro/keitaro-campaign"
 import { IKeitaroDomain } from "../keitaro/keitaro-domain"
 import { KeitaroService } from "../network/keitaro/keitaro-service"
-const sleep = require('sleep-promise');
 import * as util from 'util';
 import axios from "axios"
 import { getTimestampsForTodayAndYesterday } from "../utils/general"
@@ -68,6 +67,10 @@ const COST_CURRENCY_USD = "USD"
 //     }
 // } as IFlashApp
 
+function sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}``
+
 export let addGeosToAllRedirectCampaigns = async (geosToAdd: string) => {
     let allCampaigns = await KeitaroService.getAllCampaigns()
 
@@ -409,8 +412,8 @@ export let prepareOWCampaignParameters = (app: IApp): IKeitaroCampaignParameters
             "placeholder": "",
             "alias": "offer_id"
         },
-   
-        
+
+
     }
 }
 
@@ -477,7 +480,7 @@ export async function createDirectCampaign(app: IApp) {
     return campaign
 }
 
-export async function createOWCampaign(app: IApp, platform?: EPlatform ) {
+export async function createOWCampaign(app: IApp, platform?: EPlatform) {
     let owCampaign = await KeitaroService.cloneOWCampaign(app, platform)
 
     return owCampaign
@@ -800,7 +803,7 @@ async function checkMultipleIPs() {
         try {
             const clicks = await getClicksByIp(ip, 2832, KeitaroClicksInterval.SEVEN_DAYS_AGO);
             subids.push(clicks[clicks.length - 1].sub_id)
-        } catch (error) {  }
+        } catch (error) { }
         await sleep(300); // Delay to avoid rate limiting
     }
 

package/src/utils/traffle-keitaro-utils.ts

@@ -0,0 +1,67 @@
+import { IKeitaroStream } from "../keitaro/keitaro-stream"
+import { EPlatform, IApp, PlugType, } from "../app/app"
+import { AppType } from "../app/app-type"
+import { IKeitaroCampaign, IKeitaroCampaignParameters } from "../keitaro/keitaro-campaign"
+import { IKeitaroDomain } from "../keitaro/keitaro-domain"
+import { KeitaroService } from "../network/keitaro/keitaro-service"
+const sleep = require('sleep-promise');
+import * as util from 'util';
+import axios from "axios"
+import { getTimestampsForTodayAndYesterday } from "./general"
+import { KeitaroUtils } from "index"
+import { rename } from "fs"
+import { IKeitaroClicksRequest, KeitaroClicksInterval } from "../keitaro/keitaro-clicks"
+import { IKeitaroClicksRangeRequest } from "../keitaro/keitaro-clicks"
+import { ITraffleTrafficType, TraffleKeitaroService } from "../network/keitaro/traffle/traffle-keitaro-service"
+import { OpenAI } from "../network/openai/openai"
+
+(async () => {
+    await TraffleKeitaroService.addOffersToTraffleKeitaro([
+        // {
+        //     offer: {
+        //         caption: "4rabet (aviator)",
+        //         geo: "IN"
+        //     },
+        //     link: "https://click.traffprogo7.com/GUU0LPNx?landing=684&sub_id3=aviator",
+        //     partnerName: "4rabet",
+        //     trafficType: ITraffleTrafficType.ASO
+        // },
+        // {
+        //     offer: {
+        //         caption: "4rabet (regpage)",
+        //         geo: "IN"
+        //     },
+        //     link: "https://click.traffprogo7.com/GUU0LPNx?landing=54&sub_id3=reg_form",
+        //     partnerName: "4rabet",
+        //     trafficType: ITraffleTrafficType.ASO
+        // },
+        // {
+        //     offer: {
+        //         caption: "4rabet (chicken #1)",
+        //         geo: "IN"
+        //     },
+        //     link: "https://click.traffprogo7.com/GUU0LPNx?landing=1803&sub_id3=chicken1",
+        //     partnerName: "4rabet",
+        //     trafficType: ITraffleTrafficType.ASO
+        // },
+        // {
+        //     offer: {
+        //         caption: "4rabet (chicken #2)",
+        //         geo: "IN"
+        //     },
+        //     link: "https://click.traffprogo7.com/GUU0LPNx?landing=2689&sub_id3=chicken2",
+        //     partnerName: "4rabet",
+        //     trafficType: ITraffleTrafficType.ASO
+        // }
+    ])
+
+    // await TraffleKeitaroService.deleteOfferById(2070)
+
+    await TraffleKeitaroService.updateOfferLinkById(2074, "https://click.traffprogo7.com/GUU0LPNx?landing=2689&sub_id3=chicken")
+    // await TraffleKeitaroService.updateOfferLinkById(2073, "https://click.traffprogo7.com/GUU0LPNx?landing=1803&sub_id3=chicken")
+
+    let offers = await TraffleKeitaroService.getAllOffers()
+    console.log(offers)
+})();
+
+// Offers group: { name: '[from] El Trafico', position: 79, type: 'offers', id: 1037 }