agrs-sequelize-sdk 1.1.98 → 1.2.0

package/agrs-sequelize/models/RSOCFeedCampaign.js

@@ -0,0 +1,302 @@
+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.STRING,
+        allowNull: false,
+      },
+      campaignId: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      keywords: {
+        type: DataTypes.ARRAY(DataTypes.STRING),
+        allowNull: true,
+      },
+      link: {
+        type: DataTypes.STRING(1024),
+        allowNull: true,
+        comment: "Campaign-specific URL based on article URL with parameters",
+      },
+      redirectLink: {
+        type: DataTypes.STRING(1024),
+        allowNull: true,
+      },
+      pixelId: {
+        type: DataTypes.STRING(1024),
+        allowNull: true,
+      },
+      token: {
+        type: DataTypes.STRING(1024),
+        allowNull: true,
+      },
+      accountId: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      feedName: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        defaultValue: "RSOC",
+      },
+      adTitle: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      domain: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      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,
+      },
+      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,
+      },
+    },
+    {
+      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.Ad) {
+      RSOCFeedCampaign.hasMany(models.Ad, {
+        foreignKey: "AGRS_CID",
+        sourceKey: "AGRS_CID",
+        as: "Ads",
+        constraints: false,
+      });
+    }
+  };
+
+  // BeforeCreate hook: Update Channel status and connectedCampaigns
+  RSOCFeedCampaign.beforeCreate(async (campaign, options) => {
+    campaign.setDataValue("redirectLink", null);
+
+    // 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);
+
+    // 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(
+          `Channel not found for channelId: ${newChannelId}, styleId: ${newStyleId}`
+        );
+      }
+    } catch (error) {
+      console.error("Error in beforeUpdate hook:", error.message);
+    }
+  });
+
+  return RSOCFeedCampaign;
+};

package/agrs-sequelize/models/RsocKeywordPerformance.js

@@ -0,0 +1,111 @@
+module.exports = (sequelize, DataTypes) => {
+    const RsocKeywordPerformance = sequelize.define('RsocKeywordPerformance', {
+        id: {
+            type: DataTypes.INTEGER,
+            primaryKey: true,
+            autoIncrement: true,
+            allowNull: false
+        },
+        ts: {
+            type: DataTypes.DATE,
+            allowNull: false,
+            comment: 'Timestamp of the record'
+        },
+        channel_id: {
+            type: DataTypes.STRING,
+            allowNull: false,
+            comment: 'Channel identifier'
+        },
+        style_id: {
+            type: DataTypes.STRING,
+            allowNull: true,
+            comment: 'Style identifier'
+        },
+        country_code: {
+            type: DataTypes.STRING(2),
+            allowNull: true,
+            comment: 'Country code (ISO 2-letter)'
+        },
+        custom_query: {
+            type: DataTypes.TEXT,
+            allowNull: true,
+            comment: 'Custom search query'
+        },
+        query: {
+            type: DataTypes.TEXT,
+            allowNull: true,
+            comment: 'Standard search query'
+        },
+        funnel_page_views: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            defaultValue: 0,
+            comment: 'Number of funnel page views'
+        },
+        funnel_impressions: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            defaultValue: 0,
+            comment: 'Number of funnel impressions'
+        },
+        funnel_clicks: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            defaultValue: 0,
+            comment: 'Number of funnel clicks'
+        },
+        page_views: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            defaultValue: 0,
+            comment: 'Number of page views'
+        },
+        impressions: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            defaultValue: 0,
+            comment: 'Number of impressions'
+        },
+        clicks: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            defaultValue: 0,
+            comment: 'Number of clicks'
+        },
+        agrs_cid: {
+            type: DataTypes.STRING,
+            allowNull: true,
+            comment: 'AGRS campaign identifier linking to campaign data'
+        }
+    }, {
+        tableName: 'rsoc_keyword_performance',
+        timestamps: true, // Adds createdAt and updatedAt columns
+        indexes: [
+            {
+                fields: ['channel_id', 'ts'],
+                name: 'idx_rsoc_keyword_channel_time'
+            },
+            {
+                fields: ['style_id'],
+                name: 'idx_rsoc_keyword_style'
+            },
+            {
+                fields: ['country_code'],
+                name: 'idx_rsoc_keyword_country'
+            },
+            {
+                fields: ['agrs_cid'],
+                name: 'idx_rsoc_keyword_agrs_cid'
+            }
+        ]
+    });
+
+    // Define associations if needed
+    RsocKeywordPerformance.associate = (models) => {
+        // Add associations here if your table needs to reference other tables
+        // For example:
+        // RsocKeywordPerformance.belongsTo(models.Channel, { foreignKey: 'channel_id' });
+    };
+
+    return RsocKeywordPerformance;
+};

