agrs-sequelize-sdk 1.2.11 → 1.2.13

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.13",
   "main": "index.js",
   "scripts": {
     "start": "node index.js",

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,
+};

package/migrations/20240321000000-add-performance-indexes.js

@@ -1,73 +0,0 @@
-"use strict";
-
-module.exports = {
-  up: async (queryInterface, Sequelize) => {
-    // Add indexes for AdPerformance table
-    await queryInterface.addIndex("AdPerformance", ["Date", "AdID"], {
-      name: "ad_performance_date_adid_idx",
-      unique: true,
-    });
-
-    await queryInterface.addIndex("AdPerformance", ["Date"], {
-      name: "ad_performance_date_idx",
-    });
-
-    // Add indexes for Ad table
-    await queryInterface.addIndex("Ad", ["AdSetID"], {
-      name: "ad_adsetid_idx",
-    });
-
-    await queryInterface.addIndex("Ad", ["AGRS_CID"], {
-      name: "ad_agrs_cid_idx",
-    });
-
-    await queryInterface.addIndex("Ad", ["Status"], {
-      name: "ad_status_idx",
-    });
-
-    // Add indexes for AdSet table
-    await queryInterface.addIndex("AdSet", ["CampaignID"], {
-      name: "adset_campaignid_idx",
-    });
-
-    await queryInterface.addIndex("AdSet", ["Status"], {
-      name: "adset_status_idx",
-    });
-
-    // Add indexes for Campaign table
-    await queryInterface.addIndex("Campaign", ["AdAccountID"], {
-      name: "campaign_adaccountid_idx",
-    });
-
-    await queryInterface.addIndex("Campaign", ["Status"], {
-      name: "campaign_status_idx",
-    });
-
-    await queryInterface.addIndex("Campaign", ["CreatedTime"], {
-      name: "campaign_createdtime_idx",
-    });
-  },
-
-  down: async (queryInterface, Sequelize) => {
-    // Remove indexes in reverse order
-    await queryInterface.removeIndex("Campaign", "campaign_createdtime_idx");
-    await queryInterface.removeIndex("Campaign", "campaign_status_idx");
-    await queryInterface.removeIndex("Campaign", "campaign_adaccountid_idx");
-
-    await queryInterface.removeIndex("AdSet", "adset_status_idx");
-    await queryInterface.removeIndex("AdSet", "adset_campaignid_idx");
-
-    await queryInterface.removeIndex("Ad", "ad_status_idx");
-    await queryInterface.removeIndex("Ad", "ad_agrs_cid_idx");
-    await queryInterface.removeIndex("Ad", "ad_adsetid_idx");
-
-    await queryInterface.removeIndex(
-      "AdPerformance",
-      "ad_performance_date_idx"
-    );
-    await queryInterface.removeIndex(
-      "AdPerformance",
-      "ad_performance_date_adid_idx"
-    );
-  },
-};