agrs-sequelize-sdk 1.2.11 → 1.2.12

package/controllers/campaignCreationLogsController.js

@@ -0,0 +1,264 @@
+const { CampaignCreationLogNew } = require("../db");
+const {
+  getProcessHierarchy,
+  getProcessStats,
+} = require("../utils/loggerUtils");
+const { Op } = require("sequelize");
+
+/**
+ * Get detailed logs for campaign creation processes
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ */
+async function getCampaignCreationLogs(req, res) {
+  try {
+    const {
+      process_id,
+      country,
+      status,
+      stage,
+      entity_name,
+      facebook_campaign_id,
+      facebook_adset_id,
+      facebook_ad_id,
+      from_date,
+      to_date,
+      page = 0,
+      limit = 20,
+    } = req.query;
+
+    // Build where clause
+    const whereClause = {};
+    if (process_id) whereClause.process_id = process_id;
+    if (country) whereClause.country = country;
+    if (status) whereClause.status = status;
+    if (stage) whereClause.stage = stage;
+    if (entity_name)
+      whereClause.entity_name = { [Op.iLike]: `%${entity_name}%` };
+    if (facebook_campaign_id)
+      whereClause.facebook_campaign_id = facebook_campaign_id;
+    if (facebook_adset_id) whereClause.facebook_adset_id = facebook_adset_id;
+    if (facebook_ad_id) whereClause.facebook_ad_id = facebook_ad_id;
+
+    // Date range filtering
+    if (from_date || to_date) {
+      whereClause.createdAt = {};
+      if (from_date) whereClause.createdAt[Op.gte] = new Date(from_date);
+      if (to_date) whereClause.createdAt[Op.lte] = new Date(to_date);
+    }
+
+    // Pagination params
+    const pageInt = parseInt(page, 10);
+    const limitInt = parseInt(limit, 10);
+
+    // Execute query
+    const { count, rows } = await CampaignCreationLogNew.findAndCountAll({
+      where: whereClause,
+      limit: limitInt,
+      offset: pageInt * limitInt,
+      order: [["createdAt", "DESC"]],
+    });
+
+    return res.json({
+      success: true,
+      logs: rows,
+      pagination: {
+        total: count,
+        page: pageInt,
+        limit: limitInt,
+        pages: Math.ceil(count / limitInt),
+      },
+    });
+  } catch (error) {
+    console.error("Error in getCampaignCreationLogs:", error);
+    return res.status(500).json({
+      success: false,
+      error: error.message,
+    });
+  }
+}
+
+/**
+ * Get all processes with summary information
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ */
+async function getCampaignCreationProcesses(req, res) {
+  try {
+    const {
+      status,
+      country,
+      from_date,
+      to_date,
+      page = 0,
+      limit = 10,
+    } = req.query;
+
+    // Get distinct process IDs with filter conditions
+    const whereClause = {};
+    if (status) whereClause.status = status;
+    if (country) whereClause.country = country;
+
+    // Date range filtering
+    if (from_date || to_date) {
+      whereClause.createdAt = {};
+      if (from_date) whereClause.createdAt[Op.gte] = new Date(from_date);
+      if (to_date) whereClause.createdAt[Op.lte] = new Date(to_date);
+    }
+
+    // Get distinct process IDs
+    const distinctProcessIds = await CampaignCreationLogNew.findAll({
+      attributes: [
+        "process_id",
+        [
+          CampaignCreationLogNew.sequelize.fn(
+            "MAX",
+            CampaignCreationLogNew.sequelize.col("createdAt")
+          ),
+          "latest_timestamp",
+        ],
+      ],
+      where: whereClause,
+      group: ["process_id"],
+      order: [
+        [CampaignCreationLogNew.sequelize.literal("latest_timestamp"), "DESC"],
+      ],
+      limit: parseInt(limit, 10),
+      offset: parseInt(page, 10) * parseInt(limit, 10),
+    });
+
+    // Get process IDs from result
+    const processIds = distinctProcessIds.map((item) => item.process_id);
+
+    // Get summary information for each process
+    const processes = [];
+    for (const processId of processIds) {
+      // Get the initial log for this process
+      const initialLog = await CampaignCreationLogNew.findOne({
+        where: {
+          process_id: processId,
+          stage: "PROCESS_STARTED",
+        },
+        order: [["createdAt", "ASC"]],
+      });
+
+      if (initialLog) {
+        // Get stats for this process
+        const stats = await getProcessStats(processId);
+
+        // Get the latest log to determine current status
+        const latestLog = await CampaignCreationLogNew.findOne({
+          where: { process_id: processId },
+          order: [["createdAt", "DESC"]],
+        });
+
+        processes.push({
+          process_id: processId,
+          created_at: initialLog.createdAt,
+          updated_at: latestLog.createdAt,
+          status: latestLog.status,
+          statistics: stats,
+          countries: await getCountriesByProcess(processId),
+        });
+      }
+    }
+
+    // Count total number of distinct processes
+    const totalProcessesCount = await CampaignCreationLogNew.count({
+      distinct: true,
+      col: "process_id",
+      where: whereClause,
+    });
+
+    return res.json({
+      success: true,
+      processes,
+      pagination: {
+        total: totalProcessesCount,
+        page: parseInt(page, 10),
+        limit: parseInt(limit, 10),
+        pages: Math.ceil(totalProcessesCount / parseInt(limit, 10)),
+      },
+    });
+  } catch (error) {
+    console.error("Error in getCampaignCreationProcesses:", error);
+    return res.status(500).json({
+      success: false,
+      error: error.message,
+    });
+  }
+}
+
+/**
+ * Get detailed hierarchical view of a specific process
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ */
+async function getCampaignCreationProcessDetails(req, res) {
+  try {
+    const { process_id } = req.params;
+
+    if (!process_id) {
+      return res.status(400).json({
+        success: false,
+        error: "Process ID is required",
+      });
+    }
+
+    // Get hierarchical view
+    const processDetails = await getProcessHierarchy(process_id);
+
+    if (!processDetails) {
+      return res.status(404).json({
+        success: false,
+        error: "Process not found",
+      });
+    }
+
+    return res.json({
+      success: true,
+      process: processDetails,
+    });
+  } catch (error) {
+    console.error("Error in getCampaignCreationProcessDetails:", error);
+    return res.status(500).json({
+      success: false,
+      error: error.message,
+    });
+  }
+}
+
+/**
+ * Helper function to get countries involved in a process
+ * @param {String} processId - Process ID
+ * @returns {Promise<Array>} Array of country information
+ */
+async function getCountriesByProcess(processId) {
+  const countries = await CampaignCreationLogNew.findAll({
+    attributes: [
+      "country",
+      [
+        CampaignCreationLogNew.sequelize.fn(
+          "MAX",
+          CampaignCreationLogNew.sequelize.col("status")
+        ),
+        "status",
+      ],
+    ],
+    where: {
+      process_id: processId,
+      country: { [Op.ne]: null },
+      stage: "CAMPAIGN_CREATION",
+    },
+    group: ["country"],
+    raw: true,
+  });
+
+  return countries;
+}
+
+module.exports = {
+  getCampaignCreationLogs,
+  getCampaignCreationProcesses,
+  getCampaignCreationProcessDetails,
+};

