agrs-sequelize-sdk 1.2.10 → 1.2.12

package/agrs-sequelize/models/AdPerformanceHourly.js

@@ -1,66 +0,0 @@
-// models/AdPerformanceHourly.js
-module.exports = (sequelize, DataTypes) => {
-  const AdPerformanceHourly = sequelize.define(
-    "AdPerformanceHourly",
-    {
-      Date: {
-        type: DataTypes.DATEONLY,
-        primaryKey: true,
-      },
-      Hour: {
-        type: DataTypes.INTEGER,
-        primaryKey: true,
-      },
-      AdID: {
-        type: DataTypes.STRING,
-        primaryKey: true,
-      },
-      AmountSpent: {
-        type: DataTypes.FLOAT,
-        allowNull: true,
-      },
-      Impressions: {
-        type: DataTypes.INTEGER,
-        allowNull: true,
-      },
-      LinkClicks: {
-        type: DataTypes.INTEGER,
-        allowNull: true,
-      },
-      ViewContent: {
-        // New field
-        type: DataTypes.INTEGER,
-        allowNull: true,
-      },
-      Search: {
-        // New field
-        type: DataTypes.INTEGER,
-        allowNull: true,
-      },
-      Purchase: {
-        // New field
-        type: DataTypes.INTEGER,
-        allowNull: true,
-      },
-      originalSpend: {
-        type: DataTypes.FLOAT,
-        allowNull: true,
-      },
-    },
-    {
-      tableName: "AdPerformanceHourly",
-      indexes: [
-        {
-          unique: true,
-          fields: ["AdID", "Date", "Hour"],
-        },
-      ],
-    }
-  );
-
-  AdPerformanceHourly.associate = (models) => {
-    AdPerformanceHourly.belongsTo(models.Ad, { foreignKey: "AdID" });
-  };
-
-  return AdPerformanceHourly;
-};

package/agrs-sequelize/models/AdSet.js

@@ -1,140 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-  const AdSet = sequelize.define(
-    "AdSet",
-    {
-      AdSetID: {
-        type: DataTypes.STRING,
-        primaryKey: true,
-      },
-      AdSetName: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      Status: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      daily_budget: {
-        type: DataTypes.INTEGER,
-        allowNull: true,
-      },
-      start_time: {
-        type: DataTypes.DATE,
-        allowNull: true,
-      },
-      end_time: {
-        type: DataTypes.DATE,
-        allowNull: true,
-      },
-      targeting: {
-        type: DataTypes.JSONB,
-        allowNull: true,
-      },
-      promotedObject: {
-        type: DataTypes.JSONB,
-        allowNull: true,
-      },
-      BillingEvent: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        defaultValue: "impressions",
-      },
-      OptimizationGoal: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        defaultValue: "offsite_conversions",
-      },
-      Draft: {
-        type: DataTypes.BOOLEAN,
-        allowNull: true,
-        defaultValue: false,
-      },
-      UserCreated: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      publish: {
-        type: DataTypes.BOOLEAN,
-        allowNull: true,
-        defaultValue: true,
-      },
-      CampaignID: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        references: {
-          model: "Campaign",
-          key: "CampaignID",
-        },
-      },
-      effectiveStatus: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      issuesInfo: {
-        type: DataTypes.JSONB,
-        allowNull: true,
-      },
-      bid_strategy: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      bid_amount: {
-        type: DataTypes.INTEGER,
-        allowNull: true,
-      },
-      waiting: {
-        type: DataTypes.BOOLEAN,
-        defaultValue: false,
-      },
-    },
-    {
-      tableName: "AdSet",
-      indexes: [
-        {
-          fields: ["CampaignID"],
-        },
-      ],
-    }
-  );
-
-  AdSet.associate = (models) => {
-    AdSet.belongsTo(models.Campaign, { foreignKey: "CampaignID" });
-    AdSet.hasMany(models.Ad, { foreignKey: "AdSetID" });
-    // Add this line to define the relationship with AdSetPerformance
-    AdSet.hasMany(models.AdSetPerformance, { foreignKey: "AdSetID" });
-  };
-
-  AdSet.addHook("beforeUpdate", async (adSet, options) => {
-    if (adSet.changed("publish")) {
-      if (adSet.previous("publish") === true && adSet.publish === false) {
-        await sequelize.models.AdSetHistory.create({
-          AdSetID: adSet.AdSetID,
-          DataSnapshot: adSet._previousDataValues,
-        });
-      } else if (
-        adSet.previous("publish") === false &&
-        adSet.publish === true
-      ) {
-        const latestHistory = await sequelize.models.AdSetHistory.findOne({
-          where: { AdSetID: adSet.AdSetID },
-          order: [["timestamp", "DESC"]],
-        });
-
-        if (latestHistory) {
-          await latestHistory.destroy();
-        }
-      }
-    }
-  });
-
-  AdSet.addHook("afterCreate", async (adSet, options) => {
-    if (adSet.publish === false) {
-      await sequelize.models.AdSetHistory.create({
-        AdSetID: adSet.AdSetID,
-        DataSnapshot: adSet.toJSON(),
-      });
-    }
-  });
-
-  return AdSet;
-};

