agrs-sequelize-sdk 1.4.22 → 1.4.25

package/.worktrees/aicampaign-queue-group-id/models/Pages.js

@@ -0,0 +1,105 @@
+module.exports = (sequelize, DataTypes) => {
+  const Pages = sequelize.define(
+    "Pages",
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+      name: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      code: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true,
+      },
+      link: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      feedProvider: {
+        type: DataTypes.ARRAY(DataTypes.STRING),
+        allowNull: false,
+        defaultValue: [], // Default value is an empty array
+      },
+      tasks: {
+        type: DataTypes.ARRAY(DataTypes.STRING),
+        allowNull: false,
+        defaultValue: [], // Default value is an empty array
+      },
+      is_published: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: true,
+      },
+      Category: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      Owner: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      Status: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      AdLibrary: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      BusinessManager: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      Users: {
+        type: DataTypes.ARRAY(DataTypes.STRING),
+        allowNull: false,
+        defaultValue: [],
+      },
+      Archived: {
+        type: DataTypes.BOOLEAN,
+        allowNull: true,
+      },
+      ads_limit: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        defaultValue: 0,
+        comment:
+          "Number of currently active ads running on this page (Max limit: 250)",
+      },
+      instagram_user_id: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment:
+          "Instagram User ID (Page-backed Instagram Account ID) for this page",
+      },
+      promotion_eligible: {
+        type: DataTypes.BOOLEAN,
+        allowNull: true,
+        defaultValue: true,
+        comment:
+          "Whether this page is eligible for advertising (synced from Facebook promotion_eligible field)",
+      },
+      // access_token: {
+      //   type: DataTypes.STRING,
+      //   allowNull: true,
+      //   comment: "Facebook page access token",
+      // },
+      platform: {
+        type: DataTypes.ENUM("fb", "tt", "snp"),
+        allowNull: false,
+        defaultValue: "fb",
+        comment: "Ad platform identifier: fb=Facebook, tt=TikTok, snp=Snapchat",
+      },
+    },
+    {
+      tableName: "Pages",
+    }
+  );
+
+  return Pages;
+};

package/.worktrees/aicampaign-queue-group-id/models/PipelineExecution.js

@@ -0,0 +1,59 @@
+module.exports = (sequelize, DataTypes) => {
+  const PipelineExecution = sequelize.define(
+    "PipelineExecution",
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+      startTime: {
+        type: DataTypes.DATE,
+        allowNull: false,
+      },
+      endTime: {
+        type: DataTypes.DATE,
+        allowNull: false,
+      },
+      status: {
+        type: DataTypes.ENUM("success", "failed"),
+        allowNull: false,
+      },
+      fbDaysBack: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+      },
+      codeFuelDaysBack: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+      },
+      tonicDaysBack: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+      },
+      compadoDaysBack: { // Added missing column
+        type: DataTypes.INTEGER,
+        allowNull: true,
+      },
+      cfn2sDaysBack: { // Added missing column
+        type: DataTypes.INTEGER,
+        allowNull: true,
+      },
+      error: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+      },
+      feedTimestamps: { // Added new column for feed timestamps
+        type: DataTypes.JSONB, // Use JSONB for PostgreSQL
+        allowNull: true,
+        field: 'feed_timestamps', // Map to snake_case column name
+      },
+    },
+    {
+      tableName: "pipeline_executions",
+      timestamps: true,
+    }
+  );
+
+  return PipelineExecution;
+};

package/.worktrees/aicampaign-queue-group-id/models/PolicyDogsCreativeCache.js

