@bprotsyk/aso-core 2.1.224 → 2.1.225

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

@@ -1,20 +1,13 @@
 import { IKeitaroStream } from "../../keitaro/keitaro-stream";
-import { IOffer } from "../../offers/offer";
+import { IOffer } from "../../offers/offer"
 import keitaroApi from "./http"
 import { IKeitaroCampaign } from "../../keitaro/keitaro-campaign";
 import { IKeitaroDomain } from "../../keitaro/keitaro-domain";
-import { 
-    IApp, 
-    IAppKeitaroData,
-    IntegrationType,
-    OFFERWALL_TEMPLATE_CAMPAIGN_ID,
-    DIRECT_TEMPLATE_CAMPAIGN_ID
-} from "../../app/app";
-import { IKeitaroOffer } from "../../keitaro/keitaro-offer";
-
-// Default group IDs
-const DEFAULT_OFFERS_GROUP_ID = 107;
-const DEFAULT_CAMPAIGNS_GROUP_ID = 106;
+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 } from "index";
+import { IKeitaroClicksRequest, IKeitaroClicksRangeRequest, KeitaroClicksInterval } from "../../keitaro/keitaro-clicks";
 
 export interface IKeitaroOffersFilter {
     keitaroId?: number,
@@ -22,9 +15,9 @@ export interface IKeitaroOffersFilter {
     caption?: string
 }
 
-// Basic campaign operations
 async function getStreamsByCampaignId(campaignId: number): Promise<IKeitaroStream[]> {
     const { data: streams } = await keitaroApi.get<IKeitaroStream[]>(`campaigns/${campaignId}/streams`);
+
     return streams
 }
 
@@ -33,213 +26,450 @@ async function getAllCampaigns(): Promise<IKeitaroCampaign[]> {
     return campaigns
 }
 
-async function getCampaignById(id: number): Promise<IKeitaroCampaign> {
-    const { data: campaign } = await keitaroApi.get(`/campaigns/${id}`);
-    return campaign
+
+
+async function cloneStreams(originalCampaignId: number, streamPositionsToClone: number[], campaignRegExp: RegExp): Promise<void> {
+    // 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 keitaroApi.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: number, payload: Partial<IKeitaroCampaign>) {
     await keitaroApi.put(`campaigns/${id}`, payload)
 }
 
-async function createCampaign(campaignData: Partial<IKeitaroCampaign>): Promise<IKeitaroCampaign> {
-    let { data: campaign } = await keitaroApi.post(`/campaigns`, campaignData)
-    return campaign
-}
+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)
+    );
 
-// Domain operations
-async function getDomains(onlyActive?: boolean): Promise<IKeitaroDomain[]> {
-    const { data: domains } = await keitaroApi.get<IKeitaroDomain[]>(`/domains`)
-    return onlyActive ? domains.filter((d) => d.network_status == "active") : domains
+    // 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));
+    }
+
+    // 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 keitaroApi.put(`streams/${identicalStream.id}`, {
+                        campaign_id: matchingCampaign.id,
+                        ...payload
+                    });
+                } else {
+                    await keitaroApi.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(): Promise<IKeitaroOffer[]> {
-    const { data: offers } = await keitaroApi.get<IKeitaroOffer[]>('offers');
+    const { data: offers } = await keitaroApi.get<IKeitaroOffer[]>('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: IOffer): Promise<IKeitaroOffer> {
-    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, // Can be set if we have partner mapping
-        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 keitaroApi.post<IKeitaroOffer>('offers', payload);
-    return keitaroOffer;
+
+async function findKeitaroOffers(filter: IKeitaroOffersFilter): Promise<IKeitaroOffer[]> {
+    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: number, streamData: Partial<IKeitaroStream>): Promise<IKeitaroStream> {
-    const { data: stream } = await keitaroApi.post<IKeitaroStream>('streams', {
-        ...streamData,
-        campaign_id: campaignId
-    });
-    return stream;
+async function getOfferByKeitaroId(id: number): Promise<IKeitaroOffer> {
+    const { data: offer } = await keitaroApi.get<IKeitaroOffer>(`offers/${id}`)
+
+    return offer
 }
 
-/**
- * Get all offerwall campaigns (campaigns with [◈] prefix in group 106)
- */
-async function getOfferwallCampaigns(): Promise<IKeitaroCampaign[]> {
-    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: any): Promise<IKeitaroOffer> {
+    const { data: o } = await keitaroApi.put<IKeitaroOffer>(`offers/${offer.id}`, offer)
+
+    return o
+}
+
+function createStreamPartialPayload(keitaroOfferId: number, offerName: string, offerId: string, offerGeo: string) {
+    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]
+        }],
+    }
 }
 