package/agrs-sequelize/models/AdSetHistory.js

@@ -1,30 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-  const AdSetHistory = sequelize.define(
-    "AdSetHistory",
-    {
-      HistoryID: {
-        type: DataTypes.UUID,
-        defaultValue: DataTypes.UUIDV4,
-        primaryKey: true,
-      },
-      AdSetID: {
-        type: DataTypes.STRING,
-        allowNull: false,
-      },
-      DataSnapshot: {
-        type: DataTypes.JSONB, // Store the full AdSet row as a JSON object
-        allowNull: false,
-      },
-      timestamp: {
-        type: DataTypes.DATE,
-        defaultValue: DataTypes.NOW,
-      },
-    },
-    {
-      tableName: "AdSetHistory",
-      timestamps: false,
-    }
-  );
-
-  return AdSetHistory;
-};

package/agrs-sequelize/models/AdsetPerformance.js

@@ -1,116 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-  const AdSetPerformance = sequelize.define(
-    "AdSetPerformance",
-    {
-      AdSetID: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        primaryKey: true,
-        // Part of the composite primary key identifying the AdSet
-      },
-      Date: {
-        type: DataTypes.DATEONLY,
-        allowNull: false,
-        primaryKey: true,
-        // Part of the composite primary key representing the performance date
-      },
-      ChannelID: {
-        type: DataTypes.STRING,
-        allowNull: true,
-        // Optional identifier for the channel, extracted from AdSet name if available
-      },
-      StyleID: {
-        type: DataTypes.STRING,
-        allowNull: true,
-        // Optional identifier for the style, extracted from AdSet name if available
-      },
-      Spend: {
-        type: DataTypes.FLOAT,
-        defaultValue: 0,
-        // Total spend on the AdSet from the source platform (e.g., Facebook)
-      },
-      Impressions: {
-        type: DataTypes.INTEGER,
-        defaultValue: 0,
-        // Number of impressions recorded by the source platform
-      },
-      LinkClicks: {
-        type: DataTypes.INTEGER,
-        defaultValue: 0,
-        // Number of link clicks recorded by the source platform
-      },
-      ViewContent: {
-        type: DataTypes.INTEGER,
-        defaultValue: 0,
-        // Number of view content events recorded by the source platform
-      },
-      Search: {
-        type: DataTypes.INTEGER,
-        defaultValue: 0,
-        // Number of search events recorded by the source platform
-      },
-      Purchase: {
-        type: DataTypes.INTEGER,
-        defaultValue: 0,
-        // Number of purchase events recorded by the source platform
-      },
-      ExternalRevenue: {
-        type: DataTypes.FLOAT,
-        defaultValue: 0,
-        // Revenue data from an external source (e.g., analytics or monetization platforms)
-      },
-      ExternalImpressions: {
-        type: DataTypes.INTEGER,
-        defaultValue: 0,
-        // Number of impressions recorded by an external source
-      },
-      ExternalClicks: {
-        type: DataTypes.INTEGER,
-        defaultValue: 0,
-        // Number of clicks recorded by an external source
-      },
-      ExternalRequests: {
-        type: DataTypes.INTEGER,
-        defaultValue: 0,
-        // Number of requests recorded by an external source
-      },
-      ROI: {
-        type: DataTypes.FLOAT,
-        defaultValue: 0,
-        // Calculated Return on Investment (ExternalRevenue / Spend)
-      },
-      agrscid: {
-        type: DataTypes.STRING,
-        allowNull: true,
-        // Optional identifier for the AdSet, extracted from AdSet url if available
-      },
-      originalRevenue: {
-        type: DataTypes.FLOAT,
-        defaultValue: 0,
-        // Original revenue value before any modifications or calculations
-      }
-    },
-    {
-      tableName: "AdSetPerformance",
-      timestamps: false, // No need for createdAt/updatedAt timestamps
-      indexes: [
-        {
-          unique: true,
-          fields: ["AdSetID", "Date"],
-          // Composite unique index to ensure one record per AdSet per date
-        },
-      ],
-    }
-  );
-
-  // Define associations with other models
-  AdSetPerformance.associate = (models) => {
-    AdSetPerformance.belongsTo(models.AdSet, {
-      foreignKey: "AdSetID",
-      targetKey: "AdSetID",
-      // Links to the AdSet model for additional AdSet details
-    });
-  };
-
-  return AdSetPerformance;
-};

