agrs-sequelize-sdk 1.2.10 → 1.2.12

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/agrs-sequelize/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Agressive Scale LTD
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/agrs-sequelize/README.md

@@ -1,179 +0,0 @@
-# agrs-sequelize SDK
-
-The `agrs-sequelize` SDK provides a structured way to manage your database models using Sequelize ORM. It allows you to easily add, update, and manage models, with support for publishing updates to NPM and pushing changes to GitHub.
-
-## Table of Contents
-
-- [Prerequisites](#prerequisites)
-- [Installation](#installation)
-- [Usage](#usage)
-  - [Adding or Modifying Models](#adding-or-modifying-models)
-  - [Model Loading](#model-loading)
-- [Publishing Changes](#publishing-changes)
-  - [Using PowerShell (Windows)](#using-powershell-windows)
-  - [Using Bash (Linux/macOS)](#using-bash-linuxmacos)
-- [Script Details](#script-details)
-  - [run.ps1 (PowerShell Script for Windows)](#runps1-powershell-script-for-windows)
-  - [run.sh (Bash Script for Linux/macOS)](#runsh-bash-script-for-linuxmacos)
-- [Example Model File](#example-model-file)
-- [Versioning](#versioning)
-- [Troubleshooting](#troubleshooting)
-- [License](#license)
-
-## Prerequisites
-
-Ensure the following dependencies are installed on your system:
-
-- **Node.js**: [Download Node.js](https://nodejs.org/)
-- **Sequelize**: Used for database interaction.
-- **Git**: Required for version control and publishing changes to GitHub.
-- **npm**: For managing and publishing packages.
-- **PowerShell** (Windows) or **Bash** (Linux/macOS): For running automation scripts.
-
-## Installation
-
-1. **Clone the Repository:**
-
-   ```bash
-   git clone https://github.com/your-repo/agrs-sequelize.git
-   cd agrs-sequelize
-    ```
-
-2. **Install Dependencies:**
-
-   ```bash
-        npm install
-    ```
-
-
-# Usage
-
-## Adding or Modifying Models
-To add or modify models in the agrs-sequelize SDK:
-
-1. **Create or Edit a Model:**
-
-    - Add a new model file inside the models directory or edit an existing one.
-    - Each model file should export a function that initializes the model with Sequelize.
-
-```javascript
-// models/YourModel.js
-module.exports = (sequelize, DataTypes) => {
-  const YourModel = sequelize.define('YourModel', {
-    fieldName: {
-      type: DataTypes.STRING,
-      allowNull: false,
-    },
-  });
-
-  // Define associations (optional)
-  YourModel.associate = (models) => {
-    YourModel.hasMany(models.OtherModel);
-  };
-
-  return YourModel;
-}; 
-```
-
-2. **Define Associations (if required):**
-
-    Use the associate method to define relationships with other models.
-    Associations like hasMany, belongsTo, etc., are supported.
-### Model Loading
-    Models are automatically loaded when initializing Sequelize.
-    The index.js file ensures all models in the models directory are properly loaded and associated.
-
-## Publishing Changes
- After modifying or adding models, publish the changes to NPM and GitHub.
-
-### Using PowerShell (Windows)
-Open PowerShell as Administrator.
-
-Run the Script:
-
-```powershell
-./run.ps1
-```
-The script will:
-
-- Check for jq installation.
-- Bump the version in package.json.
-- Publish to NPM.
-- Commit and push changes to GitHub.
-
-### Using Bash (Linux/macOS)
-Open a Bash Terminal.
-
-Run the Script:
-
-```bash
-./run.sh
-```
-The script performs the same tasks as the PowerShell script, tailored for Bash environments.
-
-## Script Details
-### run.ps1 (PowerShell Script for Windows)
-Automates the publishing process:
-
-- Ensures jq is installed.
-- Increments the version in package.json.
-- Publishes the package to NPM.
-- Commits and pushes changes to GitHub.
-
-### run.sh (Bash Script for Linux/macOS)
-Provides similar functionality:
-
-- Checks for jq installation.
-- Bumps the package version.
-= Publishes to NPM.
-= Commits and pushes to GitHub.
-
-## Example Model File
-```javascript
-Copy code
-// models/YourModel.js
-module.exports = (sequelize, DataTypes) => {
-  const YourModel = sequelize.define('YourModel', {
-    name: {
-      type: DataTypes.STRING,
-      allowNull: false,
-    },
-  });
-
-  // Define associations (optional)
-  YourModel.associate = (models) => {
-    YourModel.hasMany(models.OtherModel);
-  };
-
-  return YourModel;
-};
-```
-In this example:
-
-YourModel has a name field.
-It has a hasMany association with OtherModel.
-## Versioning
-Versioning is handled automatically:
-
-- The scripts increment the version in package.json.
-- Follows semantic versioning (major, minor, patch).
-- Updated versions are published to NPM and committed to the repository.
-
-## Troubleshooting
-- ### Permission Issues:
-
-   - Linux/macOS: Ensure scripts have execute permissions (chmod +x run.sh).
-- ### NPM Login Errors:
-
-   - The script will prompt for NPM login if not already logged in.
-   - Verify NPM account credentials.
-
-- ### Missing Dependencies:
-
-   - The script checks for jq and installs it if missing.
-## License
-This project is licensed under the MIT License. See the LICENSE file for details.
-
-
-
-