package/models/CampaignCreationLogNew.js

@@ -0,0 +1,141 @@
+module.exports = (sequelize, DataTypes) => {
+  const CampaignCreationLogNew = sequelize.define(
+    "CampaignCreationLogNew",
+    {
+      id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      process_id: {
+        type: DataTypes.UUID,
+        allowNull: false,
+        comment: "Unique ID for the creation batch process",
+      },
+      stage: {
+        type: DataTypes.ENUM(
+          "PROCESS_STARTED",
+          "CAMPAIGN_CREATION",
+          "ADSET_CREATION",
+          "AD_CREATION"
+        ),
+        allowNull: false,
+        comment: "Current stage of the campaign creation process",
+      },
+      status: {
+        type: DataTypes.ENUM("STARTED", "IN_PROGRESS", "COMPLETED", "FAILED"),
+        allowNull: false,
+        defaultValue: "STARTED",
+        comment: "Status of the current stage",
+      },
+      country: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: "Country being processed",
+      },
+      feed_campaign_id: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: "AGRS_CID of the created feed campaign",
+      },
+      facebook_campaign_id: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: "Facebook campaign ID if created",
+      },
+      facebook_adset_id: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: "Facebook adset ID if created",
+      },
+      facebook_ad_id: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: "Facebook ad ID if created",
+      },
+      parent_id: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: "Parent entity ID (campaign ID for adsets, adset ID for ads)",
+      },
+      entity_name: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: "Name of the created entity (campaign, adset, or ad name)",
+      },
+      entity_index: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        comment:
+          "Index of this entity in a collection (for multiple adsets/ads)",
+      },
+      details: {
+        type: DataTypes.JSONB,
+        allowNull: true,
+        comment:
+          "Structured details about the stage, including original request, campaign, adset, or ad data",
+      },
+      error_message: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        comment: "Error message if process failed",
+      },
+    },
+    {
+      tableName: "CampaignCreationLogsNew",
+      timestamps: true,
+      indexes: [
+        {
+          fields: ["process_id"],
+        },
+        {
+          fields: ["stage"],
+        },
+        {
+          fields: ["status"],
+        },
+        {
+          fields: ["country"],
+        },
+        {
+          fields: ["feed_campaign_id"],
+        },
+        {
+          fields: ["facebook_campaign_id"],
+        },
+        {
+          fields: ["facebook_adset_id"],
+        },
+        {
+          fields: ["facebook_ad_id"],
+        },
+        {
+          fields: ["parent_id"],
+        },
+        {
+          fields: ["entity_name"],
+        },
+        {
+          fields: ["entity_index"],
+        },
+        {
+          fields: ["createdAt"],
+        },
+      ],
+    }
+  );
+
+  CampaignCreationLogNew.associate = (models) => {
+    // Add associations if needed
+    if (models.CodefuelCampaign) {
+      CampaignCreationLogNew.belongsTo(models.CodefuelCampaign, {
+        foreignKey: "feed_campaign_id",
+        targetKey: "AGRSCID",
+        as: "FeedCampaign",
+        constraints: false,
+      });
+    }
+  };
+
+  return CampaignCreationLogNew;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agrs-sequelize-sdk",
-  "version": "1.2.11",
+  "version": "1.2.12",
   "main": "index.js",
   "scripts": {
     "start": "node index.js",

package/routes/api.js

@@ -0,0 +1,18 @@
+// Add these new routes to the API router
+
+// Import the controller
+const campaignCreationLogsController = require("../controllers/campaignCreationLogsController");
+
+// Add routes for campaign creation logs
+router.get(
+  "/campaign-creation-logs",
+  campaignCreationLogsController.getCampaignCreationLogs
+);
+router.get(
+  "/campaign-creation-processes",
+  campaignCreationLogsController.getCampaignCreationProcesses
+);
+router.get(
+  "/campaign-creation-processes/:process_id",
+  campaignCreationLogsController.getCampaignCreationProcessDetails
+);

package/utils/loggerUtils.js

@@ -0,0 +1,497 @@
+/**
+ * Create logs in both old and new campaign creation log models
+ * @param {Object} oldLogData Data for the original CampaignCreationLog model
+ * @param {Object} newLogData Data for the new CampaignCreationLogNew model
+ * @returns {Promise<Object>} Object containing both created logs
+ */
+async function createDualLogs(oldLogData, newLogData) {
+  const { CampaignCreationLog, CampaignCreationLogNew } = require("../db");
+
+  try {
+    // Create log in original model
+    const oldLog = await CampaignCreationLog.create(oldLogData);
+
+    // Create log in new model with extended data
+    const newLog = await CampaignCreationLogNew.create({
+      ...newLogData,
+      // Ensure we have the original data as well
+      process_id: oldLogData.process_id,
+      country: oldLogData.country,
+      feed_campaign_id: oldLogData.feed_campaign_id,
+      facebook_campaign_id: oldLogData.facebook_campaign_id,
+      error_message: oldLogData.error_message,
+    });
+
+    return { oldLog, newLog };
+  } catch (error) {
+    console.error("Error creating logs:", error);
+    // Always try to create the original log even if the new one fails
+    try {
+      const oldLog = await CampaignCreationLog.create(oldLogData);
+      return { oldLog, newLog: null };
+    } catch (oldLogError) {
+      console.error("Failed to create old log as well:", oldLogError);
+      throw error; // Re-throw original error
+    }
+  }
+}
+
+/**
+ * Log campaign creation stage - with support for hierarchy
+ * @param {Object} data Log data
+ * @returns {Promise<Object>} Created logs
+ */
+async function logCampaignCreationStage(data) {
+  const {
+    process_id,
+    stage,
+    status,
+    country,
+    facebook_campaign_id,
+    feed_campaign_id,
+    facebook_adset_id,
+    facebook_ad_id,
+    parent_id,
+    entity_name,
+    entity_index,
+    details,
+    error_message,
+  } = data;
+
+  // Format data for old log model
+  const oldLogData = {
+    process_id,
+    status,
+    country,
+    feed_campaign_id,
+    facebook_campaign_id,
+    details: {
+      step: stage,
+      ...(facebook_adset_id && { adsetId: facebook_adset_id }),
+      ...(facebook_ad_id && { adId: facebook_ad_id }),
+      ...(entity_name && { name: entity_name }),
+      ...(details && { ...details }),
+    },
+    error_message,
+  };
+
+  // Format data for new log model
+  const newLogData = {
+    process_id,
+    stage,
+    status,
+    country,
+    feed_campaign_id,
+    facebook_campaign_id,
+    facebook_adset_id,
+    facebook_ad_id,
+    parent_id,
+    entity_name,
+    entity_index,
+    details,
+    error_message,
+  };
+
+  return createDualLogs(oldLogData, newLogData);
+}
+
+/**
+ * Log campaign creation with multiple adsets and ads
+ * @param {Object} data Campaign data
+ * @returns {Promise<Array>} Created logs
+ */
+async function logCampaignWithChildEntities(data) {
+  const {
+    process_id,
+    country,
+    campaign_id,
+    campaign_name,
+    adsets = [],
+    campaign_details,
+    status = "COMPLETED",
+    error_message,
+  } = data;
+
+  const logs = [];
+
+  // Log the campaign creation
+  const campaignLog = await logCampaignCreationStage({
+    process_id,
+    stage: "CAMPAIGN_CREATION",
+    status,
+    country,
+    facebook_campaign_id: campaign_id,
+    entity_name: campaign_name,
+    details: {
+      campaign_data: campaign_details || { campaign_name },
+      planned_adsets: adsets.map((adset) => ({
+        adset_name: adset.name,
+        targeting: adset.targeting,
+      })),
+    },
+    error_message,
+  });
+
+  logs.push(campaignLog);
+
+  // If campaign was successful and we have adsets, log each adset
+  if (status === "COMPLETED" && adsets.length > 0) {
+    for (const [index, adset] of adsets.entries()) {
+      // Log adset creation
+      const adsetLog = await logCampaignCreationStage({
+        process_id,
+        stage: "ADSET_CREATION",
+        status: adset.status || "COMPLETED",
+        country,
+        facebook_campaign_id: campaign_id,
+        facebook_adset_id: adset.id,
+        parent_id: campaign_id,
+        entity_name: adset.name,
+        entity_index: index,
+        details: {
+          adset_data: {
+            adset_name: adset.name,
+            targeting: adset.targeting,
+            budget: adset.budget,
+          },
+          planned_ads: adset.ads?.map((ad) => ({
+            ad_name: ad.name,
+            creative: ad.creative,
+          })),
+        },
+        error_message: adset.error_message,
+      });
+
+      logs.push(adsetLog);
+
+      // If adset was successful and we have ads, log each ad
+      if (adset.status !== "FAILED" && adset.ads && adset.ads.length > 0) {
+        for (const [adIndex, ad] of adset.ads.entries()) {
+          // Log ad creation
+          const adLog = await logCampaignCreationStage({
+            process_id,
+            stage: "AD_CREATION",
+            status: ad.status || "COMPLETED",
+            country,
+            facebook_campaign_id: campaign_id,
+            facebook_adset_id: adset.id,
+            facebook_ad_id: ad.id,
+            parent_id: adset.id,
+            entity_name: ad.name,
+            entity_index: adIndex,
+            details: {
+              ad_data: {
+                ad_name: ad.name,
+                creative: ad.creative,
+              },
+            },
+            error_message: ad.error_message,
+          });
+
+          logs.push(adLog);
+        }
+      }
+    }
+  }
+
+  return logs;
+}
+
+/**
+ * Determine error stage based on error message or context
+ * @param {Error} error Error object
+ * @returns {String} Stage name where the error occurred
+ */
+function determineErrorStage(error) {
+  if (!error) return "PROCESS_STARTED";
+
+  // Check if stage is explicitly set
+  if (error.stage) return error.stage;
+
+  // Try to infer from error message
+  const message = error.message ? error.message.toLowerCase() : "";
+
+  if (message.includes("campaign")) return "CAMPAIGN_CREATION";
+  if (message.includes("adset")) return "ADSET_CREATION";
+  if (message.includes("ad ") || message.includes("creative"))
+    return "AD_CREATION";
+
+  return "PROCESS_STARTED"; // Default
+}
+
+/**
+ * Get summary statistics for a campaign creation process
+ * @param {String} processId UUID of the process
+ * @returns {Promise<Object>} Object with stats about the process
+ */
+async function getProcessStats(processId) {
+  const { CampaignCreationLogNew, sequelize } = require("../db");
+  const { Op } = require("sequelize");
+
+  // Count successful countries (completed campaign stage with adsets and ads)
+  const successfulCampaigns = await CampaignCreationLogNew.count({
+    where: {
+      process_id: processId,
+      stage: "CAMPAIGN_CREATION",
+      status: "COMPLETED",
+    },
+  });
+
+  // Count successful adsets
+  const successfulAdsets = await CampaignCreationLogNew.count({
+    where: {
+      process_id: processId,
+      stage: "ADSET_CREATION",
+      status: "COMPLETED",
+    },
+  });
+
+  // Count successful ads
+  const successfulAds = await CampaignCreationLogNew.count({
+    where: {
+      process_id: processId,
+      stage: "AD_CREATION",
+      status: "COMPLETED",
+    },
+  });
+
+  // Count failed entities at each level
+  const failedCampaigns = await CampaignCreationLogNew.count({
+    where: {
+      process_id: processId,
+      stage: "CAMPAIGN_CREATION",
+      status: "FAILED",
+    },
+  });
+
+  const failedAdsets = await CampaignCreationLogNew.count({
+    where: {
+      process_id: processId,
+      stage: "ADSET_CREATION",
+      status: "FAILED",
+    },
+  });
+
+  const failedAds = await CampaignCreationLogNew.count({
+    where: {
+      process_id: processId,
+      stage: "AD_CREATION",
+      status: "FAILED",
+    },
+  });
+
+  // Count countries
+  const successfulCountries = await CampaignCreationLogNew.count({
+    where: {
+      process_id: processId,
+      stage: "CAMPAIGN_CREATION",
+      status: "COMPLETED",
+    },
+    distinct: true,
+    col: "country",
+  });
+
+  const failedCountries = await CampaignCreationLogNew.count({
+    where: {
+      process_id: processId,
+      stage: "CAMPAIGN_CREATION",
+      status: "FAILED",
+    },
+    distinct: true,
+    col: "country",
+  });
+
+  // Get all countries in the process
+  const allCountries = await CampaignCreationLogNew.count({
+    where: {
+      process_id: processId,
+      country: { [Op.ne]: null },
+    },
+    distinct: true,
+    col: "country",
+  });
+
+  return {
+    total_countries: allCountries,
+    successful_countries: successfulCountries,
+    failed_countries: failedCountries,
+    in_progress_countries: allCountries - successfulCountries - failedCountries,
+    entity_stats: {
+      campaigns: {
+        successful: successfulCampaigns,
+        failed: failedCampaigns,
+      },
+      adsets: {
+        successful: successfulAdsets,
+        failed: failedAdsets,
+      },
+      ads: {
+        successful: successfulAds,
+        failed: failedAds,
+      },
+    },
+  };
+}
+
+/**
+ * Get hierarchical view of a campaign creation process
+ * @param {String} processId Process ID
+ * @returns {Promise<Object>} Hierarchical view of the process
+ */
+async function getProcessHierarchy(processId) {
+  const { CampaignCreationLogNew } = require("../db");
+
+  // Get initial process log
+  const processLog = await CampaignCreationLogNew.findOne({
+    where: {
+      process_id: processId,
+      stage: "PROCESS_STARTED",
+    },
+    order: [["createdAt", "ASC"]],
+  });
+
+  if (!processLog) {
+    return null;
+  }
+
+  // Get all campaign logs
+  const campaignLogs = await CampaignCreationLogNew.findAll({
+    where: {
+      process_id: processId,
+      stage: "CAMPAIGN_CREATION",
+    },
+    order: [
+      ["country", "ASC"],
+      ["createdAt", "DESC"],
+    ],
+  });
+
+  // Group campaigns by country
+  const campaignsByCountry = {};
+
+  for (const log of campaignLogs) {
+    const country = log.country || "unknown";
+
+    if (!campaignsByCountry[country]) {
+      campaignsByCountry[country] = {
+        country,
+        status: log.status,
+        campaign_id: log.facebook_campaign_id,
+        campaign_name: log.entity_name,
+        details: log.details,
+        error: log.error_message,
+        adsets: [],
+        createdAt: log.createdAt,
+      };
+    }
+  }
+
+  // For each campaign, get its adsets
+  for (const country in campaignsByCountry) {
+    const campaign = campaignsByCountry[country];
+
+    if (campaign.campaign_id) {
+      // Get adsets for this campaign
+      const adsetLogs = await CampaignCreationLogNew.findAll({
+        where: {
+          process_id: processId,
+          stage: "ADSET_CREATION",
+          parent_id: campaign.campaign_id,
+        },
+        order: [
+          ["entity_index", "ASC"],
+          ["createdAt", "DESC"],
+        ],
+      });
+
+      // Process adsets
+      for (const adsetLog of adsetLogs) {
+        const adset = {
+          adset_id: adsetLog.facebook_adset_id,
+          adset_name: adsetLog.entity_name,
+          status: adsetLog.status,
+          details: adsetLog.details,
+          error: adsetLog.error_message,
+          ads: [],
+          createdAt: adsetLog.createdAt,
+        };
+
+        // Get ads for this adset
+        if (adsetLog.facebook_adset_id) {
+          const adLogs = await CampaignCreationLogNew.findAll({
+            where: {
+              process_id: processId,
+              stage: "AD_CREATION",
+              parent_id: adsetLog.facebook_adset_id,
+            },
+            order: [
+              ["entity_index", "ASC"],
+              ["createdAt", "DESC"],
+            ],
+          });
+
+          // Process ads
+          for (const adLog of adLogs) {
+            adset.ads.push({
+              ad_id: adLog.facebook_ad_id,
+              ad_name: adLog.entity_name,
+              status: adLog.status,
+              details: adLog.details,
+              error: adLog.error_message,
+              createdAt: adLog.createdAt,
+            });
+          }
+        }
+
+        campaign.adsets.push(adset);
+      }
+    }
+  }
+
+  // Return hierarchical view
+  return {
+    process_id: processId,
+    status: processLog.status,
+    original_request: processLog.details?.original_request,
+    created_at: processLog.createdAt,
+    campaigns_by_country: campaignsByCountry,
+    statistics: await getProcessStats(processId),
+  };
+}
+
+/**
+ * Determine the final status of a process based on its logs
+ * @param {String} processId UUID of the process
+ * @returns {Promise<String>} Final status (COMPLETED, FAILED, etc.)
+ */
+async function determineFinalStatus(processId) {
+  const stats = await getProcessStats(processId);
+
+  // If all countries failed
+  if (stats.failed_countries > 0 && stats.successful_countries === 0) {
+    return "FAILED";
+  }
+
+  // If some countries succeeded and some failed
+  if (stats.failed_countries > 0 && stats.successful_countries > 0) {
+    return "COMPLETED"; // Could also be "PARTIALLY_COMPLETED" if you want to add this status
+  }
+
+  // If all countries succeeded
+  if (stats.successful_countries > 0 && stats.failed_countries === 0) {
+    return "COMPLETED";
+  }
+
+  // If no countries completed or failed yet
+  return "IN_PROGRESS";
+}
+
+module.exports = {
+  createDualLogs,
+  logCampaignCreationStage,
+  logCampaignWithChildEntities,
+  determineErrorStage,
+  getProcessStats,
+  getProcessHierarchy,
+  determineFinalStatus,
+};