package/agrs-sequelize/models/Rule.js

@@ -0,0 +1,39 @@
+module.exports = (sequelize, DataTypes) => {
+  const Rule = sequelize.define("Rule", {
+    ruleName: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+    timeUnit: {
+      type: DataTypes.ENUM("minutes", "hours", "days"),
+      allowNull: false,
+    },
+    timeValue: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+    },
+    daysAndTimes: {
+      type: DataTypes.JSONB, // Store days, time ranges, and conditions as a JSON object
+      allowNull: true,
+    },
+    filters: {
+      type: DataTypes.JSONB,
+      allowNull: true,
+    },
+    triggers: {
+      type: DataTypes.JSONB,
+      allowNull: false,
+    },
+    actions: {
+      type: DataTypes.JSONB,
+      allowNull: false,
+    },
+    status: {
+      type: DataTypes.ENUM("active", "paused"),
+      allowNull: false,
+      defaultValue: "active",
+    },
+  });
+
+  return Rule;
+};

package/agrs-sequelize/models/RulesValues.js

@@ -0,0 +1,56 @@
+module.exports = (sequelize, DataTypes) => {
+  const RulesValues = sequelize.define(
+    "RulesValues",
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+      },
+      name: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      code: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true,
+      },
+      permissions: {
+        type: DataTypes.ARRAY(DataTypes.STRING),
+        allowNull: false,
+        defaultValue: [],
+      },
+      feature: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      parentId: {
+        type: DataTypes.UUID,
+        allowNull: true,
+        references: {
+          model: "RulesValues",
+          key: "id",
+        },
+        onDelete: "CASCADE",
+      },
+    },
+    {
+      tableName: "RulesValues",
+    }
+  );
+
+  // Self-referential association to define sub-rules
+  RulesValues.hasMany(RulesValues, {
+    as: "subRules",
+    foreignKey: "parentId",
+    onDelete: "CASCADE",
+  });
+
+  RulesValues.belongsTo(RulesValues, {
+    as: "parentRule",
+    foreignKey: "parentId",
+  });
+
+  return RulesValues;
+};

package/agrs-sequelize/models/SupportedLocale.js

@@ -0,0 +1,24 @@
+module.exports = (sequelize, DataTypes) => {
+    const SupportedLocale = sequelize.define('SupportedLocale', {
+      country: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      locale: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      language: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: 'Language code (e.g., en, es, fr)'
+      }
+    });
+  
+    // Define associations if needed in the future
+    // SupportedLocale.associate = (models) => {
+    //   // e.g., SupportedLocale.hasMany(models.OtherModel);
+    // };
+  
+    return SupportedLocale;
+  };

package/agrs-sequelize/models/TonicCampaign.js

@@ -0,0 +1,97 @@
+const { DataTypes } = require("sequelize");
+
+module.exports = (sequelize, DataTypes) => {
+  const TonicCampaign = sequelize.define("TonicCampaign", {
+    AGRSCID: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      unique: true,
+      primaryKey: true,
+    },
+    CampaignName: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+    CampaignID: {
+      type: DataTypes.STRING,
+      allowNull: true,
+    },
+    Vertical: {
+      type: DataTypes.STRING,
+      allowNull: true,
+    },
+    Offer: {
+      type: DataTypes.STRING,
+      allowNull: true,
+    },
+    OfferID: {
+      type: DataTypes.STRING,
+      allowNull: true,
+    },
+    Country: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+    Domain: {
+      type: DataTypes.STRING,
+      allowNull: true,
+    },
+    Imprint: {
+      type: DataTypes.STRING,
+      allowNull: true,
+      defaultValue: "no",
+    },
+    Status: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      defaultValue: "inactive",
+    },
+    FinalLink: {
+      type: DataTypes.STRING(1024),
+      allowNull: true,
+    },
+    Assignee: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+    KW: {
+      type: DataTypes.ARRAY(DataTypes.STRING),
+      allowNull: true,
+    },
+    PixelID: {
+      type: DataTypes.STRING(1024),
+      allowNull: true,
+    },
+    Token: {
+      type: DataTypes.STRING(1024),
+      allowNull: true,
+    },
+    AccountID: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+    FeedName: {
+      type: DataTypes.STRING,
+      allowNull: true,
+    },
+    AdTitle: {
+      type: DataTypes.STRING,
+      allowNull: true,
+    },
+    Target: {
+      type: DataTypes.STRING,
+      allowNull: true,
+    },
+  });
+
+  TonicCampaign.associate = (models) => {
+    TonicCampaign.hasMany(models.Ad, {
+      foreignKey: "AGRS_CID",
+      sourceKey: "AGRSCID",
+      constraints: false, // Disable the strict foreign key constraint
+      as: "Ads",
+    });
+  };
+
+  return TonicCampaign;
+};