-/**
- * 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: IOffer): Promise<{ 
-    keitaroOfferId: number; 
-    success: number; 
-    failed: number; 
-    campaigns: string[] 
-}> {
-    // First, create the offer in Keitaro
-    const keitaroOffer = await createOfferInKeitaro(offer);
-    console.log(`Created Keitaro offer #${keitaroOffer.id}: ${keitaroOffer.name}`);
+async function addOffersToKeitaro(offers: IOffer[], affiliateId: number, links: string[], avoidGroup?: number, groupId?: number) {
+    const allOffers = await getAllOffers();
     
-    // Then distribute to all offerwall campaigns
-    const offerwallCampaigns = await getOfferwallCampaigns();
-    let success = 0;
-    let failed = 0;
-    const campaignNames: string[] = [];
+    const streamPayloads = [];
     
-    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]
-                }]
-            });
+    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,
+            };
             
-            success++;
-            campaignNames.push(campaign.name);
-        } catch (error) {
-            console.error(`Failed to add offer to campaign ${campaign.name}:`, error);
-            failed++;
+            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
+        });
     }
     
-    return { keitaroOfferId: keitaroOffer.id, success, failed, campaigns: campaignNames };
+    await createStreamForMatchingCampaigns(streamPayloads, /◈/, avoidGroup);
 }
 
-// Generate random alias for campaigns
-function generateAlias(): string {
-    const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
-    return Array.from(
-        { length: 8 }, 
-        () => chars.charAt(Math.floor(Math.random() * chars.length))
-    ).join('');
+async function createCampaign(campaignData: Partial<IKeitaroCampaign>): Promise<IKeitaroCampaign> {
+    let { data: campaign } = await keitaroApi.post(`/campaigns`, campaignData)
+
+    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: IApp, integrationType: IntegrationType): Promise<IAppKeitaroData> {
-    const templateId = integrationType === IntegrationType.OFFERWALL 
-        ? OFFERWALL_TEMPLATE_CAMPAIGN_ID 
-        : DIRECT_TEMPLATE_CAMPAIGN_ID;
-    
-    const campaignPrefix = integrationType === 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 getCampaignById(id: number): Promise<IKeitaroCampaign> {
+    const { data: campaign } = await keitaroApi.get(`/campaigns/${id}`);
+    return campaign
+}
+
+export async function upsertStreamToCampaign(campaign: IKeitaroCampaign, stream: Partial<IKeitaroStream>) {
+    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 keitaroApi.put(`streams/${identicalStream.id}`, {
+            campaign_id: campaign.id,
+            ...stream
+        });
+    } else {
+        await keitaroApi.post('streams', {
+            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');
+}
+
+async function cloneOWCampaign(app: IApp, platform?: EPlatform): Promise<IKeitaroCampaign | any> {
+    let name = `#${app.id} [◈]`
+    let platformName = platform ? getPlatformName(platform) : null;
+    const platformCampaignName = `#${app.id} [◈] (${platformName})`;
+    const generateAlias = () => {
+        const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+        return Array.from(
+            { length: 8 }, 
+            () => chars.charAt(Math.floor(Math.random() * chars.length))
+        ).join('');
+    };
+
+    let allCampaigns = await getAllCampaigns();
+
+    let matchingCampaign: IKeitaroCampaign[] = [];
+
+    if (platform && platform !== EPlatform.GENERAL) {
+        // Шукаємо кампанію з платформою
+        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: IKeitaroCampaign = await getCampaignById(2673);
+    const maxPosition = Math.max(...allCampaigns.map(c => c.position || 0));
+    const originalStreams = await getStreamsByCampaignId(2673);
+
+    let allDomains = await KeitaroService.getDomains(true);
+    if (!allDomains) {
+        throw Error(`Failed to get all domains list`);
     }
+
     const domain = allDomains[Math.floor(Math.random() * allDomains.length)];
-    
-    // Create campaign payload
+    const maxGroupId = Math.max(...allCampaigns.map(c => c.group_id || 0));
+
+    let alias = generateAlias();
+
+    let payload: Partial<IKeitaroCampaign> = {
+        // Унікальні поля
+        name: platformName ? platformCampaignName : name,
+        alias: alias,
+        domain_id: domain.id,
+        position: [maxPosition + 100],
+        group_id: maxGroupId + 1,
+        traffic_source_id: TRAFFIC_SOURCE_ID_FLASH_AI,
+        parameters: 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,
+    };
+
+    const newCampaign: IKeitaroCampaign = await createCampaign(payload);
+
+    for (const stream of originalStreams) {
+        await keitaroApi.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 keitaroApi.put(`/campaigns/${newCampaign.id}`, {
+        group_id: originalCampaign.group_id
+    });
+
+    const updatedCampaign = await getCampaignById(newCampaign.id);
+
+    return updatedCampaign;
+}
+
+async function cloneDirectCampaign(app: IApp, platform?: EPlatform, addDefaultStreams?: boolean): Promise<IKeitaroCampaign | any> {
+    let name = `#${app.id} [➥]`
+    let platformName = platform ? getPlatformName(platform) : null;
+    const platformCampaignName = `#${app.id} [➥] (${platformName})`;
+    const generateAlias = () => {
+        const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+        return Array.from(
+            { length: 8 }, 
+            () => chars.charAt(Math.floor(Math.random() * chars.length))
+        ).join('');
+    };
+
+    let allCampaigns = await getAllCampaigns();
+    let matchingCampaign: IKeitaroCampaign[] = [];
+
+    if (platform && platform !== EPlatform.GENERAL) {
+        // Для конкретної платформи
+        const platformName = getPlatformName(platform);
+        matchingCampaign = allCampaigns.filter((c) => {
+            // Точна перевірка ID з межами слів
+            const idPattern = new RegExp(`#${app.id}\\b`);
+            const hasId = idPattern.test(c.name);
+            // Перевіряємо наявність стрілки (може бути в комбінації з іншими символами)
+            const 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 keitaroApi.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: IKeitaroCampaign = await getCampaignById(3175);
     const maxPosition = Math.max(...allCampaigns.map(c => c.position || 0));
-    const alias = generateAlias();
-    
-    const payload: Partial<IKeitaroCampaign> = {
-        name: campaignName,
+    const originalStreams = await getStreamsByCampaignId(3175);
+
+    let allDomains = await 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: Partial<IKeitaroCampaign> = {
+        // Унікальні поля
+        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: TRAFFIC_SOURCE_ID_FLASH_AI,
+        parameters: 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: IKeitaroCampaign = await createCampaign(payload);
+
+    // Додаємо потоки: всі якщо addDefaultStreams === true, інакше тільки перший
+    const streamsToAdd = addDefaultStreams ? originalStreams : originalStreams.slice(0, 1);
     
-    // Create the new campaign
-    const newCampaign = await createCampaign(payload);
-    
-    // Clone streams from template
-    for (const stream of templateStreams) {
+    for (const stream of streamsToAdd) {
         await keitaroApi.post('streams', {
             name: stream.name,
             campaign_id: newCampaign.id,
@@ -261,62 +491,133 @@ async function cloneCampaignForApp(app: IApp, integrationType: IntegrationType):
             state: stream.state
         });
     }
-    
-    // Get updated campaign with token
+    await keitaroApi.put(`/campaigns/${newCampaign.id}`, {
+        group_id: originalCampaign.group_id
+    });
+
     const updatedCampaign = await getCampaignById(newCampaign.id);
+
+    return updatedCampaign;
     
-    return campaignToKeitaroData(updatedCampaign);
 }
 
-/**
- * Convert a Keitaro campaign to IAppKeitaroData
- */
-function campaignToKeitaroData(campaign: IKeitaroCampaign): IAppKeitaroData {
-    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 cloneDCampaign(app: IApp): Promise<IKeitaroCampaign> {
+    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 keitaroApi.post(`/campaigns/2693/clone`);
+
+    if (campaigns.length == 0) throw Error("Campaign cloning falied")
+
+    let clonedCampaign: IKeitaroCampaign = campaigns[0]
+
+    let allDomains = await KeitaroService.getDomains(true)
+    if (!allDomains) {
+        throw Error(`Failed to get all domains list`)
+    }
+
+    const domain = allDomains[Math.floor(Math.random() * allDomains.length)];
+
+    let payload: Partial<IKeitaroCampaign> = {
+        name: name,
+        traffic_source_id: TRAFFIC_SOURCE_ID_FLASH_AI,
+        domain_id: domain.id,
+        group_id: 93,
+    }
+
+    const { data: campaign } = await keitaroApi.put(`/campaigns/${clonedCampaign.id}`, payload)
+
+    return campaign
+}
+
+async function changeCampaignsGroup(fromId: number, toId: number, exceptForCampaignIds: number[], onlyForCampaignIds?: number[]) {
+    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?: boolean): Promise<IKeitaroDomain[]> {
+    const { data: domains } = await keitaroApi.get<IKeitaroDomain[]>(`/domains`)
+    return onlyActive ? domains.filter((d) => d.network_status == "active") : domains
+}
+
+async function getProfitForTimeRange(from: number, to: number): Promise<number> {
+    let fromString = convertMillisToDate(from)
+    let toString = convertMillisToDate(to)
+
+    let { data: data } = await keitaroApi.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: string, endDate: string): Promise<void> {
+    // 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 keitaroApi.post('/clicks/update_costs', payload);
 }
 
-export const KeitaroService = {
-    // Campaign operations
-    getAllCampaigns,
-    getCampaignById,
-    createCampaign,
-    updateCampaign,
-    cloneCampaignForApp,
-    getOfferwallCampaigns,
-    
-    // Stream operations
-    getStreamsByCampaignId,
-    createStream,
-    
-    // Domain operations
-    getDomains,
-    
-    // Offer operations
-    getAllOffers,
-    createOfferInKeitaro,
-    addOfferToKeitaro,
+async function getClicks(request: IKeitaroClicksRequest | KeitaroClicksInterval) {
+    const defaultRequest: IKeitaroClicksRequest = typeof request === 'string' ? {
+        range: { interval: request }
+    } : {
+        ...request
+    };
     
-    // Utilities
-    generateAlias,
-    campaignToKeitaroData,
+    const { data } = await keitaroApi.post('/clicks/log', defaultRequest);
+    return data.rows;
 }
 
-export default KeitaroService;
+
+export const KeitaroService = {
+    getStreamsByCampaignId, updateCampaign, getAllCampaigns, getAllOffers, cloneStreams, addOffersToKeitaro, getOfferByKeitaroId, getDomains, createCampaign, getCampaignById, upsertStreamToCampaign, cloneOWCampaign,
+    updateOffer, changeCampaignsGroup, getProfitForTimeRange, getClicks,
+    // getProfitForTodayAndYesterday, 
+    cloneDCampaign, findKeitaroOffers, fixBrokenClickCosts, cloneDirectCampaign
+}