package/agrs-sequelize/models/Article.js

@@ -1,156 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-  const Article = sequelize.define(
-    "Article",
-    {
-      providerId: {
-        type: DataTypes.STRING,
-        allowNull: true,
-        unique: true,
-      },
-      category: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      AGRSAID: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        unique: true,
-      },
-      articleUrl: {
-        type: DataTypes.STRING(1024),
-        allowNull: true,
-      },
-      feed: {
-        type: DataTypes.STRING,
-        allowNull: false,
-      },
-      feedName: {
-        type: DataTypes.STRING,
-        allowNull: false,
-      },
-      vertical: {
-        type: DataTypes.STRING,
-        allowNull: false,
-      },
-      language: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        defaultValue: "en",
-      },
-      headline: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      topics: {
-        type: DataTypes.ARRAY(DataTypes.STRING),
-        allowNull: true,
-      },
-      mainKeyword: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      keywords: {
-        type: DataTypes.ARRAY(DataTypes.STRING),
-        allowNull: true,
-      },
-      date: {
-        type: DataTypes.DATE,
-        allowNull: true,
-        defaultValue: DataTypes.NOW,
-      },
-      nativeKeyword: {
-        type: DataTypes.STRING,
-        allowNull: false,
-      },
-      suggestedKeywords: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      articleExcerpt: {
-        type: DataTypes.TEXT,
-        allowNull: true,
-      },
-      articleContent: {
-        type: DataTypes.TEXT,
-        allowNull: true,
-      },
-      fbPixelId: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      status: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        defaultValue: "pending",
-        validate: {
-          isIn: [
-            [
-              "pending",
-              "approved",
-              "rejected",
-              "disapproved",
-              "duplicated",
-              "keyword_already_exists",
-              "invalid_vertical",
-              "invalid_language",
-              "in_review",
-              "error",
-            ],
-          ],
-        },
-      },
-      originalStatus: {
-        type: DataTypes.STRING,
-        allowNull: true,
-        comment: "Original status from Predicto before any mapping",
-      },
-      creationType: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        defaultValue: "slug",
-        validate: {
-          isIn: [["search", "slug"]],
-        },
-      },
-      createdAt: {
-        type: DataTypes.DATE,
-        defaultValue: DataTypes.NOW,
-      },
-      updatedAt: {
-        type: DataTypes.DATE,
-        defaultValue: DataTypes.NOW,
-      },
-      buyer: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      country: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      name: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-    },
-    {
-      tableName: "articles",
-      timestamps: true,
-    }
-  );
-
-  Article.associate = (models) => {
-    Article.hasMany(models.RSOCFeedCampaign, {
-      foreignKey: "AGRSAID",
-      sourceKey: "AGRSAID",
-      as: "RSOCFeedCampaigns",
-      constraints: false,
-    });
-  };
-
-  Article.prototype.isAvailableForCampaign = function () {
-    return ["approved", "keyword_already_exists"].includes(this.status);
-  };
-
-  return Article;
-};

