Tag update

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

@@ -60,6 +60,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: { 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,17 @@ 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 },
+      type: { type: String, label: 'Content type' },
     },
     {
       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, type: 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,107 +12,93 @@ export interface ITagModel extends Model<ITagDocument> {
 
 export const loadTagClass = (models: IModels) => {
   class Tag {
-    /*
-     * Get a tag
-     */
-    public static async getTag(_id: string) {
-      const tag = await models.Tags.findOne({ _id });
+    public static async validate(_id: string | null, doc: ITag) {
+      const { name, parentId, isGroup } = doc;
 
-      if (!tag) {
-        throw new Error('Tag not found');
-      }
+      const tag = await models.Tags.findOne({
+        $or: [{ _id }, { name }],
+      });
 
-      return tag;
-    }
+      if (tag?.name === name) {
+        throw new Error(`A tag named ${name} already exists`);
+      }
 
-    /**
-     * Create a tag
-     */
-    public static async createTag(doc: ITag) {
-      const isUnique = await this.validateUniqueness(null, doc.name, doc.type);
+      if (tag?.isGroup && isGroup) {
+        throw new Error('Nested group is not allowed 1');
+      }
 
-      if (!isUnique) {
-        throw new Error('Tag duplicated');
+      if (_id === parentId) {
+        throw new Error('Group cannot be itself');
       }
 
-      const parentTag = await this.getParentTag(doc);
+      if (parentId) {
+        const parentTag = await models.Tags.findOne({ _id: parentId });
 
-      // Generatingg order
-      const order = await this.generateOrder(parentTag, doc);
+        if (!parentTag) {
+          throw new Error('Group not found');
+        }
 
-      const tag = await models.Tags.create({
-        ...doc,
-        order,
-        createdAt: new Date(),
-      });
+        if (!parentTag.isGroup) {
+          throw new Error('Parent tag must be a group');
+        }
 
-      await setRelatedTagIds(models, tag);
+        if ((isGroup || tag?.isGroup) && parentTag?.isGroup) {
+          throw new Error('Nested group is not allowed 2 ');
+        }
+      }
 
-      return tag;
-    }
+      if (tag) {
+        const parentTag = await models.Tags.findOne({ _id: tag.parentId });
+        const childTags = await models.Tags.find({ parentId: tag._id });
 
-    /**
-     * Update Tag
-     */
-    public static async updateTag(_id: string, doc: ITag) {
-      const isUnique = await this.validateUniqueness(
-        { _id },
-        doc.name,
-        doc.type,
-      );
+        if (parentTag?.isGroup && isGroup) {
+          throw new Error('Nested group is not allowed 3');
+        }
 
-      if (!isUnique) {
-        throw new Error('Tag duplicated');
+        if (!isGroup && childTags.length) {
+          throw new Error('Group has tags');
+        }
       }
+    }
 
-      const parentTag = await this.getParentTag(doc);
+    public static async getTag(_id: string) {
+      const tag = await models.Tags.findOne({ _id });
 
-      if (parentTag && parentTag.parentId === _id) {
-        throw new Error('Cannot change tag');
+      if (!tag) {
+        throw new Error('Tag not found');
       }
 
-      const tag = await models.Tags.getTag(_id);
+      return tag;
+    }
 
-      // Generatingg  order
-      const order = await this.generateOrder(parentTag, doc);
+    public static async createTag(doc: ITag) {
+      await this.validate(null, doc);
 
-      const childTags = await models.Tags.find({
-        $and: [
-          { order: { $regex: new RegExp(escapeRegExp(tag.order || ''), 'i') } },
-          { _id: { $ne: _id } },
-        ],
-      });
+      const tag = await models.Tags.create(doc);
 
-      if (childTags.length > 0) {
-        const bulkDoc: Array<{
-          updateOne: {
-            filter: { _id: string };
-            update: { $set: { order: string } };
-          };
-        }> = [];
+      await setRelatedTagIds(models, tag);
 
-        // updating child tag order
-        childTags.forEach((childTag) => {
-          let childOrder = childTag.order || '';
+      return tag;
+    }
 
-          childOrder = childOrder.replace(tag.order || '', order);
+    public static async updateTag(_id: string, doc: ITag) {
+      await this.validate(_id, doc);
 
-          bulkDoc.push({
-            updateOne: {
-              filter: { _id: childTag._id },
-              update: { $set: { order: childOrder } },
-            },
-          });
-        });
+      const tag = await models.Tags.getTag(_id);
 
-        await models.Tags.bulkWrite(bulkDoc);
+      const childTags = await models.Tags.find({ parentId: tag._id });
 
+      if (childTags.length) {
         await removeRelatedTagIds(models, tag);
       }
 
-      await models.Tags.updateOne({ _id }, { $set: { ...doc, order } });
-
-      const updated = await models.Tags.findOne({ _id });
+      const updated = await models.Tags.findOneAndUpdate(
+        { _id: tag._id },
+        doc,
+        {
+          new: true,
+        },
+      );
 
       if (updated) {
         await setRelatedTagIds(models, updated);
@@ -122,82 +107,22 @@ export const loadTagClass = (models: IModels) => {
       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);
-  },
 };