agrs-sequelize-sdk 1.1.94 → 1.1.97

package/agrs-sequelize/models/Folders.js

@@ -1,133 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-  const Folders = sequelize.define("Folders", {
-    id: {
-      type: DataTypes.STRING,
-      primaryKey: true,
-    },
-    ParentFolder: {
-      type: DataTypes.STRING, // Self-referencing folder ID
-      allowNull: true,
-    },
-    ParentFolders: {
-      type: DataTypes.ARRAY(DataTypes.STRING), // Array of folder IDs
-      allowNull: true,
-    },
-    name: {
-      type: DataTypes.STRING,
-      allowNull: false,
-    },
-    FilesCount: {
-      type: DataTypes.INTEGER,
-      allowNull: true,
-      defaultValue: 0,
-    }
-  });
-
-  Folders.associate = function (models) {
-    // One-to-many: A folder can have many files
-    Folders.hasMany(models.Files, { foreignKey: "ParentFolder", sourceKey: "id" });
-
-    // Self-referencing: A folder can have subfolders
-    Folders.hasMany(models.Folders, { foreignKey: "ParentFolder", sourceKey: "id" });
-    Folders.belongsTo(models.Folders, { foreignKey: "ParentFolder", targetKey: "id" });
-  };
-
-  // Function to count files and subfolders for each parent folder in ParentFolders array
-  Folders.countFilesAndSubfolders = async function (parentFolderIds) {
-    try {
-      const { Files } = sequelize.models; // Move the reference inside the function
-      
-      // Loop through each parent folder ID
-      for (const parentFolderId of parentFolderIds) {
-        // Find the parent folder by ID
-        const parentFolder = await Folders.findOne({ where: { id: parentFolderId } });
-
-        if (!parentFolder) {
-          console.warn(`Folder with ID ${parentFolderId} not found.`);
-          continue;
-        }
-
-        // Count the number of files directly under this folder
-        const fileCount = await Files.count({
-          where: { ParentFolder: parentFolder.id }
-        });
-
-        // Count the number of subfolders directly under this folder
-        const subfolderCount = await Folders.count({
-          where: { ParentFolder: parentFolder.id }
-        });
-
-        // Total count is files + subfolders
-        const totalFilesCount = fileCount + subfolderCount;
-
-        // Update the FilesCount field in the parent folder
-        await parentFolder.update({ FilesCount: totalFilesCount });
-      }
-    } catch (error) {
-      console.error(error);
-      throw error;
-    }
-  };
-
-  // Add a hook that triggers after a folder is created, updated, or deleted
-  Folders.addHook('afterCreate', async (folder, options) => {
-    if (folder.ParentFolders && folder.ParentFolders.length > 0) {
-      await Folders.countFilesAndSubfolders(folder.ParentFolders);
-    }
-  });
-
-  Folders.addHook('afterDestroy', async (folder, options) => {
-    if (folder.ParentFolders && folder.ParentFolders.length > 0) {
-      await Folders.countFilesAndSubfolders(folder.ParentFolders);
-    }
-  });
-
-  Folders.addHook('afterUpdate', async (folder, options) => {
-    if (folder.ParentFolders && folder.ParentFolders.length > 0) {
-      await Folders.countFilesAndSubfolders(folder.ParentFolders);
-    }
-  });
-
-  // Add hooks for Files
-  sequelize.models.Files.addHook('afterCreate', async (file, options) => {
-    if (file.ParentFolders && file.ParentFolders.length > 0) {
-      await Folders.countFilesAndSubfolders(file.ParentFolders);
-    } else if (file.ParentFolder) {
-      await Folders.countFilesAndSubfolders([file.ParentFolder]);
-    }
-  });
-
-  sequelize.models.Files.addHook('afterDestroy', async (file, options) => {
-    if (file.ParentFolders && file.ParentFolders.length > 0) {
-      await Folders.countFilesAndSubfolders(file.ParentFolders);
-    } else if (file.ParentFolder) {
-      await Folders.countFilesAndSubfolders([file.ParentFolder]);
-    }
-  });
-
-  sequelize.models.Files.addHook('afterUpdate', async (file, options) => {
-    if (file.ParentFolders && file.ParentFolders.length > 0) {
-      await Folders.countFilesAndSubfolders(file.ParentFolders);
-    } else if (file.ParentFolder) {
-      await Folders.countFilesAndSubfolders([file.ParentFolder]);
-    }
-  });
-
-    // Add a hook before saving the folder to check ParentFolders
-  Folders.addHook('beforeSave', (folder, options) => {
-    // If ParentFolders is an empty array or contains only nulls, set it to null
-    if (folder.ParentFolders && (folder.ParentFolders.length === 0 || folder.ParentFolders.every(f => f === null))) {
-      folder.ParentFolders = null;
-    }
-  });
-
-  // You can also add this hook for files
-  sequelize.models.Files.addHook('beforeSave', (file, options) => {
-    // If ParentFolders is an empty array or contains only nulls, set it to null
-    if (file.ParentFolders && (file.ParentFolders.length === 0 || file.ParentFolders.every(f => f === null))) {
-      file.ParentFolders = null;
-    }
-  });
-
-  return Folders;
-};

