agrs-sequelize-sdk 1.2.10 → 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/models/RSOCFeedCampaign.js

@@ -132,7 +132,7 @@ module.exports = (sequelize, DataTypes) => {
         type: DataTypes.STRING,
         allowNull: true,
       },
-      language1: {
+      language: {
         type: DataTypes.STRING,
         allowNull: true,
         comment: "Language code for the campaign",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agrs-sequelize-sdk",
-  "version": "1.2.10",
+  "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
+);