@bprotsyk/aso-core 2.1.223 → 2.1.225

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

@@ -3,13 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KeitaroService = void 0;
+exports.KeitaroService = exports.upsertStreamToCampaign = void 0;
 const http_1 = __importDefault(require("./http"));
 const app_1 = require("../../app/app");
-// Default group IDs
-const DEFAULT_OFFERS_GROUP_ID = 107;
-const DEFAULT_CAMPAIGNS_GROUP_ID = 106;
-// Basic campaign operations
+const keitaro_utils_1 = require("../../utils/keitaro-utils");
+const general_1 = require("../../utils/general");
 async function getStreamsByCampaignId(campaignId) {
     const { data: streams } = await http_1.default.get(`campaigns/${campaignId}/streams`);
     return streams;
@@ -18,175 +16,239 @@ async function getAllCampaigns() {
     const { data: campaigns } = await http_1.default.get('campaigns');
     return campaigns;
 }
-async function getCampaignById(id) {
-    const { data: campaign } = await http_1.default.get(`/campaigns/${id}`);
-    return campaign;
+async function cloneStreams(originalCampaignId, streamPositionsToClone, campaignRegExp) {
+    // Get the original campaign's streams
+    const originalStreams = await getStreamsByCampaignId(originalCampaignId);
+    // Filter the original streams by the given stream positions to clone
+    const streamsToClone = originalStreams.filter(stream => streamPositionsToClone.includes(stream.position));
+    // Get a list of all campaigns
+    const allCampaigns = await getAllCampaigns();
+    // Filter the campaigns by the given RegExp
+    const matchingCampaigns = allCampaigns.filter(campaign => campaignRegExp.exec(campaign.name) && campaign.id != originalCampaignId);
+    // console.log(matchingCampaigns)
+    // For each matching campaign, clone the streams
+    for (const matchingCampaign of matchingCampaigns) {
+        for (const streamToClone of streamsToClone) {
+            await http_1.default.post('streams', {
+                name: streamToClone.name,
+                campaign_id: matchingCampaign.id,
+                schema: streamToClone.schema,
+                type: streamToClone.type,
+                action_type: streamToClone.action_type,
+                weight: 100,
+                offers: streamToClone.offers.map((offer) => {
+                    return {
+                        offer_id: offer.offer_id,
+                        share: 100
+                    };
+                }),
+                filters: streamToClone.filters.map((filter) => {
+                    return {
+                        name: filter.name,
+                        mode: filter.mode,
+                        payload: filter.payload
+                    };
+                }),
+            });
+        }
+    }
 }
 async function updateCampaign(id, payload) {
     await http_1.default.put(`campaigns/${id}`, payload);
 }
-async function createCampaign(campaignData) {
-    let { data: campaign } = await http_1.default.post(`/campaigns`, campaignData);
-    return campaign;
-}
-// Domain operations
-async function getDomains(onlyActive) {
-    const { data: domains } = await http_1.default.get(`/domains`);
-    return onlyActive ? domains.filter((d) => d.network_status == "active") : domains;
+async function createStreamForMatchingCampaigns(streamPayloads, campaignRegExp, avoidGroup) {
+    // 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();
+    for (const campaign of matchingCampaigns) {
+        campaignStreams.set(campaign.id, await getStreamsByCampaignId(campaign.id));
+    }
+    // Process each campaign
+    for (const matchingCampaign of matchingCampaigns) {
+        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));
+            try {
+                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
+                    });
+                }
+            }
+            catch (error) {
+                console.error(`Error updating stream ${offerId} (${payload.name}) in campaign ${matchingCampaign.id} (${matchingCampaign.name}):`, error);
+            }
+        }
+    }
 }
-// Offer operations
 async function getAllOffers() {
     const { data: offers } = await http_1.default.get('offers');
     return offers;
 }