package/agrs-sequelize/models/KeywordPerformance.js

@@ -1,99 +0,0 @@
-module.exports = (sequelize, DataTypes) => {
-  const KeywordPerformance = sequelize.define(
-    "KeywordPerformance",
-    {
-      Date: {
-        type: DataTypes.DATEONLY,
-        primaryKey: true,
-      },
-      adID: {
-        type: DataTypes.STRING,
-        references: {
-          model: "Ad",
-          key: "AdID",
-        },
-        foreignKey: true,
-        primaryKey: true,
-      },
-      Keyword: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        primaryKey: true,
-      },
-      Revenue: {
-        type: DataTypes.FLOAT,
-        allowNull: false,
-      },
-      Clicks: {
-        type: DataTypes.INTEGER,
-        allowNull: false,
-      },
-      TemplatedKeyword: {
-        type: DataTypes.STRING,
-        allowNull: true,
-      },
-      FirstAppearanceDate: {
-        type: DataTypes.DATEONLY,
-        allowNull: true,
-      },
-    },
-
-    {
-      tableName: "KeywordPerformance",
-      indexes: [
-        {
-          unique: true,
-          fields: ["adID", "Date", "Keyword"], // Composite unique index for fast lookups
-        },
-        {
-          fields: ["Date"], // Index for date filtering
-        },
-        {
-          fields: ["adID"], // Index for faster joins on adID
-        },
-        {
-          fields: ["Keyword"], // Index for faster searches on Keyword
-        },
-        {
-          fields: ["Revenue"], // Index to optimize sorting/filtering on Revenue
-        },
-        {
-          fields: ["Clicks"], // Index to optimize sorting/filtering on Clicks
-        },
-      ],
-      hooks: {
-        beforeCreate: async (record, options) => {
-          try {
-            const existingKeyword =
-              await sequelize.models.KeywordPerformance.findOne({
-                where: {
-                  Keyword: sequelize.where(
-                    sequelize.fn("LOWER", sequelize.col("Keyword")),
-                    sequelize.fn("LOWER", record.Keyword)
-                  ),
-                },
-                attributes: ["FirstAppearanceDate"],
-                transaction: options.transaction,
-              });
-
-            // If keyword exists, use its FirstAppearanceDate
-            // If not, use the current record's Date
-            record.FirstAppearanceDate =
-              existingKeyword?.FirstAppearanceDate || record.Date;
-          } catch (error) {
-            console.error("Error in FirstAppearanceDate hook:", error);
-            throw error;
-          }
-        },
-      },
-    }
-  );
-
-  KeywordPerformance.associate = (models) => {
-    KeywordPerformance.belongsTo(models.Ad, {
-      foreignKey: "adID",
-    });
-  };
-
-  return KeywordPerformance;
-};

package/agrs-sequelize/models/KeywordRotationState.js

@@ -1,51 +0,0 @@
-// models/KeywordRotationState.js
-const { DataTypes } = require("sequelize");
-
-module.exports = (sequelize) => {
-  const KeywordRotationState = sequelize.define("KeywordRotationState", {
-    campaignId: {
-      type: DataTypes.STRING,
-      allowNull: false,
-      primaryKey: true,
-    },
-    staticKeywords: {
-      type: DataTypes.ARRAY(DataTypes.STRING),
-      allowNull: false,
-      defaultValue: [], // Default to empty array if no static keywords are provided
-    },
-    rotatingKeywords: {
-      type: DataTypes.ARRAY(DataTypes.STRING),
-      allowNull: false,
-      defaultValue: [], // Default to empty array if no rotating keywords are provided
-    },
-    dynamic: {
-      type: DataTypes.ARRAY(DataTypes.STRING),
-      allowNull: false,
-      defaultValue: [], // Default to empty array if no dynamic keywords are provided
-    },
-    offset: {
-      type: DataTypes.INTEGER,
-      allowNull: false,
-      defaultValue: 0,
-    },
-    rotationTime: {
-      type: DataTypes.STRING, // in minutes
-      allowNull: false,
-    },
-    rotatingKeywordSlots: {
-      type: DataTypes.INTEGER, // Number of keyword slots assigned to rotation
-      allowNull: false,
-    },
-    lastRotationTime: {
-      type: DataTypes.DATE,
-      allowNull: true,
-    },
-    status: {
-      type: DataTypes.STRING,
-      allowNull: false,
-      defaultValue: "Not Set", // Default to started when first created
-    },
-  });
-
-  return KeywordRotationState;
-};

package/agrs-sequelize/models/Pages.js

@@ -1,74 +0,0 @@
-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,
-        },
-      },
-      {
-        tableName: "Pages",
-      }
-    );
-  
-    return Pages;
-  };

package/agrs-sequelize/models/PipelineExecution.js

@@ -1,46 +0,0 @@
-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,
-      },
-      error: {
-        type: DataTypes.TEXT,
-        allowNull: true,
-      },
-    },
-    {
-      tableName: "pipeline_executions",
-      timestamps: true,
-    }
-  );
-
-  return PipelineExecution;
-};

package/agrs-sequelize/models/RSOCFeedCampaign.js

@@ -1,302 +0,0 @@
-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;
-};