Tag update

backend/core-api/src/commands/migrateContentType.ts

@@ -33,8 +33,7 @@ const command = async () => {
   const COLLECTIONS = {
     // IMPORTANT: Do not add collections here unless they have a `type` (contentType) field.
     // This script will break or have no effect if the collection does not contain `type`.
-
-    tags: db.collection('tags'),
+    // tags: db.collection('tags'), // Note: 'tags' no longer include a contentType field
   };
 
   try {
@@ -60,6 +59,9 @@ const command = async () => {
   }
 
   console.log(`Process finished at: ${new Date().toISOString()}`);
+
+  await client.close();
+  process.exit();
 };
 
 command();

backend/core-api/src/commands/migrateTags.ts

@@ -0,0 +1,44 @@
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+import { Collection, Db, MongoClient } from 'mongodb';
+
+const { MONGO_URL = 'mongodb://localhost:27017/erxes?directConnection=true' } =
+  process.env;
+
+if (!MONGO_URL) {
+  throw new Error(`Environment variable MONGO_URL not set.`);
+}
+
+const client = new MongoClient(MONGO_URL);
+
+let db: Db;
+let Tags: Collection;
+
+const command = async () => {
+  await client.connect();
+  db = client.db() as Db;
+
+  Tags = db.collection('tags');
+
+  try {
+    await Tags.updateMany(
+      {},
+      {
+        $unset: { type: '', objectCount: '', order: '', scopeBrandIds: '' },
+        $set: { isGroup: false, parentId: '' }, // flatten parentId: no nested parent tags allowed
+      },
+    );
+  } catch (e) {
+    console.log(`Error occurred: ${e.message}`);
+    await client.close();
+  }
+
+  console.log(`Process finished at: ${new Date().toISOString()}`);
+
+  await client.close();
+  process.exit();
+};
+
+command();

backend/core-api/src/modules/documents/db/definitions/documents.ts

@@ -8,7 +8,7 @@ export const documentSchema = new Schema(
     name: { type: String },
     content: { type: String },
     replacer: { type: String },
-    code: { type: String },
+    code: { type: String, optional: true },
   },
   {
     timestamps: true,

backend/core-api/src/modules/tags/@types/tag.ts

@@ -9,6 +9,7 @@ export interface ITagFilterQueryParams
   type: string;
   tagIds?: string[];
   parentId?: string;
+  isGroup?: boolean;
   ids: string[];
   excludeIds: boolean;
 }

backend/core-api/src/modules/tags/db/definitions/tags.ts

@@ -5,32 +5,16 @@ export const tagSchema = schemaWrapper(
   new Schema(
     {
       _id: mongooseStringRandomId,
-      name: { type: String, label: 'Name' },
-      type: {
-        type: String,
-        label: 'Type',
-        index: true,
-      },
+      name: { type: String, label: 'Name', unique: true },
       colorCode: { type: String, label: 'Color code' },
-      objectCount: { type: Number, label: 'Object count' },
-      order: { type: String, label: 'Order', index: true },
-      parentId: {
-        type: String,
-        optional: true,
-        index: true,
-        label: 'Parent',
-      },
-      relatedIds: {
-        type: [String],
-        optional: true,
-        label: 'Children tag ids',
-      },
+      parentId: { type: String, label: 'Parent' },
+      relatedIds: { type: [String], label: 'Children tag ids' },
+      isGroup: { type: Boolean, label: 'Is group', default: false },
     },
     {
       timestamps: true,
     },
   ),
 );
 
-// for tags query. increases search speed, avoids in-memory sorting
-tagSchema.index({ _id: 1, type: 1, order: 1, name: 1, createdAt: 1 });
+tagSchema.index({ _id: 1, name: 1, parentId: 1 });

backend/core-api/src/modules/tags/db/models/Tags.ts

@@ -1,9 +1,8 @@
-import { escapeRegExp } from 'erxes-api-shared/utils';
+import { tagSchema } from '@/tags/db/definitions/tags';
+import { removeRelatedTagIds, setRelatedTagIds } from '@/tags/utils';
 import { ITag, ITagDocument } from 'erxes-api-shared/core-types';
 import { Model } from 'mongoose';
 import { IModels } from '~/connectionResolvers';
-import { removeRelatedTagIds, setRelatedTagIds } from '@/tags/utils';
-import { tagSchema } from '@/tags/db/definitions/tags';
 export interface ITagModel extends Model<ITagDocument> {
   getTag(_id: string): Promise<ITagDocument>;
   createTag(doc: ITag): Promise<ITagDocument>;
@@ -13,9 +12,40 @@ export interface ITagModel extends Model<ITagDocument> {
 
 export const loadTagClass = (models: IModels) => {
   class Tag {
-    /*
-     * Get a tag
-     */
+    public static async validate(_id: string | null, doc: ITag) {
+      const { name, parentId, isGroup } = doc;
+
+      const tag = await models.Tags.findOne({ name });
+
+      if (tag && tag._id !== _id) {
+        throw new Error('There is already a tag with this name');
+      }
+
+      if (parentId) {
+        const parentTag = await models.Tags.findOne({ _id: parentId });
+
+        if (!parentTag?.isGroup) {
+          throw new Error('Parent tag must be a group');
+        }
+      }
+
+      if (isGroup && parentId) {
+        throw new Error('Group tag cannot have parent tag');
+      }
+
+      if (_id) {
+        const existingTag = await models.Tags.findOne({ _id });
+
+        if (isGroup && parentId) {
+          throw new Error('Group tag cannot have parent tag');
+        }
+
+        if (!existingTag?.isGroup && isGroup && existingTag?.parentId) {
+          throw new Error('Cannot convert a nested tag into a group');
+        }
+      }
+    }
+
     public static async getTag(_id: string) {
       const tag = await models.Tags.findOne({ _id });
 
@@ -26,178 +56,48 @@ export const loadTagClass = (models: IModels) => {
       return tag;
     }
 
-    /**
-     * Create a tag
-     */
     public static async createTag(doc: ITag) {
-      const isUnique = await this.validateUniqueness(null, doc.name, doc.type);
-
-      if (!isUnique) {
-        throw new Error('Tag duplicated');
-      }
+      await this.validate(null, doc);
 
-      const parentTag = await this.getParentTag(doc);
-
-      // Generatingg order
-      const order = await this.generateOrder(parentTag, doc);
-
-      const tag = await models.Tags.create({
-        ...doc,
-        order,
-        createdAt: new Date(),
-      });
+      const tag = await models.Tags.create(doc);
 
       await setRelatedTagIds(models, tag);
 
       return tag;
     }
 
-    /**
-     * Update Tag
-     */
     public static async updateTag(_id: string, doc: ITag) {
-      const isUnique = await this.validateUniqueness(
-        { _id },
-        doc.name,
-        doc.type,
-      );
-
-      if (!isUnique) {
-        throw new Error('Tag duplicated');
-      }
-
-      const parentTag = await this.getParentTag(doc);
-
-      if (parentTag && parentTag.parentId === _id) {
-        throw new Error('Cannot change tag');
-      }
+      await this.validate(_id, doc);
 
       const tag = await models.Tags.getTag(_id);
 
-      // Generatingg  order
-      const order = await this.generateOrder(parentTag, doc);
-
-      const childTags = await models.Tags.find({
-        $and: [
-          { order: { $regex: new RegExp(escapeRegExp(tag.order || ''), 'i') } },
-          { _id: { $ne: _id } },
-        ],
+      const updated = await models.Tags.findOneAndUpdate({ _id }, doc, {
+        new: true,
       });
 
-      if (childTags.length > 0) {
-        const bulkDoc: Array<{
-          updateOne: {
-            filter: { _id: string };
-            update: { $set: { order: string } };
-          };
-        }> = [];
-
-        // updating child tag order
-        childTags.forEach((childTag) => {
-          let childOrder = childTag.order || '';
-
-          childOrder = childOrder.replace(tag.order || '', order);
-
-          bulkDoc.push({
-            updateOne: {
-              filter: { _id: childTag._id },
-              update: { $set: { order: childOrder } },
-            },
-          });
-        });
-
-        await models.Tags.bulkWrite(bulkDoc);
-
-        await removeRelatedTagIds(models, tag);
-      }
-
-      await models.Tags.updateOne({ _id }, { $set: { ...doc, order } });
-
-      const updated = await models.Tags.findOne({ _id });
-
       if (updated) {
         await setRelatedTagIds(models, updated);
       }
 
       return updated;
     }
 
-    /**
-     * Remove Tag
-     */
     public static async removeTag(_id: string) {
       const tag = await models.Tags.getTag(_id);
 
-      const childCount = await models.Tags.countDocuments({
-        parentId: _id,
-      });
+      const childTagIds = await models.Tags.find({ parentId: _id }).distinct(
+        '_id',
+      );
 
-      if (childCount > 0) {
-        throw new Error('Please remove child tags first');
-      }
+      await models.Tags.updateMany(
+        { _id: { $in: childTagIds } },
+        { $unset: { parentId: 1 } },
+      );
 
       await removeRelatedTagIds(models, tag);
 
       return models.Tags.deleteOne({ _id });
     }
-
-    /*
-     * Validates tag uniquness
-     */
-    public static async validateUniqueness(
-      selector: any,
-      name: string,
-      type: string,
-    ): Promise<boolean> {
-      // required name and type
-      if (!name || !type) {
-        return true;
-      }
-
-      // can't update name & type same time more than one tags.
-      const count = await models.Tags.countDocuments(selector);
-
-      if (selector && count > 1) {
-        return false;
-      }
-
-      const obj = selector && (await models.Tags.findOne(selector));
-
-      const filter: any = { name, type };
-
-      if (obj) {
-        filter._id = { $ne: obj._id };
-      }
-
-      const existing = await models.Tags.findOne(filter);
-
-      if (existing) {
-        return false;
-      }
-
-      return true;
-    }
-
-    /*
-     * Get a parent tag
-     */
-    static async getParentTag(doc: ITag) {
-      return models.Tags.findOne({
-        _id: doc.parentId,
-      }).lean();
-    }
-
-    /**
-     * Generating order
-     */
-    public static async generateOrder(
-      parentTag: ITagDocument | null,
-      { name }: { name: string },
-    ) {
-      const order = parentTag ? `${parentTag.order}${name}/` : `${name}/`;
-
-      return order;
-    }
   }
 
   tagSchema.loadClass(Tag);

backend/core-api/src/modules/tags/graphql/mutations.ts

@@ -96,18 +96,4 @@ export const tagMutations = {
   ) {
     return models.Tags.removeTag(_id);
   },
-
-  /**
-   * Merge tags
-   */
-  async tagsMerge(
-    _parent: undefined,
-    { sourceId, destId }: { sourceId: string; destId: string },
-    { models }: IContext,
-  ) {
-    // remove old tag
-    await models.Tags.removeTag(sourceId);
-
-    return models.Tags.getTag(destId);
-  },
 };