@@ -0,0 +1,50 @@
+module.exports = (sequelize, DataTypes) => {
+  const PolicyDogsCreativeCache = sequelize.define(
+    "PolicyDogsCreativeCache",
+    {
+      id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      ad_account_id: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: "Facebook ad account ID (e.g., act_123456)",
+      },
+      page_id: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: "Facebook page ID used in the creative",
+      },
+      dog_url: {
+        type: DataTypes.TEXT,
+        allowNull: false,
+        comment: "The dog article URL used in the creative",
+      },
+      creative_id: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: "Facebook creative ID to reuse",
+      },
+      created_at: {
+        type: DataTypes.DATE,
+        allowNull: false,
+        defaultValue: DataTypes.NOW,
+      },
+    },
+    {
+      tableName: "policy_dogs_creative_cache",
+      timestamps: false,
+      indexes: [
+        {
+          unique: true,
+          fields: ["ad_account_id", "page_id", "dog_url"],
+          name: "idx_dogs_creative_cache_unique",
+        },
+      ],
+    }
+  );
+
+  return PolicyDogsCreativeCache;
+};

package/.worktrees/aicampaign-queue-group-id/models/PolicyDogsImageCache.js

@@ -0,0 +1,30 @@
+module.exports = (sequelize, DataTypes) => {
+  const PolicyDogsImageCache = sequelize.define(
+    "PolicyDogsImageCache",
+    {
+      ad_account_id: {
+        type: DataTypes.STRING,
+        primaryKey: true,
+        allowNull: false,
+        comment: "Facebook ad account ID (e.g., act_123456)",
+      },
+      image_hash: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: "Facebook image hash for the dog image uploaded to this account",
+      },
+      uploaded_at: {
+        type: DataTypes.DATE,
+        allowNull: false,
+        defaultValue: DataTypes.NOW,
+        comment: "When the image was uploaded to this ad account",
+      },
+    },
+    {
+      tableName: "policy_dogs_image_cache",
+      timestamps: false,
+    }
+  );
+
+  return PolicyDogsImageCache;
+};

package/.worktrees/aicampaign-queue-group-id/models/Presets.js

@@ -0,0 +1,40 @@
+// models/Presets.js
+module.exports = (sequelize, DataTypes) => {
+  const Presets = sequelize.define("Presets", {
+    id: {
+      type: DataTypes.UUID,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true,
+    },
+    name: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+    feeds: {
+      type: DataTypes.JSONB,
+      allowNull: true,
+    },
+    userId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Users',
+        key: 'id',
+      },
+    },
+    platform: {
+      type: DataTypes.ENUM("fb", "tt", "snp"),
+      allowNull: false,
+      defaultValue: "fb",
+      comment: "Ad platform identifier: fb=Facebook, tt=TikTok, snp=Snapchat",
+    },
+  }, {
+    tableName: "Presets",
+  });
+
+  Presets.associate = (models) => {
+    Presets.belongsTo(models.Users, { foreignKey: 'userId', as: 'user' });
+  };
+
+  return Presets;
+};

package/.worktrees/aicampaign-queue-group-id/models/RSOCFeedCampaign.js

