@bprotsyk/aso-core 2.1.42 → 2.1.43

package/lib/general/domain.d.ts

@@ -91,6 +91,7 @@ export declare const DomainSchema: Schema<any, Model<any, any, any, any, any>, {
     caption?: string | undefined;
     title?: string | undefined;
     proxied?: boolean | undefined;
+    ip?: string | undefined;
     namecheapId?: string | undefined;
     status?: string | undefined;
     isUpdating?: boolean | undefined;
@@ -100,7 +101,6 @@ export declare const DomainSchema: Schema<any, Model<any, any, any, any, any>, {
     originalDNSHost?: string | undefined;
     createdAt?: number | undefined;
     expiresAt?: number | undefined;
-    ip?: string | undefined;
     subdomain?: string | undefined;
     mxRecord?: string | undefined;
     target?: string | undefined;

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

@@ -0,0 +1,26 @@
+export declare enum KeitaroClicksInterval {
+    TODAY = "today",
+    YESTERDAY = "yesterday",
+    SEVEN_DAYS_AGO = "7_days_ago",
+    FIRST_DAY_OF_THIS_WEEK = "first_day_of_this_week",
+    ONE_MONTH_AGO = "1_month_ago",
+    FIRST_DAY_OF_THIS_MONTH = "first_day_of_this_month",
+    ONE_YEAR_AGO = "1_year_ago",
+    FIRST_DAY_OF_THIS_YEAR = "first_day_of_this_year",
+    ALL_TIME = "all_time"
+}
+export interface IKeitaroClicksRangeRequest {
+    interval: KeitaroClicksInterval;
+}
+export interface IKeitaroClicksFilterRequest {
+    name: string;
+    operator: string;
+    expression: string | number;
+}
+export interface IKeitaroClicksRequest {
+    range: IKeitaroClicksRangeRequest;
+    limit?: number;
+    offset?: number;
+    columns?: string[];
+    filters?: IKeitaroClicksFilterRequest[];
+}

package/lib/keitaro/keitaro-clicks.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeitaroClicksInterval = void 0;
+var KeitaroClicksInterval;
+(function (KeitaroClicksInterval) {
+    KeitaroClicksInterval["TODAY"] = "today";
+    KeitaroClicksInterval["YESTERDAY"] = "yesterday";
+    KeitaroClicksInterval["SEVEN_DAYS_AGO"] = "7_days_ago";
+    KeitaroClicksInterval["FIRST_DAY_OF_THIS_WEEK"] = "first_day_of_this_week";
+    KeitaroClicksInterval["ONE_MONTH_AGO"] = "1_month_ago";
+    KeitaroClicksInterval["FIRST_DAY_OF_THIS_MONTH"] = "first_day_of_this_month";
+    KeitaroClicksInterval["ONE_YEAR_AGO"] = "1_year_ago";
+    KeitaroClicksInterval["FIRST_DAY_OF_THIS_YEAR"] = "first_day_of_this_year";
+    KeitaroClicksInterval["ALL_TIME"] = "all_time";
+})(KeitaroClicksInterval = exports.KeitaroClicksInterval || (exports.KeitaroClicksInterval = {}));

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

@@ -4,6 +4,7 @@ import { IKeitaroCampaign } from "../../keitaro/keitaro-campaign";
 import { IKeitaroDomain } from "../../keitaro/keitaro-domain";
 import { IApp } from "../../app/app";
 import { IKeitaroOffer } from "index";
+import { IKeitaroClicksRequest, KeitaroClicksInterval } from "../../keitaro/keitaro-clicks";
 export interface IKeitaroOffersFilter {
     keitaroId?: number;
     name?: string;
@@ -17,7 +18,7 @@ declare function getAllOffers(): Promise<IKeitaroOffer[]>;
 declare function findKeitaroOffers(filter: IKeitaroOffersFilter): Promise<IKeitaroOffer[]>;
 declare function getOfferByKeitaroId(id: number): Promise<IKeitaroOffer>;
 declare function updateOffer(offer: any): Promise<IKeitaroOffer>;
-declare function addOfferToKeitaro(offer: IOffer, affiliateId: number, link: string, avoidGroup?: number, groupId?: number): Promise<void>;
+declare function addOffersToKeitaro(offers: IOffer[], affiliateId: number, links: string[], avoidGroup?: number, groupId?: number): Promise<void>;
 declare function createCampaign(campaignData: Partial<IKeitaroCampaign>): Promise<IKeitaroCampaign>;
 declare function getCampaignById(id: number): Promise<IKeitaroCampaign>;
 export declare function upsertStreamToCampaign(campaign: IKeitaroCampaign, stream: Partial<IKeitaroStream>): Promise<void>;
@@ -27,13 +28,14 @@ declare function changeCampaignsGroup(fromId: number, toId: number, exceptForCam
 declare function getDomains(onlyActive?: boolean): Promise<IKeitaroDomain[]>;
 declare function getProfitForTimeRange(from: number, to: number): Promise<number>;
 declare function fixBrokenClickCosts(startDate: string, endDate: string): Promise<void>;
+declare function getClicks(request: IKeitaroClicksRequest | KeitaroClicksInterval): Promise<any>;
 export declare const KeitaroService: {
     getStreamsByCampaignId: typeof getStreamsByCampaignId;
     updateCampaign: typeof updateCampaign;
     getAllCampaigns: typeof getAllCampaigns;
     getAllOffers: typeof getAllOffers;
     cloneStreams: typeof cloneStreams;
-    addOfferToKeitaro: typeof addOfferToKeitaro;
+    addOffersToKeitaro: typeof addOffersToKeitaro;
     getOfferByKeitaroId: typeof getOfferByKeitaroId;
     getDomains: typeof getDomains;
     createCampaign: typeof createCampaign;
@@ -43,6 +45,7 @@ export declare const KeitaroService: {
     updateOffer: typeof updateOffer;
     changeCampaignsGroup: typeof changeCampaignsGroup;
     getProfitForTimeRange: typeof getProfitForTimeRange;
+    getClicks: typeof getClicks;
     cloneDCampaign: typeof cloneDCampaign;
     findKeitaroOffers: typeof findKeitaroOffers;
     fixBrokenClickCosts: typeof fixBrokenClickCosts;

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

@@ -55,27 +55,34 @@ async function cloneStreams(originalCampaignId, streamPositionsToClone, campaign
 async function updateCampaign(id, payload) {
     await http_1.default.put(`campaigns/${id}`, payload);
 }
-async function createStreamForMatchingCampaigns(streamPartialPayload, offerId, campaignRegExp, avoidGroup) {
-    // Get a list of all campaigns
+async function createStreamForMatchingCampaigns(streamPayloads, campaignRegExp, avoidGroup) {
+    // Get all campaigns once
     const allCampaigns = await getAllCampaigns();
-    // Filter the campaigns by the given RegExp
-    const matchingCampaigns = allCampaigns.filter(campaign => (avoidGroup ? campaign.group_id != avoidGroup : true) && campaignRegExp.exec(campaign.name));
-    // console.log(matchingCampaigns)
-    // For each matching campaign, clone the streams
+    const matchingCampaigns = allCampaigns.filter(campaign => (avoidGroup ? campaign.group_id != avoidGroup : true) &&
+        campaignRegExp.exec(campaign.name));
+    // Get all streams for matching campaigns once
+    const campaignStreams = new Map();
+    for (const campaign of matchingCampaigns) {
+        campaignStreams.set(campaign.id, await getStreamsByCampaignId(campaign.id));
+    }
+    // Process each campaign
     for (const matchingCampaign of matchingCampaigns) {
-        let streams = await getStreamsByCampaignId(matchingCampaign.id);
-        let identicalStream = streams.find((stream) => stream.name.includes(offerId));
-        if (identicalStream) {
-            await http_1.default.put(`streams/${identicalStream.id}`, {
-                campaign_id: matchingCampaign.id,
-                ...streamPartialPayload
-            });
-        }
-        else {
-            await http_1.default.post('streams', {
-                campaign_id: matchingCampaign.id,
-                ...streamPartialPayload
-            });
+        const streams = campaignStreams.get(matchingCampaign.id) || [];
+        // Process each stream payload
+        for (const { payload, offerId } of streamPayloads) {
+            const identicalStream = streams.find(stream => stream.name.includes(offerId));
+            if (identicalStream) {
+                await http_1.default.put(`streams/${identicalStream.id}`, {
+                    campaign_id: matchingCampaign.id,
+                    ...payload
+                });
+            }
+            else {
+                await http_1.default.post('streams', {
+                    campaign_id: matchingCampaign.id,
+                    ...payload
+                });
+            }
         }
     }
 }
@@ -120,31 +127,38 @@ function createStreamPartialPayload(keitaroOfferId, offerName, offerId, offerGeo
             }],
     };
 }
-async function addOfferToKeitaro(offer, affiliateId, link, avoidGroup, groupId) {
-    // TODO look if offer already exists by offer.name
-    let allOffers = await getAllOffers();
-    let identicalOffer = allOffers.find((o) => { return o.name.includes(offer.name); });
-    let keitaroOfferId;
-    if (identicalOffer) {
-        keitaroOfferId = identicalOffer.id;
-    }
-    else {
-        let offerPayload = {
-            name: `${offer.caption} ${offer.geo} (${offer.name})`,
-            group_id: groupId || 1,
-            action_payload: link,
-            affiliate_network_id: affiliateId,
-            country: [offer.geo],
-            action_type: "http",
-            offer_type: "external",
-            payout_auto: true,
-            payout_upsell: true,
-        };
-        const { data: keitaroOffer } = await http_1.default.post(`offers`, offerPayload);
-        keitaroOfferId = keitaroOffer.id;
+async function addOffersToKeitaro(offers, affiliateId, links, avoidGroup, groupId) {
+    const allOffers = await getAllOffers();
+    const streamPayloads = [];
+    for (let i = 0; i < offers.length; i++) {
+        const offer = offers[i];
+        const link = links[i];
+        const identicalOffer = allOffers.find(o => o.name.includes(offer.name));
+        let keitaroOfferId;
+        if (identicalOffer) {
+            keitaroOfferId = identicalOffer.id;
+        }
+        else {
+            const offerPayload = {
+                name: `${offer.caption} ${offer.geo} (${offer.name})`,
+                group_id: groupId || 1,
+                action_payload: link,
+                affiliate_network_id: affiliateId,
+                country: [offer.geo],
+                action_type: "http",
+                offer_type: "external",
+                payout_auto: true,
+                payout_upsell: true,
+            };
+            const { data: keitaroOffer } = await http_1.default.post('offers', offerPayload);
+            keitaroOfferId = keitaroOffer.id;
+        }
+        streamPayloads.push({
+            payload: createStreamPartialPayload(keitaroOfferId, offer.caption, offer.name, offer.geo),
+            offerId: offer.name
+        });
     }
-    let streamPartialPayload = createStreamPartialPayload(keitaroOfferId, offer.caption, offer.name, offer.geo);
-    await createStreamForMatchingCampaigns(streamPartialPayload, offer.name, /◈/, avoidGroup);
+    await createStreamForMatchingCampaigns(streamPayloads, /◈/, avoidGroup);
 }
 async function createCampaign(campaignData) {
     let { data: campaign } = await http_1.default.post(`/campaigns`, campaignData);
@@ -275,9 +289,18 @@ async function fixBrokenClickCosts(startDate, endDate) {
     // Make the API request to update costs
     await http_1.default.post('/clicks/update_costs', payload);
 }
+async function getClicks(request) {
+    const defaultRequest = typeof request === 'string' ? {
+        range: { interval: request }
+    } : {
+        ...request
+    };
+    const { data } = await http_1.default.post('/clicks/log', defaultRequest);
+    return data.rows;
+}
 exports.KeitaroService = {
-    getStreamsByCampaignId, updateCampaign, getAllCampaigns, getAllOffers, cloneStreams, addOfferToKeitaro, getOfferByKeitaroId, getDomains, createCampaign, getCampaignById, upsertStreamToCampaign, cloneOWCampaign,
-    updateOffer, changeCampaignsGroup, getProfitForTimeRange,
+    getStreamsByCampaignId, updateCampaign, getAllCampaigns, getAllOffers, cloneStreams, addOffersToKeitaro, getOfferByKeitaroId, getDomains, createCampaign, getCampaignById, upsertStreamToCampaign, cloneOWCampaign,
+    updateOffer, changeCampaignsGroup, getProfitForTimeRange, getClicks,
     // getProfitForTodayAndYesterday, 
     cloneDCampaign, findKeitaroOffers, fixBrokenClickCosts
 };

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

@@ -6,8 +6,8 @@ export declare let addGeosToAllRedirectCampaigns: (geosToAdd: string) => Promise
 export declare let removeGeosFromAllRedirectCampaigns: (geoToRemove: string) => Promise<void>;
 export declare let prepareOWCampaignParameters: (app: IApp) => IKeitaroCampaignParameters;
 export declare function createOWStreamPartialPayload(app: IApp): Partial<IKeitaroStream>;
-export declare function createFlashCampaigns(app: IApp): Promise<{
-    tracking: IKeitaroCampaign;
-}>;
 export declare function createDirectCampaign(app: IApp): Promise<IKeitaroCampaign>;
 export declare function createOWCampaign(app: IApp): Promise<IKeitaroCampaign>;
+type PostbackStatus = 'lead' | 'sale' | 'rejected';
+export declare function sendPostbacks(subids: string[], status: PostbackStatus, payout?: number): Promise<void>;
+export {};

package/lib/utils/keitaro-utils.js

@@ -1,8 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createOWCampaign = exports.createDirectCampaign = exports.createFlashCampaigns = exports.createOWStreamPartialPayload = exports.prepareOWCampaignParameters = exports.removeGeosFromAllRedirectCampaigns = exports.addGeosToAllRedirectCampaigns = exports.TRAFFIC_SOURCE_ID_FLASH_AI = void 0;
+exports.sendPostbacks = exports.createOWCampaign = exports.createDirectCampaign = exports.createOWStreamPartialPayload = 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;
 exports.TRAFFIC_SOURCE_ID_FLASH_AI = 22;
 const UNIQUENESS_METHOD = "ip_ua";
@@ -356,25 +361,6 @@ function createOWStreamPartialPayload(app) {
     };
 }
 exports.createOWStreamPartialPayload = createOWStreamPartialPayload;
-async function createFlashCampaigns(app) {
-    // Upserting Flash Redirect campaign
-    // let redirectCampaign = await createOrFindFlashRedirectCampaign(app)
-    // console.log(`Redirect campaign name:`)
-    // console.log(`${redirectCampaign.domain}/${redirectCampaign.alias}?uid=`)
-    // Upserting necessary streams
-    // let botProtectionStream = createBPStreamPartialPayload(app)
-    // let owStream = createOWStreamPartialPayload(app)
-    // for (let stream of [botProtectionStream, owStream]) {
-    //     await KeitaroService.upsertStreamToCampaign(redirectCampaign, stream)
-    // }
-    // Upserting OW campaign
-    let owCampaign = await keitaro_service_1.KeitaroService.cloneOWCampaign(app);
-    return {
-        tracking: owCampaign,
-        // redirect: redirectCampaign
-    };
-}
-exports.createFlashCampaigns = createFlashCampaigns;
 async function createDirectCampaign(app) {
     let campaign = await keitaro_service_1.KeitaroService.cloneDCampaign(app);
     let stream = createDefenceMainStreamPartialPayload(app);
@@ -611,4 +597,72 @@ async function disableAutoCost() {
         throw error;
     }
 }
-// disableAutoCost();
+async function getClicksByIp(ip, campaignId, interval = keitaro_clicks_1.KeitaroClicksInterval.ONE_MONTH_AGO, limit = 100) {
+    const request = {
+        range: {
+            interval
+        },
+        columns: ['sub_id'],
+        filters: [
+            {
+                name: 'ip',
+                operator: 'BEGINS_WITH',
+                expression: ip
+            },
+            {
+                name: 'campaign_id',
+                operator: 'EQUALS',
+                expression: campaignId
+            }
+        ],
+        limit
+    };
+    return keitaro_service_1.KeitaroService.getClicks(request);
+}
+async function checkMultipleIPs() {
+    const ips = [
+        "88.155.31.196",
+        "176.120.63.205"
+    ];
+    let subids = [];
+    for (const ip of ips) {
+        // console.log(`\nChecking IP: ${ip}`);
+        try {
+            const clicks = await getClicksByIp(ip, 2832, keitaro_clicks_1.KeitaroClicksInterval.SEVEN_DAYS_AGO);
+            subids.push(clicks[clicks.length - 1].sub_id);
+        }
+        catch (error) { }
+        await sleep(300); // Delay to avoid rate limiting
+    }
+    return subids;
+}
+async function sendPostbacks(subids, status, payout) {
+    const baseUrl = 'https://aibprtsk.com/bab2832/postback';
+    const sendPostback = async (subid) => {
+        try {
+            let url = `${baseUrl}?subid=${subid}&status=${status}`;
+            if (payout !== undefined) {
+                url += `&payout=${payout}`;
+            }
+            const response = await axios_1.default.get(url);
+            if (response.status !== 200) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            console.log(`Postback sent successfully for subid: ${subid}`);
+        }
+        catch (error) {
+            console.error(`Failed to send postback for subid: ${subid}`, error);
+        }
+        // Add delay between requests to prevent overwhelming the server
+        await sleep(300);
+    };
+    // Process postbacks sequentially to avoid rate limiting
+    for (const subid of subids) {
+        await sendPostback(subid);
+    }
+}
+exports.sendPostbacks = sendPostbacks;
+(async () => {
+    let subids = await checkMultipleIPs();
+    await sendPostbacks(subids, 'sale', 125);
+})();

package/package.json

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

package/src/keitaro/keitaro-clicks.ts

@@ -0,0 +1,29 @@
+export enum KeitaroClicksInterval {
+    TODAY = 'today',
+    YESTERDAY = 'yesterday',
+    SEVEN_DAYS_AGO = '7_days_ago',
+    FIRST_DAY_OF_THIS_WEEK = 'first_day_of_this_week',
+    ONE_MONTH_AGO = '1_month_ago',
+    FIRST_DAY_OF_THIS_MONTH = 'first_day_of_this_month',
+    ONE_YEAR_AGO = '1_year_ago',
+    FIRST_DAY_OF_THIS_YEAR = 'first_day_of_this_year',
+    ALL_TIME = 'all_time'
+}
+
+export interface IKeitaroClicksRangeRequest {
+    interval: KeitaroClicksInterval;
+}
+
+export interface IKeitaroClicksFilterRequest {
+    name: string;
+    operator: string;
+    expression: string | number;
+}
+
+export interface IKeitaroClicksRequest {
+    range: IKeitaroClicksRangeRequest;
+    limit?: number;
+    offset?: number;
+    columns?: string[];
+    filters?: IKeitaroClicksFilterRequest[];
+} 

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

@@ -7,6 +7,7 @@ import { IApp } from "../../app/app";
 import { TRAFFIC_SOURCE_ID_FLASH_AI, prepareOWCampaignParameters } from "../../utils/keitaro-utils";
 import { convertMillisToDate, getTimestampsForTodayAndYesterday } from "../../utils/general";
 import { IKeitaroOffer } from "index";
+import { IKeitaroClicksRequest, IKeitaroClicksRangeRequest, KeitaroClicksInterval } from "../../keitaro/keitaro-clicks";
 
 export interface IKeitaroOffersFilter {
     keitaroId?: number,
@@ -71,31 +72,39 @@ async function updateCampaign(id: number, payload: Partial<IKeitaroCampaign>) {
     await keitaroApi.put(`campaigns/${id}`, payload)
 }
 
-async function createStreamForMatchingCampaigns(streamPartialPayload: any, offerId: string, campaignRegExp: RegExp, avoidGroup?: number) {
-    // Get a list of all campaigns
-    const allCampaigns = await getAllCampaigns()
-
-    // Filter the campaigns by the given RegExp
-    const matchingCampaigns = allCampaigns.filter(campaign => (avoidGroup ? campaign.group_id != avoidGroup : true) && campaignRegExp.exec(campaign.name));
-    // console.log(matchingCampaigns)
-
+async function createStreamForMatchingCampaigns(streamPayloads: { payload: any, offerId: string }[], campaignRegExp: RegExp, avoidGroup?: number) {
+    // Get all campaigns once
+    const allCampaigns = await getAllCampaigns();
+    const matchingCampaigns = allCampaigns.filter(campaign => 
+        (avoidGroup ? campaign.group_id != avoidGroup : true) && 
+        campaignRegExp.exec(campaign.name)
+    );
+
+    // Get all streams for matching campaigns once
+    const campaignStreams = new Map<number, IKeitaroStream[]>();
+    for (const campaign of matchingCampaigns) {
+        campaignStreams.set(campaign.id, await getStreamsByCampaignId(campaign.id));
+    }
 
-    // For each matching campaign, clone the streams
+    // Process each campaign
     for (const matchingCampaign of matchingCampaigns) {
-        let streams = await getStreamsByCampaignId(matchingCampaign.id)
-
-        let identicalStream = streams.find((stream) => stream.name.includes(offerId))
-
-        if (identicalStream) {
-            await keitaroApi.put(`streams/${identicalStream.id}`, {
-                campaign_id: matchingCampaign.id,
-                ...streamPartialPayload
-            });
-        } else {
-            await keitaroApi.post('streams', {
-                campaign_id: matchingCampaign.id,
-                ...streamPartialPayload
-            });
+        const streams = campaignStreams.get(matchingCampaign.id) || [];
+
+        // Process each stream payload
+        for (const { payload, offerId } of streamPayloads) {
+            const identicalStream = streams.find(stream => stream.name.includes(offerId));
+
+            if (identicalStream) {
+                await keitaroApi.put(`streams/${identicalStream.id}`, {
+                    campaign_id: matchingCampaign.id,
+                    ...payload
+                });
+            } else {
+                await keitaroApi.post('streams', {
+                    campaign_id: matchingCampaign.id,
+                    ...payload
+                });
+            }
         }
     }
 }
@@ -149,35 +158,49 @@ function createStreamPartialPayload(keitaroOfferId: number, offerName: string, o
     }
 }
 
-async function addOfferToKeitaro(offer: IOffer, affiliateId: number, link: string, avoidGroup?: number, groupId?: number) {
-    // TODO look if offer already exists by offer.name
-    let allOffers = await getAllOffers()
-    let identicalOffer = allOffers.find((o) => { return o.name.includes(offer.name) })
-
-    let keitaroOfferId
-    if (identicalOffer) {
-        keitaroOfferId = identicalOffer.id
-    } else {
-        let offerPayload = {
-            name: `${offer.caption} ${offer.geo} (${offer.name})`,
-            group_id: groupId || 1,
-            action_payload: link,
-            affiliate_network_id: affiliateId,
-            country: [offer.geo],
-            action_type: "http",
-            offer_type: "external",
-            payout_auto: true,
-            payout_upsell: true,
+async function addOffersToKeitaro(offers: IOffer[], affiliateId: number, links: string[], avoidGroup?: number, groupId?: number) {
+    const allOffers = await getAllOffers();
+    
+    const streamPayloads = [];
+    
+    for (let i = 0; i < offers.length; i++) {
+        const offer = offers[i];
+        const link = links[i];
+        
+        const identicalOffer = allOffers.find(o => o.name.includes(offer.name));
+        
+        let keitaroOfferId;
+        if (identicalOffer) {
+            keitaroOfferId = identicalOffer.id;
+        } else {
+            const offerPayload = {
+                name: `${offer.caption} ${offer.geo} (${offer.name})`,
+                group_id: groupId || 1,
+                action_payload: link,
+                affiliate_network_id: affiliateId,
+                country: [offer.geo],
+                action_type: "http",
+                offer_type: "external",
+                payout_auto: true,
+                payout_upsell: true,
+            };
+            
+            const { data: keitaroOffer } = await keitaroApi.post('offers', offerPayload);
+            keitaroOfferId = keitaroOffer.id;
         }
-
-        const { data: keitaroOffer } = await keitaroApi.post(`offers`, offerPayload);
-
-        keitaroOfferId = keitaroOffer.id
+        
+        streamPayloads.push({
+            payload: createStreamPartialPayload(
+                keitaroOfferId,
+                offer.caption,
+                offer.name,
+                offer.geo
+            ),
+            offerId: offer.name
+        });
     }
-
-    let streamPartialPayload = createStreamPartialPayload(keitaroOfferId, offer.caption, offer.name, offer.geo)
-
-    await createStreamForMatchingCampaigns(streamPartialPayload, offer.name, /◈/, avoidGroup)
+    
+    await createStreamForMatchingCampaigns(streamPayloads, /◈/, avoidGroup);
 }
 
 async function createCampaign(campaignData: Partial<IKeitaroCampaign>): Promise<IKeitaroCampaign> {
@@ -340,9 +363,21 @@ async function fixBrokenClickCosts(startDate: string, endDate: string): Promise<
     await keitaroApi.post('/clicks/update_costs', payload);
 }
 
+async function getClicks(request: IKeitaroClicksRequest | KeitaroClicksInterval) {
+    const defaultRequest: IKeitaroClicksRequest = typeof request === 'string' ? {
+        range: { interval: request }
+    } : {
+        ...request
+    };
+    
+    const { data } = await keitaroApi.post('/clicks/log', defaultRequest);
+    return data.rows;
+}
+
+
 export const KeitaroService = {
-    getStreamsByCampaignId, updateCampaign, getAllCampaigns, getAllOffers, cloneStreams, addOfferToKeitaro, getOfferByKeitaroId, getDomains, createCampaign, getCampaignById, upsertStreamToCampaign, cloneOWCampaign,
-    updateOffer, changeCampaignsGroup, getProfitForTimeRange, 
+    getStreamsByCampaignId, updateCampaign, getAllCampaigns, getAllOffers, cloneStreams, addOffersToKeitaro, getOfferByKeitaroId, getDomains, createCampaign, getCampaignById, upsertStreamToCampaign, cloneOWCampaign,
+    updateOffer, changeCampaignsGroup, getProfitForTimeRange, getClicks,
     // getProfitForTodayAndYesterday, 
     cloneDCampaign, findKeitaroOffers, fixBrokenClickCosts
 }

package/src/utils/keitaro-utils.ts

@@ -10,6 +10,8 @@ import axios from "axios"
 import { getTimestampsForTodayAndYesterday } from "../utils/general"
 import { KeitaroUtils } from "index"
 import { rename } from "fs"
+import { IKeitaroClicksRequest, KeitaroClicksInterval } from "../keitaro/keitaro-clicks"
+import { IKeitaroClicksRangeRequest } from "../keitaro/keitaro-clicks"
 
 const FLASH_REDIRECT_GROUP_ID = 82
 export const TRAFFIC_SOURCE_ID_FLASH_AI = 22
@@ -396,29 +398,6 @@ export function createOWStreamPartialPayload(app: IApp): Partial<IKeitaroStream>
     }
 }
 
-export async function createFlashCampaigns(app: IApp) {
-    // Upserting Flash Redirect campaign
-    // let redirectCampaign = await createOrFindFlashRedirectCampaign(app)
-    // console.log(`Redirect campaign name:`)
-    // console.log(`${redirectCampaign.domain}/${redirectCampaign.alias}?uid=`)
-
-    // Upserting necessary streams
-    // let botProtectionStream = createBPStreamPartialPayload(app)
-    // let owStream = createOWStreamPartialPayload(app)
-
-    // for (let stream of [botProtectionStream, owStream]) {
-    //     await KeitaroService.upsertStreamToCampaign(redirectCampaign, stream)
-    // }
-
-    // Upserting OW campaign
-    let owCampaign = await KeitaroService.cloneOWCampaign(app)
-
-    return {
-        tracking: owCampaign,
-        // redirect: redirectCampaign
-    }
-}
-
 export async function createDirectCampaign(app: IApp) {
     let campaign = await KeitaroService.cloneDCampaign(app)
 
@@ -666,17 +645,17 @@ let renameCampaigns = async () => {
 async function fixLastThreeMonthsClickCosts(): Promise<void> {
     // Get current date
     const now = new Date();
-    
+
     // Calculate date 3 months ago
     const threeMonthsAgo = new Date();
     threeMonthsAgo.setMonth(threeMonthsAgo.getMonth() - 3);
-    
+
     // Format dates to required format "YYYY-MM-DD HH:MM"
     const startDate = threeMonthsAgo.toISOString().slice(0, 10) + " 00:00";
     const endDate = now.toISOString().slice(0, 10) + " 23:59";
 
     console.log(`Fixing click costs from ${startDate} to ${endDate}`);
-    
+
     try {
         await KeitaroService.fixBrokenClickCosts(startDate, endDate);
         console.log("Successfully fixed click costs");
@@ -693,20 +672,20 @@ async function disableAutoCost(): Promise<void> {
         // Get all campaigns
         const campaigns = await KeitaroService.getAllCampaigns();
         console.log(`Disabling auto cost for ${campaigns.length} campaigns...`);
-        
+
         // Update each campaign
         for (const campaign of campaigns) {
             try {
                 await KeitaroService.updateCampaign(campaign.id, { cost_auto: false });
                 console.log(`Disabled auto cost for campaign: ${campaign.name} (ID: ${campaign.id})`);
-                
+
                 // Add a small delay to avoid overwhelming the API
                 await sleep(500);
             } catch (error) {
                 console.error(`Failed to update campaign ${campaign.name} (ID: ${campaign.id}):`, error);
             }
         }
-        
+
         console.log('Successfully disabled auto cost for all campaigns');
     } catch (error) {
         console.error('Failed to disable auto cost:', error);
@@ -714,4 +693,88 @@ async function disableAutoCost(): Promise<void> {
     }
 }
 
-// disableAutoCost();
+
+
+async function getClicksByIp(ip: string, campaignId: number, interval: KeitaroClicksInterval = KeitaroClicksInterval.ONE_MONTH_AGO, limit: number = 100): Promise<any> {
+    const request: IKeitaroClicksRequest = {
+        range: {
+            interval
+        },
+        columns: ['sub_id'],
+        filters: [
+            {
+                name: 'ip',
+                operator: 'BEGINS_WITH',
+                expression: ip
+            },
+            {
+                name: 'campaign_id',
+                operator: 'EQUALS',
+                expression: campaignId
+            }
+        ],
+
+        limit
+    };
+
+    return KeitaroService.getClicks(request);
+}
+
+async function checkMultipleIPs() {
+    const ips = [
+        "88.155.31.196",
+        "176.120.63.205"
+    ];
+    let subids = []
+    for (const ip of ips) {
+        // console.log(`\nChecking IP: ${ip}`);
+        try {
+            const clicks = await getClicksByIp(ip, 2832, KeitaroClicksInterval.SEVEN_DAYS_AGO);
+            subids.push(clicks[clicks.length - 1].sub_id)
+        } catch (error) {  }
+        await sleep(300); // Delay to avoid rate limiting
+    }
+
+    return subids
+}
+
+
+// disableAutoCost();
+
+type PostbackStatus = 'lead' | 'sale' | 'rejected';
+
+export async function sendPostbacks(subids: string[], status: PostbackStatus, payout?: number): Promise<void> {
+    const baseUrl = 'https://aibprtsk.com/bab2832/postback';
+
+    const sendPostback = async (subid: string) => {
+        try {
+            let url = `${baseUrl}?subid=${subid}&status=${status}`;
+            if (payout !== undefined) {
+                url += `&payout=${payout}`;
+            }
+
+            const response = await axios.get(url);
+            if (response.status !== 200) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+
+            console.log(`Postback sent successfully for subid: ${subid}`);
+        } catch (error) {
+            console.error(`Failed to send postback for subid: ${subid}`, error);
+        }
+
+        // Add delay between requests to prevent overwhelming the server
+        await sleep(300);
+    };
+
+    // Process postbacks sequentially to avoid rate limiting
+    for (const subid of subids) {
+        await sendPostback(subid);
+    }
+}
+
+
+(async () => {
+    let subids = await checkMultipleIPs();
+    await sendPostbacks(subids, 'sale', 125)
+})();