package/agrs-sequelize/models/Buyers.js

@@ -1,26 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-    const Buyers = sequelize.define(
-      "Buyers",
-      {
-        id: {
-          type: DataTypes.UUID,
-          defaultValue: DataTypes.UUIDV4,
-          primaryKey: true,
-        },
-        name: {
-          type: DataTypes.STRING,
-          allowNull: false,
-        },
-        code: {
-            type: DataTypes.STRING,
-            allowNull: false,
-            unique: true, 
-        },
-      },
-      {
-        tableName: "Buyers",
-      }
-    );
-  
-    return Buyers;
-  };

package/agrs-sequelize/models/Campaign.js

@@ -1,136 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-  const Campaign = sequelize.define(
-    "Campaign",
-    {
-      CampaignID: {
-        type: DataTypes.STRING,
-        primaryKey: true,
-      },
-      CampaignName: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      pixelId: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      customEventType: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        defaultValue: "PURCHASE",
-      },
-      objective: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        defaultValue: "OUTCOME_SALES",
-      },
-      status: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      AdAccountID: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        references: {
-          model: "AdAccount",
-          key: "AdAccountID",
-        },
-      },
-      CreatedTime: {
-        type: DataTypes.DATE,
-        allowNull: false,
-      },
-      CampaignDelivery: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      DailyBudget: {
-        type: DataTypes.INTEGER,
-        allowNull: true,
-      },
-      Draft: {
-        type: DataTypes.BOOLEAN,
-        allowNull: true,
-        defaultValue: false,
-      },
-      publish: {
-        type: DataTypes.BOOLEAN,
-        allowNull: true,
-        defaultValue: true,
-      },
-      UserCreated: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      special_ad_categories: {
-        type: DataTypes.ARRAY(DataTypes.STRING),
-        allowNull: true,
-      },
-      effectiveStatus: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      issuesInfo: {
-        type: DataTypes.JSONB,
-        allowNull: true,
-      },
-      waiting: {
-        type: DataTypes.BOOLEAN,
-        defaultValue: false,
-      },
-    },
-    {
-      tableName: "Campaign",
-      indexes: [
-        {
-          fields: ["AdAccountID"], // Index on AdAccountID for faster joins
-        },
-      ],
-    }
-  );
-
-  // Define associations
-  Campaign.associate = (models) => {
-    Campaign.belongsTo(models.AdAccount, { foreignKey: "AdAccountID" });
-    Campaign.hasMany(models.AdSet, { foreignKey: "CampaignID" });
-  };
-
-  // Combined beforeUpdate hook
-  Campaign.addHook("beforeUpdate", async (campaign, options) => {
-    if (campaign.changed("publish")) {
-      if (campaign.previous("publish") === true && campaign.publish === false) {
-        // Save current state to CampaignHistory
-        await sequelize.models.CampaignHistory.create({
-          CampaignID: campaign.CampaignID,
-          DataSnapshot: campaign._previousDataValues, // Store current state as JSON
-        });
-      } else if (
-        campaign.previous("publish") === false &&
-        campaign.publish === true
-      ) {
-        // Delete the latest history entry
-        const latestHistory = await sequelize.models.CampaignHistory.findOne({
-          where: { CampaignID: campaign.CampaignID },
-          order: [["timestamp", "DESC"]], // Get the latest history entry
-        });
-
-        if (latestHistory) {
-          await latestHistory.destroy(); // Delete the latest history entry
-        }
-      }
-    }
-  });
-
-  Campaign.addHook("afterCreate", async (campaign, options) => {
-    if (campaign.publish === false) {
-      // If publish is false on creation, save a snapshot to CampaignHistory
-      await sequelize.models.CampaignHistory.create({
-        CampaignID: campaign.CampaignID,
-        DataSnapshot: campaign.toJSON(), // Save current state
-      });
-    }
-  });
-  
-
-  return Campaign;
-};