@@ -0,0 +1,375 @@
+module.exports = (sequelize, DataTypes) => {
+  const RSOCFeedCampaign = sequelize.define(
+    "RSOCFeedCampaign",
+    {
+      AGRS_CID: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true,
+        primaryKey: true,
+      },
+      AGRSAID: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: "ID referencing Article.AGRSAID",
+      },
+      articleName: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: "Name of the associated article",
+      },
+      channelId: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: "ID referencing Channel.channelId",
+      },
+      styleId: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: "Style ID (stid) inherited from Channel",
+      },
+      assignee: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      status: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        defaultValue: "active",
+        validate: {
+          isIn: [["active", "inactive", "archived"]],
+        },
+      },
+      country: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      vertical: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: "Maps to Article.category for dynamic selection",
+      },
+      freeText: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+      },
+      campaignName: {
+        type: DataTypes.TEXT,
+        allowNull: false,
+      },
+      campaignId: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      keywords: {
+        type: DataTypes.ARRAY(DataTypes.STRING),
+        allowNull: true,
+      },
+      MainKeyword: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment:
+          "Primary/main keyword for the campaign, typically the first keyword from Predicto custom_query",
+      },
+      link: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        comment: "Campaign-specific URL based on article URL with parameters",
+      },
+      redirectLink: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+      },
+      pixelId: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+      },
+      pixelEvent: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+      },
+      token: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+      },
+      accountId: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      feedName: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        defaultValue: "RSOC",
+      },
+      feedType: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: "Type of feed campaign",
+      },
+      adTitle: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      domain: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        defaultValue: "sportfoy.com",
+        comment:
+          "Target domain for campaign URLs (searchlabz.com or sportfoy.com)",
+      },
+      url_structure: {
+        type: DataTypes.ENUM("legacy", "unified"),
+        allowNull: false,
+        defaultValue: "legacy",
+        comment:
+          "URL structure type: legacy (slug-based) or unified (search-based)",
+      },
+      feedProvider: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        defaultValue: "RSOC",
+      },
+      createdCampaignAt: {
+        type: DataTypes.DATE,
+        allowNull: true,
+        defaultValue: DataTypes.NOW,
+      },
+      draft: {
+        type: DataTypes.BOOLEAN,
+        allowNull: true,
+        defaultValue: false,
+      },
+      openedFromDashboard: {
+        type: DataTypes.BOOLEAN,
+        allowNull: true,
+        defaultValue: null,
+        comment:
+          "Tracks if the campaign was opened/viewed from the dashboard, allow null for campaigns created before this field was added",
+      },
+      createdAt: {
+        type: DataTypes.DATE,
+        allowNull: false,
+        defaultValue: DataTypes.NOW,
+      },
+      updatedAt: {
+        type: DataTypes.DATE,
+        allowNull: false,
+        defaultValue: DataTypes.NOW,
+      },
+      platform: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      mediaBuyer: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      Partner: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: "Partner associated with the campaign",
+      },
+      language: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: "Language code for the campaign",
+      },
+      feed_id: {
+        type: DataTypes.UUID,
+        allowNull: true,
+        comment: "ID referencing DynamicFeed.id for dynamic feeds",
+      },
+    },
+    {
+      tableName: "rsoc_feed_campaigns",
+      timestamps: true,
+    }
+  );
+
+  // Define associations without enforcing foreign key constraints
+  RSOCFeedCampaign.associate = (models) => {
+    if (models.Article) {
+      RSOCFeedCampaign.belongsTo(models.Article, {
+        foreignKey: "AGRSAID",
+        targetKey: "AGRSAID",
+        as: "Article",
+        constraints: false,
+      });
+    }
+
+    if (models.Channel) {
+      RSOCFeedCampaign.belongsTo(models.Channel, {
+        foreignKey: "channelId",
+        targetKey: "channelId",
+        as: "Channel",
+        constraints: false,
+      });
+    }
+
+    if (models.DynamicFeed) {
+      RSOCFeedCampaign.belongsTo(models.DynamicFeed, {
+        foreignKey: "feed_id",
+        targetKey: "id",
+        as: "DynamicFeed",
+        constraints: false,
+      });
+    }
+  };
+
+  // BeforeCreate hook: Update Channel status and connectedCampaigns
+  RSOCFeedCampaign.beforeCreate(async (campaign, options) => {
+    campaign.setDataValue("redirectLink", null);
+
+    // Set default domain and url_structure if not provided
+    if (!campaign.domain) {
+      campaign.setDataValue("domain", "sportfoy.com");
+    }
+    if (!campaign.url_structure) {
+      campaign.setDataValue("url_structure", "legacy");
+    }
+
+    // Auto-adjust url_structure based on domain
+    if (
+      campaign.domain === "sportfoy.com" &&
+      campaign.url_structure === "legacy"
+    ) {
+      campaign.setDataValue("url_structure", "unified");
+    }
+
+    // Skip channel update if in a silent operation (e.g., during sync)
+    if (options.silent) return;
+
+    try {
+      const channel = await sequelize.models.Channel.findOne({
+        where: {
+          channelId: campaign.channelId,
+          styleId: campaign.styleId || null,
+        },
+      });
+
+      if (channel) {
+        const connectedCampaigns = channel.connectedCampaigns || [];
+        if (
+          !connectedCampaigns.some((c) => c.campaignId === campaign.AGRS_CID)
+        ) {
+          connectedCampaigns.push({
+            campaignId: campaign.AGRS_CID,
+            assignedAt: new Date(),
+            releasedAt: null,
+          });
+          await channel.update(
+            {
+              status: "used",
+              connectedCampaigns,
+            },
+            { silent: true }
+          );
+        }
+      } else {
+        console.warn(
+          `Channel not found for channelId: ${campaign.channelId}, styleId: ${campaign.styleId}`
+        );
+      }
+    } catch (error) {
+      console.error("Error in beforeCreate hook:", error.message);
+    }
+  });
+
+  // BeforeUpdate hook: Handle channel reassignment
+  RSOCFeedCampaign.beforeUpdate(async (campaign, options) => {
+    campaign.setDataValue("redirectLink", null);
+
+    // Auto-adjust url_structure based on domain if domain changed
+    if (campaign.changed("domain")) {
+      if (
+        campaign.domain === "sportfoy.com" &&
+        campaign.url_structure === "legacy"
+      ) {
+        campaign.setDataValue("url_structure", "unified");
+      }
+    }
+
+    // Skip channel update if in a silent operation or no relevant changes
+    if (
+      options.silent ||
+      (!campaign.changed("channelId") && !campaign.changed("styleId"))
+    ) {
+      return;
+    }
+
+    try {
+      const oldChannelId = campaign.previous("channelId");
+      const oldStyleId = campaign.previous("styleId") || null;
+      const newChannelId = campaign.channelId;
+      const newStyleId = campaign.styleId || null;
+
+      // Release old channel
+      if (
+        oldChannelId &&
+        (oldChannelId !== newChannelId || oldStyleId !== newStyleId)
+      ) {
+        const oldChannel = await sequelize.models.Channel.findOne({
+          where: {
+            channelId: oldChannelId,
+            styleId: oldStyleId,
+          },
+        });
+
+        if (oldChannel) {
+          const connectedCampaigns = oldChannel.connectedCampaigns || [];
+          const updatedCampaigns = connectedCampaigns
+            .map((c) =>
+              c.campaignId === campaign.AGRS_CID
+                ? { ...c, releasedAt: new Date() }
+                : c
+            )
+            .filter((c) => !c.releasedAt);
+
+          await oldChannel.update(
+            {
+              connectedCampaigns: updatedCampaigns,
+              status: updatedCampaigns.length > 0 ? "used" : "free",
+            },
+            { silent: true }
+          );
+        }
+      }
+
+      // Assign new channel
+      const newChannel = await sequelize.models.Channel.findOne({
+        where: {
+          channelId: newChannelId,
+          styleId: newStyleId,
+        },
+      });
+
+      if (newChannel) {
+        const connectedCampaigns = newChannel.connectedCampaigns || [];
+        if (
+          !connectedCampaigns.some((c) => c.campaignId === campaign.AGRS_CID)
+        ) {
+          connectedCampaigns.push({
+            campaignId: campaign.AGRS_CID,
+            assignedAt: new Date(),
+            releasedAt: null,
+          });
+          await newChannel.update(
+            {
+              status: "used",
+              connectedCampaigns,
+            },
+            { silent: true }
+          );
+        }
+      } else {
+        console.warn(
+          `New channel not found for channelId: ${newChannelId}, styleId: ${newStyleId}`
+        );
+      }
+    } catch (error) {
+      console.error("Error in beforeUpdate hook:", error.message);
+    }
+  });
+
+  return RSOCFeedCampaign;
+};