-/**
- * Create offer in Keitaro from our IOffer
- * @param offer - Our internal IOffer object
- * @returns Keitaro offer with ID
- */
-async function createOfferInKeitaro(offer) {
-    const payload = {
-        name: `${offer.caption} ${offer.geo} (${offer.name})`,
-        group_id: DEFAULT_OFFERS_GROUP_ID,
-        action_type: 'http',
-        action_payload: offer.link,
-        affiliate_network_id: 0,
-        payout_value: 0,
-        payout_currency: 'USD',
-        payout_type: 'CPA',
-        state: offer.hidden ? 'disabled' : 'active',
-        country: [offer.geo],
-        offer_type: 'external',
-        payout_auto: true,
-        payout_upsell: true,
-    };
-    const { data: keitaroOffer } = await http_1.default.post('offers', payload);
-    return keitaroOffer;
+async function findKeitaroOffers(filter) {
+    let offers = await getAllOffers();
+    if (filter.caption)
+        offers = offers.filter((o) => o.name.includes(filter.caption));
+    if (filter.keitaroId)
+        offers = offers.filter((o) => o.id == filter.keitaroId);
+    if (filter.name)
+        offers = offers.filter((o) => o.name.includes(filter.name));
+    return offers;
 }
-// Stream operations
-async function createStream(campaignId, streamData) {
-    const { data: stream } = await http_1.default.post('streams', {
-        ...streamData,
-        campaign_id: campaignId
-    });
-    return stream;
+async function getOfferByKeitaroId(id) {
+    const { data: offer } = await http_1.default.get(`offers/${id}`);
+    return offer;
 }
-/**
- * Get all offerwall campaigns (campaigns with [◈] prefix in group 106)
- */
-async function getOfferwallCampaigns() {
-    const allCampaigns = await getAllCampaigns();
-    // Offerwall campaigns have [◈] in their name and are in group 106
-    return allCampaigns.filter(c => c.name.includes('[◈]') && c.group_id === DEFAULT_CAMPAIGNS_GROUP_ID);
+async function updateOffer(offer) {
+    const { data: o } = await http_1.default.put(`offers/${offer.id}`, offer);
+    return o;
 }
-/**
- * Add our IOffer to Keitaro and distribute to all offerwall campaigns
- * @param offer - Our internal IOffer object
- * @returns Result with Keitaro offer ID and distribution stats
- */
-async function addOfferToKeitaro(offer) {
-    // First, create the offer in Keitaro
-    const keitaroOffer = await createOfferInKeitaro(offer);
-    console.log(`Created Keitaro offer #${keitaroOffer.id}: ${keitaroOffer.name}`);
-    // Then distribute to all offerwall campaigns
-    const offerwallCampaigns = await getOfferwallCampaigns();
-    let success = 0;
-    let failed = 0;
-    const campaignNames = [];
-    for (const campaign of offerwallCampaigns) {
-        try {
-            // Check if stream with this offer already exists
-            const existingStreams = await getStreamsByCampaignId(campaign.id);
-            const streamExists = existingStreams.some(stream => stream.offers?.some(o => o.offer_id === keitaroOffer.id));
-            if (streamExists) {
-                console.log(`Stream with offer ${keitaroOffer.id} already exists in campaign ${campaign.name}`);
-                continue;
-            }
-            // Create a new stream with the offer
-            await createStream(campaign.id, {
-                name: `${offer.geo} - ${offer.caption} (${offer.name})`,
-                type: 'regular',
-                action_type: 'http',
-                weight: 100,
-                state: offer.hidden ? 'disabled' : 'active',
-                offers: [{
-                        offer_id: keitaroOffer.id,
-                        share: 100,
-                        state: 'active'
-                    }],
-                filters: [{
-                        name: 'country',
-                        mode: 'accept',
-                        payload: [offer.geo]
-                    }]
-            });
-            success++;
-            campaignNames.push(campaign.name);
+function createStreamPartialPayload(keitaroOfferId, offerName, offerId, offerGeo) {
+    return {
+        name: `${offerName} ${offerGeo} (${offerId})`,
+        schema: "landings",
+        type: "regular",
+        action_type: "http",
+        weight: 100,
+        offers: [{
+                offer_id: keitaroOfferId,
+                share: 100,
+                state: "active"
+            }],
+        filters: [{
+                name: "sub_id_15",
+                mode: "accept",
+                payload: [offerId]
+            }],
+    };
+}
+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;
         }
-        catch (error) {
-            console.error(`Failed to add offer to campaign ${campaign.name}:`, error);
-            failed++;
+        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
+        });
     }
-    return { keitaroOfferId: keitaroOffer.id, success, failed, campaigns: campaignNames };
+    await createStreamForMatchingCampaigns(streamPayloads, /◈/, avoidGroup);
+}
+async function createCampaign(campaignData) {
+    let { data: campaign } = await http_1.default.post(`/campaigns`, campaignData);
+    return campaign;
 }
-// Generate random alias for campaigns
-function generateAlias() {
-    const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
-    return Array.from({ length: 8 }, () => chars.charAt(Math.floor(Math.random() * chars.length))).join('');
+async function getCampaignById(id) {
+    const { data: campaign } = await http_1.default.get(`/campaigns/${id}`);
+    return campaign;
 }
-/**
- * Clone a campaign for an app based on integration type
- * @param app - The app to create campaign for
- * @param integrationType - OFFERWALL or DIRECT
- * @returns Keitaro data for the cloned campaign
- */
-async function cloneCampaignForApp(app, integrationType) {
-    const templateId = integrationType === app_1.IntegrationType.OFFERWALL
-        ? app_1.OFFERWALL_TEMPLATE_CAMPAIGN_ID
-        : app_1.DIRECT_TEMPLATE_CAMPAIGN_ID;
-    const campaignPrefix = integrationType === app_1.IntegrationType.OFFERWALL ? '[◈]' : '[➥]';
-    const campaignName = `#${app.id} ${campaignPrefix} ${app.name || app.bundle}`;
-    // Check if campaign already exists
-    const allCampaigns = await getAllCampaigns();
-    const existingCampaign = allCampaigns.find(c => c.name.includes(`#${app.id}`) && c.name.includes(campaignPrefix));
-    if (existingCampaign) {
-        return campaignToKeitaroData(existingCampaign);
+async function upsertStreamToCampaign(campaign, stream) {
+    let streams = await getStreamsByCampaignId(campaign.id);
+    let identicalStream = streams.find((s) => stream.name == s.name);
+    if (identicalStream) {
+        console.log(`Found identical! Name: ${stream.name}`);
+        await http_1.default.put(`streams/${identicalStream.id}`, {
+            campaign_id: campaign.id,
+            ...stream
+        });
     }
-    // Get template campaign and its streams
-    const templateCampaign = await getCampaignById(templateId);
-    const templateStreams = await getStreamsByCampaignId(templateId);
-    // Get random active domain
-    const allDomains = await getDomains(true);
-    if (!allDomains || allDomains.length === 0) {
-        throw new Error('No active domains available');
+    else {
+        await http_1.default.post('streams', {
+            campaign_id: campaign.id,
+            ...stream
+        });
     }
-    const domain = allDomains[Math.floor(Math.random() * allDomains.length)];
-    // Create campaign payload
+}
+exports.upsertStreamToCampaign = upsertStreamToCampaign;
+async function cloneOWCampaign(app, platform) {
+    let name = `#${app.id} [◈]`;
+    let platformName = platform ? (0, app_1.getPlatformName)(platform) : null;
+    const platformCampaignName = `#${app.id} [◈] (${platformName})`;
+    const generateAlias = () => {
+        const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+        return Array.from({ length: 8 }, () => chars.charAt(Math.floor(Math.random() * chars.length))).join('');
+    };
+    let allCampaigns = await getAllCampaigns();
+    let matchingCampaign = [];
+    if (platform && platform !== app_1.EPlatform.GENERAL) {
+        // Шукаємо кампанію з платформою
+        matchingCampaign = allCampaigns.filter((c) => c.name.includes(`#${app.id}`) &&
+            c.name.includes(`[◈]`) &&
+            c.name.includes(`(${platformName})`));
+    }
+    else {
+        // Шукаємо кампанію без платформи або з суфіксом
+        matchingCampaign = allCampaigns.filter((c) => c.name.includes(`#${app.id}`) &&
+            c.name.includes(`[◈]`) &&
+            !c.name.includes('('));
+    }
+    if (matchingCampaign.length > 0)
+        return matchingCampaign[0];
+    const originalCampaign = await getCampaignById(2673);
     const maxPosition = Math.max(...allCampaigns.map(c => c.position || 0));
-    const alias = generateAlias();
-    const payload = {
-        name: campaignName,
+    const originalStreams = await getStreamsByCampaignId(2673);
+    let allDomains = await exports.KeitaroService.getDomains(true);
+    if (!allDomains) {
+        throw Error(`Failed to get all domains list`);
+    }
+    const domain = allDomains[Math.floor(Math.random() * allDomains.length)];
+    const maxGroupId = Math.max(...allCampaigns.map(c => c.group_id || 0));
+    let alias = generateAlias();
+    let payload = {
+        // Унікальні поля
+        name: platformName ? platformCampaignName : name,
         alias: alias,
         domain_id: domain.id,
         position: [maxPosition + 100],
-        group_id: DEFAULT_CAMPAIGNS_GROUP_ID,
-        type: templateCampaign.type,
-        state: templateCampaign.state,
-        cost_type: templateCampaign.cost_type,
-        cost_value: templateCampaign.cost_value,
-        cost_currency: templateCampaign.cost_currency,
-        uniqueness_period: templateCampaign.uniqueness_period,
-        cookies_ttl: templateCampaign.cookies_ttl,
-        notes: templateCampaign.notes,
-        collect_clicks: templateCampaign.collect_clicks,
-        uniqueness_type: templateCampaign.uniqueness_type,
-        parameters: templateCampaign.parameters,
+        group_id: maxGroupId + 1,
+        traffic_source_id: keitaro_utils_1.TRAFFIC_SOURCE_ID_FLASH_AI,
+        parameters: (0, keitaro_utils_1.prepareOWCampaignParameters)(app),
+        // Неунікальні поля з оригінальної кампанії
+        type: originalCampaign.type,
+        state: originalCampaign.state,
+        cost_type: originalCampaign.cost_type,
+        cost_value: originalCampaign.cost_value,
+        cost_currency: originalCampaign.cost_currency,
+        uniqueness_period: originalCampaign.uniqueness_period,
+        cookies_ttl: originalCampaign.cookies_ttl,
+        notes: originalCampaign.notes,
+        collect_clicks: originalCampaign.collect_clicks,
+        uniqueness_type: originalCampaign.uniqueness_type,
     };
-    // Create the new campaign
     const newCampaign = await createCampaign(payload);
-    // Clone streams from template
-    for (const stream of templateStreams) {
+    for (const stream of originalStreams) {
         await http_1.default.post('streams', {
             name: stream.name,
             campaign_id: newCampaign.id,
@@ -208,53 +270,241 @@ async function cloneCampaignForApp(app, integrationType) {
             state: stream.state
         });
     }
-    // Get updated campaign with token
+    await http_1.default.put(`/campaigns/${newCampaign.id}`, {
+        group_id: originalCampaign.group_id
+    });
     const updatedCampaign = await getCampaignById(newCampaign.id);
-    return campaignToKeitaroData(updatedCampaign);
+    return updatedCampaign;
 }
-/**
- * Convert a Keitaro campaign to IAppKeitaroData
- */
-function campaignToKeitaroData(campaign) {
-    return {
-        trackingCampaignId: campaign.id,
-        trackingCampaignName: campaign.name,
-        trackingCampaignAlias: campaign.alias,
-        trackingDomainId: campaign.domain_id,
-        trackingDomainName: campaign.domain || '',
-        campingToken: campaign.token,
-        trackingParams: {
-            naming: campaign.parameters?.sub_id_15?.name || 'naming',
-            firebase_app_instance_id: campaign.parameters?.sub_id_11?.name || 'firebase_app_instance_id',
-            firebase_user_id: campaign.parameters?.sub_id_12?.name || 'firebase_user_id',
-            firebase_device_language_code: campaign.parameters?.sub_id_13?.name || 'firebase_device_language_code',
-            firebase_push_token: campaign.parameters?.sub_id_14?.name || 'firebase_push_token',
-            bundle_id: campaign.parameters?.sub_id_16?.name || 'bundle_id',
-            advertising_id: campaign.parameters?.sub_id_17?.name || 'advertising_id',
-            appsflyer_device_id: campaign.parameters?.sub_id_18?.name || 'appsflyer_device_id',
-            campaign: campaign.parameters?.sub_id_20?.name || 'campaign',
+async function cloneDirectCampaign(app, platform, addDefaultStreams) {
+    let name = `#${app.id} [➥]`;
+    let platformName = platform ? (0, app_1.getPlatformName)(platform) : null;
+    const platformCampaignName = `#${app.id} [➥] (${platformName})`;
+    const generateAlias = () => {
+        const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+        return Array.from({ length: 8 }, () => chars.charAt(Math.floor(Math.random() * chars.length))).join('');
+    };
+    let allCampaigns = await getAllCampaigns();
+    let matchingCampaign = [];
+    if (platform && platform !== app_1.EPlatform.GENERAL) {
+        // Для конкретної платформи
+        const platformName = (0, app_1.getPlatformName)(platform);
+        matchingCampaign = allCampaigns.filter((c) => {
+            // Точна перевірка ID з межами слів
+            const idPattern = new RegExp(`#${app.id}\\b`);
+            const hasId = idPattern.test(c.name);
+            // Перевіряємо наявність стрілки (може бути в комбінації з іншими символами)
+            const hasArrow = c.name.includes('➥');
+            // Перевіряємо наявність платформи в дужках в кінці назви
+            const platformPattern = new RegExp(`\\(.*${platformName}.*\\)\\s*$`);
+            const hasPlatform = platformPattern.test(c.name);
+            return hasId && hasArrow && hasPlatform;
+        });
+    }
+    else {
+        // Для General платформи
+        matchingCampaign = allCampaigns.filter((c) => {
+            // Точна перевірка ID з межами слів
+            const idPattern = new RegExp(`#${app.id}\\b`);
+            const hasId = idPattern.test(c.name);
+            // Перевіряємо наявність стрілки (може бути в комбінації з іншими символами)
+            const hasArrow = c.name.includes('➥');
+            // Перевіряємо відсутність платформи в дужках в кінці
+            // Дозволяємо будь-які інші дужки (як для гео або опису)
+            const noPlatformAtEnd = !/\(.*(?:iOS|Android|Desktop|Mobile).*\)\s*$/.test(c.name);
+            return hasId && hasArrow && noPlatformAtEnd;
+        });
+    }
+    if (matchingCampaign.length > 0) {
+        const existingCampaign = matchingCampaign[0];
+        // Якщо addDefaultStreams === true, додаємо потоки до існуючої кампанії
+        if (addDefaultStreams) {
+            const originalStreams = await getStreamsByCampaignId(3175);
+            const existingStreams = await getStreamsByCampaignId(existingCampaign.id);
+            for (const stream of originalStreams) {
+                // Перевіряємо чи потік вже існує
+                const existingStream = existingStreams.find(s => s.name === stream.name);
+                if (!existingStream) {
+                    await http_1.default.post('streams', {
+                        name: stream.name,
+                        campaign_id: existingCampaign.id,
+                        schema: stream.schema,
+                        type: stream.type,
+                        action_type: stream.action_type,
+                        weight: stream.weight,
+                        offers: stream.offers.map((offer) => ({
+                            offer_id: offer.offer_id,
+                            share: offer.share,
+                            state: offer.state
+                        })),
+                        filters: stream.filters.map((filter) => ({
+                            name: filter.name,
+                            mode: filter.mode,
+                            payload: filter.payload
+                        })),
+                        position: stream.position,
+                        state: stream.state
+                    });
+                }
+            }
         }
+        return existingCampaign;
+    }
+    const originalCampaign = await getCampaignById(3175);
+    const maxPosition = Math.max(...allCampaigns.map(c => c.position || 0));
+    const originalStreams = await getStreamsByCampaignId(3175);
+    let allDomains = await exports.KeitaroService.getDomains(true);
+    if (!allDomains) {
+        throw Error(`Failed to get all domains list`);
+    }
+    const domain = allDomains[Math.floor(Math.random() * allDomains.length)];
+    const maxGroupId = Math.max(...allCampaigns.map(c => c.group_id || 0));
+    let alias = generateAlias();
+    let payload = {
+        // Унікальні поля
+        name: platformName ? platformCampaignName : name,
+        alias: alias,
+        domain_id: domain.id,
+        position: [maxPosition + 100],
+        group_id: maxGroupId + 1,
+        traffic_source_id: keitaro_utils_1.TRAFFIC_SOURCE_ID_FLASH_AI,
+        parameters: (0, keitaro_utils_1.prepareOWCampaignParameters)(app),
+        source: originalCampaign.source,
+        bind_visitors: "slo",
+        // Неунікальні поля з оригінальної кампанії
+        type: originalCampaign.type,
+        state: originalCampaign.state,
+        cost_type: originalCampaign.cost_type,
+        cost_value: originalCampaign.cost_value,
+        cost_currency: originalCampaign.cost_currency,
+        uniqueness_period: originalCampaign.uniqueness_period,
+        cookies_ttl: originalCampaign.cookies_ttl,
+        notes: originalCampaign.notes,
+        collect_clicks: originalCampaign.collect_clicks,
+        uniqueness_type: originalCampaign.uniqueness_type,
+    };
+    const newCampaign = await createCampaign(payload);
+    // Додаємо потоки: всі якщо addDefaultStreams === true, інакше тільки перший
+    const streamsToAdd = addDefaultStreams ? originalStreams : originalStreams.slice(0, 1);
+    for (const stream of streamsToAdd) {
+        await http_1.default.post('streams', {
+            name: stream.name,
+            campaign_id: newCampaign.id,
+            schema: stream.schema,
+            type: stream.type,
+            action_type: stream.action_type,
+            weight: stream.weight,
+            offers: stream.offers.map((offer) => ({
+                offer_id: offer.offer_id,
+                share: offer.share,
+                state: offer.state
+            })),
+            filters: stream.filters.map((filter) => ({
+                name: filter.name,
+                mode: filter.mode,
+                payload: filter.payload
+            })),
+            position: stream.position,
+            state: stream.state
+        });
+    }
+    await http_1.default.put(`/campaigns/${newCampaign.id}`, {
+        group_id: originalCampaign.group_id
+    });
+    const updatedCampaign = await getCampaignById(newCampaign.id);
+    return updatedCampaign;
+}
+async function cloneDCampaign(app) {
+    let name = `D #${app.id} (${app.bundle})`;
+    let allCampaigns = await getAllCampaigns();
+    let matchingCampaign = allCampaigns.filter((c) => c.name.includes(`D #${app.id}`));
+    if (matchingCampaign.length > 0)
+        return matchingCampaign[0];
+    const { data: campaigns } = await http_1.default.post(`/campaigns/2693/clone`);
+    if (campaigns.length == 0)
+        throw Error("Campaign cloning falied");
+    let clonedCampaign = campaigns[0];
+    let allDomains = await exports.KeitaroService.getDomains(true);
+    if (!allDomains) {
+        throw Error(`Failed to get all domains list`);
+    }
+    const domain = allDomains[Math.floor(Math.random() * allDomains.length)];
+    let payload = {
+        name: name,
+        traffic_source_id: keitaro_utils_1.TRAFFIC_SOURCE_ID_FLASH_AI,
+        domain_id: domain.id,
+        group_id: 93,
+    };
+    const { data: campaign } = await http_1.default.put(`/campaigns/${clonedCampaign.id}`, payload);
+    return campaign;
+}
+async function changeCampaignsGroup(fromId, toId, exceptForCampaignIds, onlyForCampaignIds) {
+    let campaigns = await getAllCampaigns();
+    const matchingCampaigns = campaigns.filter(campaign => campaign.group_id == fromId
+        && exceptForCampaignIds.length > 0 ? !exceptForCampaignIds.includes(campaign.id) : onlyForCampaignIds?.includes(campaign.id));
+    for (let campaign of matchingCampaigns) {
+        await updateCampaign(campaign.id, { group_id: toId });
+    }
+}
+// Domain
+async function getDomains(onlyActive) {
+    const { data: domains } = await http_1.default.get(`/domains`);
+    return onlyActive ? domains.filter((d) => d.network_status == "active") : domains;
+}
+async function getProfitForTimeRange(from, to) {
+    let fromString = (0, general_1.convertMillisToDate)(from);
+    let toString = (0, general_1.convertMillisToDate)(to);
+    let { data: data } = await http_1.default.post(`/report/build`, {
+        range: {
+            from: fromString,
+            to: toString,
+            timezone: 'Europe/Kyiv'
+        },
+        metrics: ['profit']
+    });
+    return data.rows[0].profit;
+}
+// async function getProfitForTodayAndYesterday(): Promise<any> {
+//     let timestamps = getTimestampsForTodayAndYesterday()
+//     let today = await KeitaroService.getProfitForTimeRange(timestamps.today.start, timestamps.today.end)
+//     let yesterday = await KeitaroService.getProfitForTimeRange(timestamps.yesterday.start, timestamps.yesterday.end)
+//     return {
+//         today: today,
+//         yesterday: yesterday
+//     }
+// }
+async function fixBrokenClickCosts(startDate, endDate) {
+    // Get all campaigns to update
+    const campaigns = await getAllCampaigns();
+    const campaignIds = campaigns.map(campaign => campaign.id);
+    // Prepare the payload for the API request
+    const payload = {
+        campaign_ids: campaignIds,
+        costs: [{
+                start_date: startDate,
+                end_date: endDate,
+                cost: 0,
+                filters: {}
+            }],
+        timezone: "Europe/Kyiv",
+        currency: "USD",
+        only_campaign_uniques: 0
+    };
+    // 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 = {
-    // Campaign operations
-    getAllCampaigns,
-    getCampaignById,
-    createCampaign,
-    updateCampaign,
-    cloneCampaignForApp,
-    getOfferwallCampaigns,
-    // Stream operations
-    getStreamsByCampaignId,
-    createStream,
-    // Domain operations
-    getDomains,
-    // Offer operations
-    getAllOffers,
-    createOfferInKeitaro,
-    addOfferToKeitaro,
-    // Utilities
-    generateAlias,
-    campaignToKeitaroData,
+    getStreamsByCampaignId, updateCampaign, getAllCampaigns, getAllOffers, cloneStreams, addOffersToKeitaro, getOfferByKeitaroId, getDomains, createCampaign, getCampaignById, upsertStreamToCampaign, cloneOWCampaign,
+    updateOffer, changeCampaignsGroup, getProfitForTimeRange, getClicks,
+    // getProfitForTodayAndYesterday, 
+    cloneDCampaign, findKeitaroOffers, fixBrokenClickCosts, cloneDirectCampaign
 };
-exports.default = exports.KeitaroService;