Merge pull request #304 from kimatata/develop

README.md

@@ -35,7 +35,7 @@ docker-compose up --build
 
 You can access the app at `http://localhost:8000`
 
-[Looking for a non-Docker way?](https://kimatata.github.io/unittcms/docs/getstarted/manual)
+[Looking for a non-Docker way?](https://kimatata.github.io/unittcms/docs/getstarted/from-source)
 
 ## Why UnitTCMS
 

backend/migrations/20251009180204-create-tags.js

@@ -0,0 +1,35 @@
+export async function up(queryInterface, Sequelize) {
+  await queryInterface.createTable('tags', {
+    id: {
+      type: Sequelize.INTEGER,
+      autoIncrement: true,
+      primaryKey: true,
+      allowNull: false,
+    },
+    name: {
+      type: Sequelize.STRING,
+      allowNull: false,
+    },
+    projectId: {
+      type: Sequelize.INTEGER,
+      allowNull: false,
+      references: {
+        model: 'projects',
+        key: 'id',
+      },
+      onDelete: 'CASCADE',
+    },
+    createdAt: {
+      allowNull: false,
+      type: Sequelize.DATE,
+    },
+    updatedAt: {
+      allowNull: false,
+      type: Sequelize.DATE,
+    },
+  });
+}
+
+export async function down(queryInterface) {
+  await queryInterface.dropTable('tags');
+}

backend/migrations/20251009191250-create-case-tags.js

@@ -0,0 +1,40 @@
+export async function up(queryInterface, Sequelize) {
+  await queryInterface.createTable('caseTags', {
+    id: {
+      type: Sequelize.INTEGER,
+      autoIncrement: true,
+      primaryKey: true,
+      allowNull: false,
+    },
+    caseId: {
+      type: Sequelize.INTEGER,
+      allowNull: false,
+      references: {
+        model: 'cases',
+        key: 'id',
+      },
+      onDelete: 'CASCADE',
+    },
+    tagId: {
+      type: Sequelize.INTEGER,
+      allowNull: false,
+      references: {
+        model: 'tags',
+        key: 'id',
+      },
+      onDelete: 'CASCADE',
+    },
+    createdAt: {
+      type: Sequelize.DATE,
+      allowNull: false,
+    },
+    updatedAt: {
+      type: Sequelize.DATE,
+      allowNull: false,
+    },
+  });
+}
+
+export async function down(queryInterface) {
+  await queryInterface.dropTable('caseTags');
+}

backend/models/caseTags.js

@@ -0,0 +1,36 @@
+function definecaseTags(sequelize, DataTypes) {
+  const caseTags = sequelize.define('caseTags', {
+    id: {
+      type: DataTypes.INTEGER,
+      autoIncrement: true,
+      primaryKey: true,
+    },
+    caseId: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      references: {
+        model: 'cases',
+        key: 'id',
+      },
+      onDelete: 'CASCADE',
+    },
+    tagId: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      references: {
+        model: 'tags',
+        key: 'id',
+      },
+      onDelete: 'CASCADE',
+    },
+  });
+
+  caseTags.associate = (models) => {
+    caseTags.belongsTo(models.Case, { foreignKey: 'caseId', onDelete: 'CASCADE' });
+    caseTags.belongsTo(models.Tags, { foreignKey: 'tagId', onDelete: 'CASCADE' });
+  };
+
+  return caseTags;
+}
+
+export default definecaseTags;

backend/models/cases.js

@@ -55,6 +55,11 @@ function defineCase(sequelize, DataTypes) {
     Case.belongsToMany(models.Step, {
       through: 'caseSteps',
     });
+    Case.belongsToMany(models.Tags, {
+      through: 'caseTags',
+      foreignKey: 'caseId',
+      otherKey: 'tagId',
+    });
   };
 
   return Case;

backend/models/tags.js

@@ -0,0 +1,34 @@
+function defineTag(sequelize, DataTypes) {
+  const Tags = sequelize.define('Tags', {
+    name: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+    projectId: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      references: {
+        model: 'projects',
+        key: 'id',
+      },
+      onDelete: 'CASCADE',
+    },
+  });
+
+  Tags.associate = (models) => {
+    Tags.belongsTo(models.Project, {
+      foreignKey: 'projectId',
+      onDelete: 'CASCADE',
+    });
+
+    Tags.belongsToMany(models.Case, {
+      through: 'caseTags',
+      foreignKey: 'tagId',
+      otherKey: 'caseId',
+    });
+  };
+
+  return Tags;
+}
+
+export default defineTag;

backend/routes/cases/clone.js

@@ -0,0 +1,74 @@
+import express from 'express';
+const router = express.Router();
+import { DataTypes } from 'sequelize';
+import defineCase from '../../models/cases.js';
+import defineStep from '../../models/steps.js';
+import defineCaseStep from '../../models/caseSteps.js';
+import authMiddleware from '../../middleware/auth.js';
+import editableMiddleware from '../../middleware/verifyEditable.js';
+
+export default function (sequelize) {
+  const { verifySignedIn } = authMiddleware(sequelize);
+  const { verifyProjectDeveloperFromProjectId } = editableMiddleware(sequelize);
+  const Case = defineCase(sequelize, DataTypes);
+  const Step = defineStep(sequelize, DataTypes);
+  const CaseStep = defineCaseStep(sequelize, DataTypes);
+  Case.belongsToMany(Step, { through: 'caseSteps' });
+  Step.belongsToMany(Case, { through: 'caseSteps' });
+
+  // TODO:  Implement a safer middleware to check permissions based on the actual caseId (in this case, multiples case ids)
+  router.post('/clone', verifySignedIn, verifyProjectDeveloperFromProjectId, async (req, res) => {
+    const { caseIds, targetFolderId } = req.body;
+
+    if (!Array.isArray(caseIds) || caseIds.length === 0 || !targetFolderId) {
+      return res.status(400).json({ error: 'caseIds(array) and targetFolderId are required' });
+    }
+
+    try {
+      const caseRecords = await Case.findAll({
+        where: { id: caseIds },
+        include: [{ model: Step, through: { attributes: ['stepNo'] } }],
+      });
+
+      if (caseRecords.length !== caseIds.length) {
+        return res.status(404).json({ error: 'Some cases not found' });
+      }
+
+      const cases = caseRecords.map((c) => c.get({ plain: true }));
+
+      const clonedCases = cases.map((c) => {
+        const { id: _id, createdAt: _createdAt, updatedAt: _updatedAt, ...clonedCase } = c;
+        return { ...clonedCase, folderId: targetFolderId };
+      });
+
+      await sequelize.transaction(async (t) => {
+        for (const c of clonedCases) {
+          const newCase = await Case.create(c, { transaction: t });
+
+          if (c.Steps) {
+            const clonedSteps = c.Steps.map((s) => {
+              const { id: _id, createdAt: _createdAt, updatedAt: _updatedAt, ...clonedStep } = s;
+              return clonedStep;
+            });
+
+            const newStep = await Step.bulkCreate(clonedSteps, { transaction: t });
+            const newCaseSteps = newStep.map((step, index) => ({
+              caseId: newCase.id,
+              stepId: step.id,
+              stepNo: clonedSteps[index].caseSteps.stepNo,
+            }));
+
+            await CaseStep.bulkCreate(newCaseSteps, { transaction: t });
+          }
+        }
+      });
+
+      res.status(200).json({ message: 'Cases cloned successfully' });
+    } catch (error) {
+      console.error('Error cloning cases:', error);
+      res.status(500).send('Internal Server Error');
+    }
+  });
+
+  return router;
+}

backend/routes/cases/index.js

@@ -2,6 +2,8 @@ import express from 'express';
 const router = express.Router();
 import { DataTypes, Op } from 'sequelize';
 import defineCase from '../../models/cases.js';
+import defineTag from '../../models/tags.js';
+
 import authMiddleware from '../../middleware/auth.js';
 import visibilityMiddleware from '../../middleware/verifyVisible.js';
 
@@ -9,6 +11,10 @@ export default function (sequelize) {
   const { verifySignedIn } = authMiddleware(sequelize);
   const { verifyProjectVisibleFromFolderId } = visibilityMiddleware(sequelize);
   const Case = defineCase(sequelize, DataTypes);
+  const Tags = defineTag(sequelize, DataTypes);
+
+  Case.belongsToMany(Tags, { through: 'caseTags', foreignKey: 'caseId', otherKey: 'tagId' });
+  Tags.belongsToMany(Case, { through: 'caseTags', foreignKey: 'tagId', otherKey: 'caseId' });
 
   router.get('/', verifySignedIn, verifyProjectVisibleFromFolderId, async (req, res) => {
     const { folderId, title, priority, type } = req.query;
@@ -56,6 +62,13 @@ export default function (sequelize) {
 
       const cases = await Case.findAll({
         where: whereClause,
+        include: [
+          {
+            model: Tags,
+            attributes: ['id', 'name'],
+            through: { attributes: [] },
+          },
+        ],
       });
       res.json(cases);
     } catch (error) {

backend/routes/cases/index.test.js

@@ -24,11 +24,20 @@ vi.mock('../../middleware/verifyVisible.js', () => ({
 // mock defineCase
 const mockCase = {
   findAll: vi.fn(),
+  belongsToMany: vi.fn(),
 };
+
 vi.mock('../../models/cases.js', () => ({
   default: () => mockCase,
 }));
 
+const mockTags = {
+  belongsToMany: vi.fn(),
+};
+vi.mock('../../models/tags.js', () => ({
+  default: () => mockTags,
+}));
+
 describe('GET /cases', () => {
   let app;
   const sequelize = new Sequelize({
@@ -54,7 +63,16 @@ describe('GET /cases', () => {
     mockCase.findAll.mockResolvedValue([{ id: 1 }]);
     const res = await request(app).get('/cases?folderId=1');
     expect(res.status).toBe(200);
-    expect(mockCase.findAll).toHaveBeenCalledWith({ where: { folderId: '1' } });
+    expect(mockCase.findAll).toHaveBeenCalledWith({
+      where: { folderId: '1' },
+      include: [
+        {
+          model: mockTags,
+          attributes: ['id', 'name'],
+          through: { attributes: [] },
+        },
+      ],
+    });
     expect(res.body).toEqual([{ id: 1 }]);
   });
 
@@ -69,6 +87,13 @@ describe('GET /cases', () => {
         priority: { [Op.in]: [1, 2] },
         type: { [Op.in]: [3] },
       },
+      include: [
+        {
+          model: mockTags,
+          attributes: ['id', 'name'],
+          through: { attributes: [] },
+        },
+      ],
     });
   });
 });

backend/routes/cases/indexByProjectId.js

@@ -4,6 +4,7 @@ import { DataTypes } from 'sequelize';
 import defineProject from '../../models/projects.js';
 import defineFolder from '../../models/folders.js';
 import defineCase from '../../models/cases.js';
+import defineTag from '../../models/tags.js';
 import defineRunCase from '../../models/runCases.js';
 import authMiddleware from '../../middleware/auth.js';
 import visibilityMiddleware from '../../middleware/verifyVisible.js';
@@ -13,11 +14,14 @@ export default function (sequelize) {
   const Folder = defineFolder(sequelize, DataTypes);
   const Case = defineCase(sequelize, DataTypes);
   const RunCase = defineRunCase(sequelize, DataTypes);
+  const Tags = defineTag(sequelize, DataTypes);
   Project.hasMany(Folder, { foreignKey: 'projectId' });
   Folder.hasMany(Case, { foreignKey: 'folderId' });
   Folder.belongsTo(Project, { foreignKey: 'projectId' });
   Case.belongsTo(Folder, { foreignKey: 'folderId' });
   Case.hasMany(RunCase, { foreignKey: 'caseId' });
+  Case.belongsToMany(Tags, { through: 'caseTags', foreignKey: 'caseId', otherKey: 'tagId' });
+  Tags.belongsToMany(Case, { through: 'caseTags', foreignKey: 'tagId', otherKey: 'caseId' });
   RunCase.belongsTo(Case, { foreignKey: 'caseId' });
   const { verifySignedIn } = authMiddleware(sequelize);
   const { verifyProjectVisibleFromProjectId } = visibilityMiddleware(sequelize);
@@ -43,6 +47,11 @@ export default function (sequelize) {
             model: RunCase,
             attributes: ['id', 'runId', 'status'],
           },
+          {
+            model: Tags,
+            attributes: ['id', 'name'],
+            through: { attributes: [] },
+          },
         ],
       });
       res.json(cases);

backend/routes/cases/show.js

@@ -3,6 +3,7 @@ const router = express.Router();
 import { DataTypes } from 'sequelize';
 import defineCase from '../../models/cases.js';
 import defineStep from '../../models/steps.js';
+import defineTag from '../../models/tags.js';
 import defineAttachment from '../../models/attachments.js';
 import authMiddleware from '../../middleware/auth.js';
 import visibilityMiddleware from '../../middleware/verifyVisible.js';
@@ -10,11 +11,14 @@ import visibilityMiddleware from '../../middleware/verifyVisible.js';
 export default function (sequelize) {
   const Case = defineCase(sequelize, DataTypes);
   const Step = defineStep(sequelize, DataTypes);
+  const Tags = defineTag(sequelize, DataTypes);
   const Attachment = defineAttachment(sequelize, DataTypes);
   Case.belongsToMany(Step, { through: 'caseSteps' });
   Step.belongsToMany(Case, { through: 'caseSteps' });
   Case.belongsToMany(Attachment, { through: 'caseAttachments' });
   Attachment.belongsToMany(Case, { through: 'caseAttachments' });
+  Case.belongsToMany(Tags, { through: 'caseTags', foreignKey: 'caseId', otherKey: 'tagId' });
+  Tags.belongsToMany(Case, { through: 'caseTags', foreignKey: 'tagId', otherKey: 'caseId' });
   const { verifySignedIn } = authMiddleware(sequelize);
   const { verifyProjectVisibleFromCaseId } = visibilityMiddleware(sequelize);
 
@@ -35,6 +39,11 @@ export default function (sequelize) {
           {
             model: Attachment,
           },
+          {
+            model: Tags,
+            attributes: ['id', 'name'],
+            through: { attributes: [] },
+          },
         ],
       });
       return res.json(testcase);

backend/routes/casetags/delete.js

@@ -0,0 +1,41 @@
+import express from 'express';
+const router = express.Router();
+import { DataTypes } from 'sequelize';
+import authMiddleware from '../../middleware/auth.js';
+import editableMiddleware from '../../middleware/verifyEditable.js';
+import definecaseTags from '../../models/caseTags.js';
+
+export default function (sequelize) {
+  const { verifySignedIn } = authMiddleware(sequelize);
+  const { verifyProjectDeveloperFromCaseId } = editableMiddleware(sequelize);
+  const CaseTag = definecaseTags(sequelize, DataTypes);
+
+  router.delete('/:id', verifySignedIn, verifyProjectDeveloperFromCaseId, async (req, res) => {
+    const { id } = req.params;
+
+    if (!id) {
+      return res.status(400).json({
+        error: 'id is required',
+      });
+    }
+
+    try {
+      const deletedCaseTag = await CaseTag.destroy({
+        where: {
+          id: id,
+        },
+      });
+
+      if (!deletedCaseTag) {
+        return res.status(404).json({ error: 'Case-tag association not found' });
+      }
+
+      res.status(204).send();
+    } catch (error) {
+      console.error('Error deleting case-tag association:', error);
+      res.status(500).json({ error: 'Internal server error' });
+    }
+  });
+
+  return router;
+}

backend/routes/casetags/new.js

@@ -0,0 +1,58 @@
+import express from 'express';
+const router = express.Router();
+import { DataTypes } from 'sequelize';
+import authMiddleware from '../../middleware/auth.js';
+import editableMiddleware from '../../middleware/verifyEditable.js';
+import definecaseTags from '../../models/caseTags.js';
+import defineCase from '../../models/cases.js';
+import defineTag from '../../models/tags.js';
+
+export default function (sequelize) {
+  const { verifySignedIn } = authMiddleware(sequelize);
+  const { verifyProjectDeveloperFromCaseId } = editableMiddleware(sequelize);
+  const CaseTag = definecaseTags(sequelize, DataTypes);
+  const Case = defineCase(sequelize, DataTypes);
+  const Tags = defineTag(sequelize, DataTypes);
+
+  router.post('/', verifySignedIn, verifyProjectDeveloperFromCaseId, async (req, res) => {
+    const { caseId, tagId } = req.body;
+
+    if (!caseId || !tagId) {
+      return res.status(400).json({
+        error: 'caseId and tagId are required',
+      });
+    }
+
+    try {
+      const caseExists = await Case.findByPk(caseId);
+      if (!caseExists) {
+        return res.status(404).json({ error: 'Case not found' });
+      }
+
+      const tagExists = await Tags.findByPk(tagId);
+      if (!tagExists) {
+        return res.status(404).json({ error: 'Tag not found' });
+      }
+
+      const existingAssociation = await CaseTag.findOne({
+        where: { caseId, tagId },
+      });
+
+      if (existingAssociation) {
+        return res.status(409).json({ error: 'Tag is already associated with this case' });
+      }
+
+      const newCaseTag = await CaseTag.create({
+        caseId,
+        tagId,
+      });
+
+      res.status(201).json(newCaseTag);
+    } catch (error) {
+      console.error('Error creating case-tag association:', error);
+      res.status(500).json({ error: 'Internal server error' });
+    }
+  });
+
+  return router;
+}

backend/routes/folders/clone.js

@@ -0,0 +1,106 @@
+import express from 'express';
+const router = express.Router();
+import { DataTypes } from 'sequelize';
+import defineFolder from '../../models/folders.js';
+import defineCase from '../../models/cases.js';
+import defineStep from '../../models/steps.js';
+import defineCaseStep from '../../models/caseSteps.js';
+import authMiddleware from '../../middleware/auth.js';
+import editableMiddleware from '../../middleware/verifyEditable.js';
+
+export default function (sequelize) {
+  const { verifySignedIn } = authMiddleware(sequelize);
+  const { verifyProjectDeveloperFromFolderId } = editableMiddleware(sequelize);
+
+  const Folder = defineFolder(sequelize, DataTypes);
+  const Case = defineCase(sequelize, DataTypes);
+  const Step = defineStep(sequelize, DataTypes);
+  const CaseStep = defineCaseStep(sequelize, DataTypes);
+  Case.belongsTo(Folder);
+  Case.belongsToMany(Step, { through: 'caseSteps' });
+  Step.belongsToMany(Case, { through: 'caseSteps' });
+
+  async function _cloneFolderRecursive(sourceFolder, targetParent, transaction) {
+    const folderToCreate = {
+      name: sourceFolder.name,
+      detail: sourceFolder.detail,
+      parentFolderId: targetParent.id,
+      projectId: targetParent.projectId,
+    };
+
+    const clonedFolder = await Folder.create(folderToCreate, { transaction });
+
+    await _cloneCasesAndSteps(sourceFolder.id, clonedFolder.id, transaction);
+
+    const childFolders = await Folder.findAll({
+      where: { parentFolderId: sourceFolder.id },
+    });
+
+    for (const child of childFolders) {
+      await _cloneFolderRecursive(child, clonedFolder, transaction);
+    }
+
+    return clonedFolder;
+  }
+
+  async function _cloneCasesAndSteps(folderId, targetFolderId, transaction) {
+    const folderCases = await Case.findAll({
+      where: { folderId },
+      include: [{ model: Step, through: { attributes: ['stepNo'] } }],
+    });
+
+    if (folderCases.length === 0) return;
+
+    const cases = folderCases.map((c) => c.get({ plain: true }));
+
+    const clonedCases = cases.map((c) => {
+      const { id: _id, createdAt: _createdAt, updatedAt: _updatedAt, ...clonedCase } = c;
+      return { ...clonedCase, folderId: targetFolderId };
+    });
+
+    for (const c of clonedCases) {
+      const newCase = await Case.create(c, { transaction });
+
+      if (c.Steps && c.Steps.length > 0) {
+        const clonedSteps = c.Steps.map((s) => {
+          const { id: _id, createdAt: _createdAt, updatedAt: _updatedAt, ...clonedStep } = s;
+          return clonedStep;
+        });
+
+        const newSteps = await Step.bulkCreate(clonedSteps, { transaction });
+        const caseSteps = newSteps.map((step, index) => ({
+          caseId: newCase.id,
+          stepId: step.id,
+          stepNo: clonedSteps[index].caseSteps.stepNo,
+        }));
+
+        await CaseStep.bulkCreate(caseSteps, { transaction });
+      }
+    }
+  }
+
+  router.post('/:folderId/clone', verifySignedIn, verifyProjectDeveloperFromFolderId, async (req, res) => {
+    const folderId = req.params.folderId;
+    const { targetFolderId } = req.body;
+
+    try {
+      const sourceFolder = await Folder.findByPk(folderId);
+      const targetFolder = await Folder.findByPk(targetFolderId);
+
+      if (!sourceFolder || !targetFolder) {
+        return res.status(404).send('Folder or target folder not found');
+      }
+
+      await sequelize.transaction(async (t) => {
+        await _cloneFolderRecursive(sourceFolder, targetFolder, t);
+      });
+
+      res.status(201).send({ message: 'Folder cloned successfully' });
+    } catch (err) {
+      console.error(err);
+      res.status(500).send('Internal Server Error');
+    }
+  });
+
+  return router;
+}

backend/routes/tags/delete.js

@@ -0,0 +1,45 @@
+import express from 'express';
+const router = express.Router();
+import { DataTypes } from 'sequelize';
+import authMiddleware from '../../middleware/auth.js';
+import editableMiddleware from '../../middleware/verifyEditable.js';
+
+import defineTag from '../../models/tags.js';
+
+export default function (sequelize) {
+  const { verifySignedIn } = authMiddleware(sequelize);
+  const { verifyProjectDeveloperFromProjectId } = editableMiddleware(sequelize);
+
+  const Tags = defineTag(sequelize, DataTypes);
+
+  router.delete('/:tagId', verifySignedIn, verifyProjectDeveloperFromProjectId, async (req, res) => {
+    const { tagId } = req.params;
+    const projectId = req.query.projectId;
+
+    if (!tagId || !projectId) {
+      return res.status(400).json({
+        error: 'tagId and projectId are required',
+      });
+    }
+
+    try {
+      const deletedTag = await Tags.destroy({
+        where: {
+          id: tagId,
+          projectId,
+        },
+      });
+
+      if (!deletedTag) {
+        return res.status(404).json({ error: 'Tag not found' });
+      }
+
+      res.status(204).send();
+    } catch (error) {
+      console.error('Error deleting tag:', error);
+      res.status(500).json({ error: 'Internal server error' });
+    }
+  });
+
+  return router;
+}

backend/routes/tags/edit.js

@@ -0,0 +1,63 @@
+import express from 'express';
+const router = express.Router();
+import { DataTypes, Op } from 'sequelize';
+import authMiddleware from '../../middleware/auth.js';
+import editableMiddleware from '../../middleware/verifyEditable.js';
+
+import defineTag from '../../models/tags.js';
+
+export default function (sequelize) {
+  const { verifySignedIn } = authMiddleware(sequelize);
+  const { verifyProjectDeveloperFromProjectId } = editableMiddleware(sequelize);
+
+  const Tags = defineTag(sequelize, DataTypes);
+
+  router.put('/:tagId', verifySignedIn, verifyProjectDeveloperFromProjectId, async (req, res) => {
+    const { tagId } = req.params;
+    const projectId = req.query.projectId;
+
+    if (!tagId || !projectId) {
+      return res.status(400).json({
+        error: 'tagId and projectId are required',
+      });
+    }
+
+    const { name } = req.body;
+
+    if (!name) {
+      return res.status(400).json({
+        error: 'name is required',
+      });
+    }
+
+    const trimmedName = name.trim();
+
+    if (trimmedName.length < 3 || trimmedName.length > 20) {
+      return res.status(400).json({
+        error: 'name must be between 3 and 20 characters long',
+      });
+    }
+
+    try {
+      const existingTag = await Tags.findOne({
+        where: { name: trimmedName, projectId, id: { [Op.ne]: tagId } },
+        attributes: ['id'],
+      });
+
+      if (existingTag) {
+        return res.status(409).json({ error: 'Tag name must be unique' });
+      }
+
+      const [updated, [updatedTag]] = await Tags.update({ name: trimmedName }, { where: { id: tagId, projectId } });
+
+      if (updated === 0) return res.status(404).json({ error: 'Tag not found' });
+
+      res.status(200).json(updatedTag);
+    } catch (error) {
+      console.error('Error updating tag:', error);
+      res.status(500).json({ error: 'Internal server error' });
+    }
+  });
+
+  return router;
+}

backend/routes/tags/index.js

@@ -0,0 +1,38 @@
+import express from 'express';
+const router = express.Router();
+import { DataTypes } from 'sequelize';
+import authMiddleware from '../../middleware/auth.js';
+import defineTag from '../../models/tags.js';
+import visibilityMiddleware from '../../middleware/verifyVisible.js';
+
+export default function (sequelize) {
+  const { verifySignedIn } = authMiddleware(sequelize);
+  const { verifyProjectVisibleFromProjectId } = visibilityMiddleware(sequelize);
+
+  const Tags = defineTag(sequelize, DataTypes);
+
+  router.get('/', verifySignedIn, verifyProjectVisibleFromProjectId, async (req, res) => {
+    const projectId = req.query.projectId;
+
+    if (!projectId) {
+      return res.status(400).json({
+        error: 'projectId is required',
+      });
+    }
+
+    try {
+      const tags = await Tags.findAll({
+        where: {
+          projectId: projectId,
+        },
+        order: [['name', 'ASC']],
+      });
+      res.json(tags);
+    } catch (error) {
+      console.error('Error fetching tags:', error);
+      res.status(500).json({ error: 'Internal server error' });
+    }
+  });
+
+  return router;
+}

backend/routes/tags/new.js

@@ -0,0 +1,54 @@
+import express from 'express';
+const router = express.Router();
+import { DataTypes } from 'sequelize';
+import authMiddleware from '../../middleware/auth.js';
+import editableMiddleware from '../../middleware/verifyEditable.js';
+
+import defineTag from '../../models/tags.js';
+
+export default function (sequelize) {
+  const { verifySignedIn } = authMiddleware(sequelize);
+  const { verifyProjectDeveloperFromProjectId } = editableMiddleware(sequelize);
+
+  const Tags = defineTag(sequelize, DataTypes);
+
+  router.post('/', verifySignedIn, verifyProjectDeveloperFromProjectId, async (req, res) => {
+    const { name } = req.body;
+    const projectId = req.query.projectId;
+
+    if (!name || !projectId) {
+      return res.status(400).json({
+        error: 'name and projectId are required',
+      });
+    }
+    const trimmedName = name.trim();
+
+    if (trimmedName.length < 3 || trimmedName.length > 20) {
+      return res.status(400).json({
+        error: 'name must be between 3 and 20 characters long',
+      });
+    }
+
+    try {
+      if (await Tags.findOne({ where: { name: trimmedName, projectId } })) {
+        return res.status(409).json({ error: 'Tag name must be unique' });
+      }
+
+      const newTag = await Tags.create({
+        name: trimmedName,
+        projectId,
+      });
+      res.status(201).json(newTag);
+    } catch (error) {
+      console.error('Error creating new tag:', error);
+
+      if (error.name === 'SequelizeUniqueConstraintError') {
+        return res.status(409).json({ error: 'Tag name must be unique' });
+      }
+
+      res.status(500).json({ error: 'Internal server error' });
+    }
+  });
+
+  return router;
+}

backend/routes/tags/show.js

@@ -0,0 +1,43 @@
+import express from 'express';
+const router = express.Router();
+import { DataTypes } from 'sequelize';
+import authMiddleware from '../../middleware/auth.js';
+import defineTag from '../../models/tags.js';
+import visibilityMiddleware from '../../middleware/verifyVisible.js';
+
+export default function (sequelize) {
+  const { verifySignedIn } = authMiddleware(sequelize);
+  const { verifyProjectVisibleFromProjectId } = visibilityMiddleware(sequelize);
+
+  const Tags = defineTag(sequelize, DataTypes);
+
+  router.get('/:tagId', verifySignedIn, verifyProjectVisibleFromProjectId, async (req, res) => {
+    const tagId = req.params.tagId;
+    const projectId = req.query.projectId;
+
+    if (!tagId || !projectId) {
+      return res.status(400).json({
+        error: 'tagId and projectId are required',
+      });
+    }
+
+    try {
+      const tag = await Tags.findOne({
+        where: {
+          projectId: projectId,
+          id: tagId,
+        },
+      });
+
+      if (!tag) {
+        return res.status(404).json({ error: 'Tag not found' });
+      }
+      res.json(tag);
+    } catch (error) {
+      console.error('Error fetching tags:', error);
+      res.status(500).json({ error: 'Internal server error' });
+    }
+  });
+
+  return router;
+}

backend/server.js

@@ -77,10 +77,12 @@ import foldersIndexRoute from './routes/folders/index.js';
 import foldersNewRoute from './routes/folders/new.js';
 import foldersEditRoute from './routes/folders/edit.js';
 import foldersDeleteRoute from './routes/folders/delete.js';
+import foldersCloneRoute from './routes/folders/clone.js';
 app.use('/folders', foldersIndexRoute(sequelize));
 app.use('/folders', foldersNewRoute(sequelize));
 app.use('/folders', foldersEditRoute(sequelize));
 app.use('/folders', foldersDeleteRoute(sequelize));
+app.use('/folders', foldersCloneRoute(sequelize));
 
 // "/cases"
 import casesDownloadRoute from './routes/cases/download.js';
@@ -91,6 +93,7 @@ import casesShowRoute from './routes/cases/show.js';
 import casesNewRoute from './routes/cases/new.js';
 import casesEditRoute from './routes/cases/edit.js';
 import casesDeleteRoute from './routes/cases/delete.js';
+import casesCloneRoute from './routes/cases/clone.js';
 app.use('/cases', casesDownloadRoute(sequelize));
 app.use('/cases', casesMoveRoute(sequelize));
 app.use('/cases', casesIndexRoute(sequelize));
@@ -99,6 +102,7 @@ app.use('/cases', casesShowRoute(sequelize));
 app.use('/cases', casesNewRoute(sequelize));
 app.use('/cases', casesEditRoute(sequelize));
 app.use('/cases', casesDeleteRoute(sequelize));
+app.use('/cases', casesCloneRoute(sequelize));
 
 // "/steps"
 import stepsEditRoute from './routes/steps/edit.js';
@@ -145,6 +149,24 @@ app.use('/members', membersEditRoute(sequelize));
 app.use('/members', membersDeleteRoute(sequelize));
 app.use('/members', membersCheckRoute(sequelize));
 
+// "/tags"
+import tagsNewRoute from './routes/tags/new.js';
+import tagsIndexRoute from './routes/tags/index.js';
+import tagsEditRoute from './routes/tags/edit.js';
+import tagsDeleteRoute from './routes/tags/delete.js';
+import tagsShowRoute from './routes/tags/show.js';
+app.use('/tags', tagsNewRoute(sequelize));
+app.use('/tags', tagsIndexRoute(sequelize));
+app.use('/tags', tagsShowRoute(sequelize));
+app.use('/tags', tagsDeleteRoute(sequelize));
+app.use('/tags', tagsEditRoute(sequelize));
+
+// "/casetags"
+import caseTagsNewRoute from './routes/casetags/new.js';
+import caseTagsDeleteRoute from './routes/casetags/delete.js';
+app.use('/casetags', caseTagsNewRoute(sequelize));
+app.use('/casetags', caseTagsDeleteRoute(sequelize));
+
 // "/home"
 import homeIndexRoute from './routes/home/index.js';
 app.use('/home', homeIndexRoute(sequelize));

frontend/messages/en.json

@@ -211,7 +211,12 @@
     "selected": "Selected",
     "type": "Type",
     "select_types": "Select types",
-    "cases_moved": "Test cases moved"
+    "cases_selected": "cases selected",
+    "select_action": "Select action",
+    "move": "Move",
+    "clone": "Clone",
+    "cases_moved": "Test cases moved",
+    "cases_cloned": "Test cases cloned"
   },
   "Case": {
     "back_to_cases": "Back to test cases",

frontend/messages/ja.json

@@ -212,7 +212,12 @@
     "selected": "選択済み",
     "type": "タイプ",
     "select_types": "タイプを選択",
-    "cases_moved": "テストケースを移動しました"
+    "cases_selected": "件のテストケース",
+    "select_action": "アクションを選択",
+    "move": "移動",
+    "clone": "クローン",
+    "cases_moved": "テストケースを移動しました",
+    "cases_cloned": "テストケースをクローンしました"
   },
   "Case": {
     "back_to_cases": "テストケース一覧に戻る",

frontend/messages/pt-BR.json

@@ -211,7 +211,12 @@
     "selected": "Selecionado",
     "type": "Tipo",
     "select_types": "Selecionar tipos",
-    "moved": "Casos de teste movidos"
+    "cases_selected": "casos selecionados",
+    "select_action": "Selecionar ação",
+    "move": "Mover",
+    "clone": "Clonar",
+    "cases_moved": "Casos de teste movidos",
+    "cases_cloned": "Casos de teste clonados"
   },
   "Case": {
     "back_to_cases": "Voltar para os casos de teste",

frontend/src/app/[locale]/health/HealthPage.tsx

@@ -62,7 +62,7 @@ export default function HealthPage({ messages, locale }: Props) {
           <TableBody>
             <TableRow key="1">
               <TableCell>{messages.unittcms_version}</TableCell>
-              <TableCell>1.0.0-beta.20</TableCell>
+              <TableCell>1.0.0-beta.21</TableCell>
             </TableRow>
             <TableRow key="2">
               <TableCell>{messages.api_server}</TableCell>

frontend/src/app/[locale]/projects/[projectId]/folders/[folderId]/cases/CaseMoveDialog.tsx

@@ -0,0 +1,118 @@
+'use client';
+import { useState } from 'react';
+import { Button, Modal, ModalContent, ModalHeader, ModalBody, ModalFooter, Spinner, addToast } from '@heroui/react';
+import { Copy, Forward } from 'lucide-react';
+import { CasesMessages } from '@/types/case';
+import { moveCases, cloneCases } from '@/utils/caseControl';
+
+type Props = {
+  isOpen: boolean;
+  testCaseIds: number[];
+  projectId: string;
+  targetFolderId?: number;
+  isDisabled: boolean;
+  onCancel: () => void;
+  onMoved: () => void;
+  messages: CasesMessages;
+  token: string;
+};
+
+export default function CaseDialog({
+  isOpen,
+  testCaseIds,
+  projectId,
+  targetFolderId,
+  isDisabled,
+  onCancel,
+  onMoved,
+  messages,
+  token,
+}: Props) {
+  const [isProcessing, setIsProcessing] = useState(false);
+
+  const handleMove = async () => {
+    if (!targetFolderId) {
+      return;
+    }
+
+    setIsProcessing(true);
+    const success = await moveCases(token, testCaseIds, targetFolderId, Number(projectId));
+    setIsProcessing(false);
+
+    if (success) {
+      addToast({
+        title: 'Success',
+        color: 'success',
+        description: messages.casesMoved,
+      });
+      onMoved();
+      onCancel();
+    } else {
+      console.error('Error moving cases');
+    }
+  };
+
+  const handleClone = async () => {
+    if (!targetFolderId) {
+      return;
+    }
+
+    setIsProcessing(true);
+    const success = await cloneCases(token, testCaseIds, targetFolderId, Number(projectId));
+    setIsProcessing(false);
+
+    if (success) {
+      addToast({ title: 'Success', color: 'success', description: messages.casesCloned });
+      onCancel();
+    } else {
+      console.error('Error cloning cases');
+    }
+  };
+
+  return (
+    <Modal
+      isOpen={isOpen}
+      onOpenChange={() => {
+        onCancel();
+      }}
+    >
+      <ModalContent>
+        <ModalHeader className="flex flex-col gap-1">{messages.selectAction}</ModalHeader>
+        <ModalBody>
+          <p>
+            {testCaseIds.length} {messages.casesSelected}
+          </p>
+        </ModalBody>
+        <ModalFooter>
+          {isProcessing ? (
+            <Spinner />
+          ) : (
+            <>
+              <Button variant="light" size="sm" onPress={onCancel}>
+                {messages.close}
+              </Button>
+              <Button
+                color="primary"
+                size="sm"
+                onPress={handleClone}
+                startContent={<Copy size={16} />}
+                isDisabled={isDisabled}
+              >
+                {messages.clone}
+              </Button>
+              <Button
+                color="primary"
+                size="sm"
+                onPress={handleMove}
+                startContent={<Forward size={16} />}
+                isDisabled={isDisabled}
+              >
+                {messages.move}
+              </Button>
+            </>
+          )}
+        </ModalFooter>
+      </ModalContent>
+    </Modal>
+  );
+}

frontend/src/app/[locale]/projects/[projectId]/folders/[folderId]/cases/CasesPane.tsx

@@ -1,13 +1,13 @@
 'use client';
-import { useState, useEffect, useContext } from 'react';
+import { useState, useEffect, useContext, useCallback } from 'react';
 import { useRouter, useSearchParams } from 'next/navigation';
-import { addToast } from '@heroui/react';
 import TestCaseTable from './TestCaseTable';
 import CaseDialog from './CaseDialog';
-import { TokenContext } from '@/utils/TokenProvider';
-import { fetchCases, createCase, deleteCases, exportCases, moveCases } from '@/utils/caseControl';
-import { CaseType, CasesMessages } from '@/types/case';
+import CaseMoveDialog from './CaseMoveDialog';
 import DeleteConfirmDialog from '@/components/DeleteConfirmDialog';
+import { TokenContext } from '@/utils/TokenProvider';
+import { fetchCases, createCase, deleteCases, exportCases } from '@/utils/caseControl';
+import { CaseType, CasesMessages } from '@/types/case';
 import { PriorityMessages } from '@/types/priority';
 import { TestTypeMessages } from '@/types/testType';
 import { LocaleCodeType } from '@/types/locale';
@@ -98,25 +98,6 @@ export default function CasesPane({
     fetchDataEffect();
   }, [context, folderId, searchParams]);
 
-  useEffect(() => {
-    const unsubscribe = onMoveEvent(async (e) => {
-      const { testCaseIds, targetFolderId } = e.detail;
-      const moveRet = await moveCases(context.token.access_token, testCaseIds, targetFolderId, Number(projectId));
-      if (!moveRet) {
-        console.error('Error moving cases');
-        return;
-      }
-
-      setCases(cases.filter((entry) => !testCaseIds.includes(entry.id)));
-      addToast({
-        title: 'Success',
-        color: 'success',
-        description: messages.casesMoved,
-      });
-    });
-    return unsubscribe;
-  }, [cases, context.token.access_token, messages.casesMoved, projectId]);
-
   const closeDialog = () => setIsCaseDialogOpen(false);
 
   const onSubmit = async (title: string, description: string) => {
@@ -159,6 +140,30 @@ export default function CasesPane({
     updateUrlParams({ title: title, priority: priorities, type: types });
   };
 
+  // **************************************************************************
+  // Move/Clone cases
+  // **************************************************************************
+  const [isMoveDialogOpen, setIsMoveDialogOpen] = useState(false);
+  const [selectedCaseIds, setSelectedCaseIds] = useState<number[]>([]);
+  const [targetFolderId, setTargetFolderId] = useState<number | undefined>(undefined);
+  const openMoveDialog = useCallback((caseIds: number[], folderId?: number) => {
+    setSelectedCaseIds(caseIds);
+    setTargetFolderId(folderId);
+    setIsMoveDialogOpen(true);
+  }, []);
+
+  const handleMoved = () => {
+    setCases((prev) => prev.filter((c) => !selectedCaseIds.includes(c.id)));
+  };
+
+  useEffect(() => {
+    const unsubscribe = onMoveEvent(async (e) => {
+      const { testCaseIds, targetFolderId } = e.detail;
+      openMoveDialog(testCaseIds, targetFolderId);
+    });
+    return unsubscribe;
+  }, [openMoveDialog]);
+
   return (
     <>
       <TestCaseTable
@@ -181,6 +186,18 @@ export default function CasesPane({
 
       <CaseDialog isOpen={isCaseDialogOpen} onCancel={closeDialog} onSubmit={onSubmit} messages={messages} />
 
+      <CaseMoveDialog
+        isOpen={isMoveDialogOpen}
+        testCaseIds={selectedCaseIds}
+        projectId={projectId}
+        targetFolderId={targetFolderId}
+        isDisabled={!context.isProjectDeveloper(Number(projectId))}
+        onCancel={() => setIsMoveDialogOpen(false)}
+        onMoved={handleMoved}
+        messages={messages}
+        token={context.token.access_token}
+      />
+
       <DeleteConfirmDialog
         isOpen={isDeleteConfirmDialogOpen}
         onCancel={closeDeleteConfirmDialog}

frontend/src/app/[locale]/projects/[projectId]/folders/[folderId]/cases/TestCaseTable.tsx

@@ -286,7 +286,13 @@ export default function TestCaseTable({
                 placement="top-left"
               >
                 <PopoverTrigger>
-                  <Button startContent={<Filter size={16} />} size="sm" variant="bordered" className="me-2">
+                  <Button
+                    startContent={<Filter size={16} />}
+                    endContent={<ChevronDown size={16} />}
+                    size="sm"
+                    variant="bordered"
+                    className="me-2"
+                  >
                     {messages.filter}
                   </Button>
                 </PopoverTrigger>

frontend/src/app/[locale]/projects/[projectId]/folders/[folderId]/cases/[caseId]/CaseEditor.tsx

@@ -1,5 +1,5 @@
 'use client';
-import { useState, useEffect, useContext, ChangeEvent, DragEvent } from 'react';
+import { useState, useEffect, useContext, useCallback, ChangeEvent, DragEvent } from 'react';
 import { Input, Textarea, Select, SelectItem, Button, Divider, Tooltip, addToast, Badge } from '@heroui/react';
 import { Save, Plus, ArrowLeft, Circle } from 'lucide-react';
 import CaseStepsEditor from './CaseStepsEditor';
@@ -210,24 +210,24 @@ export default function CaseEditor({
     }
   };
 
-  useEffect(() => {
-    async function fetchDataEffect() {
-      if (!tokenContext.isSignedIn()) {
-        return;
-      }
-      try {
-        const data = await fetchCase(tokenContext.token.access_token, Number(caseId));
-        data.Steps.forEach((step: StepType) => {
-          step.editState = 'notChanged';
-        });
-        setTestCase(data);
-      } catch (error: unknown) {
-        logError('Error fetching case data', error);
-      }
+  const fetchAndSetCase = useCallback(async () => {
+    if (!tokenContext.isSignedIn()) {
+      return;
     }
+    try {
+      const data = await fetchCase(tokenContext.token.access_token, Number(caseId));
+      data.Steps.forEach((step: StepType) => {
+        step.editState = 'notChanged';
+      });
+      setTestCase(data);
+    } catch (error: unknown) {
+      logError('Error fetching case data', error);
+    }
+  }, [tokenContext, caseId]);
 
-    fetchDataEffect();
-  }, [caseId, tokenContext]);
+  useEffect(() => {
+    fetchAndSetCase();
+  }, [caseId, tokenContext, fetchAndSetCase]);
 
   return (
     <>
@@ -262,6 +262,7 @@ export default function CaseEditor({
               if (testCase.Steps) {
                 await updateSteps(tokenContext.token.access_token, Number(caseId), testCase.Steps);
               }
+              await fetchAndSetCase();
 
               addToast({
                 title: 'Info',

frontend/src/app/[locale]/projects/[projectId]/folders/[folderId]/cases/page.tsx

@@ -40,7 +40,12 @@ export default function Page({ params }: { params: { projectId: string; folderId
     selected: t('selected'),
     type: t('type'),
     selectTypes: t('select_types'),
+    casesSelected: t('cases_selected'),
+    selectAction: t('select_action'),
+    move: t('move'),
+    clone: t('clone'),
     casesMoved: t('cases_moved'),
+    casesCloned: t('cases_cloned'),
   };
 
   const priorityTranslation = useTranslations('Priority');

frontend/types/case.ts

@@ -84,7 +84,12 @@ type CasesMessages = {
   selected: string;
   type: string;
   selectTypes: string;
+  casesSelected: string;
+  selectAction: string;
+  move: string;
+  clone: string;
   casesMoved: string;
+  casesCloned: string;
 };
 
 type CaseMessages = {

frontend/utils/caseControl.ts

@@ -169,6 +169,28 @@ async function deleteCases(jwt: string, deleteCaseIds: number[], projectId: numb
   }
 }
 
+async function cloneCases(jwt: string, moveCaseIds: number[], targetFolderId: number, projectId: number) {
+  const fetchOptions = {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${jwt}`,
+    },
+    body: JSON.stringify({ caseIds: moveCaseIds, targetFolderId }),
+  };
+  const url = `${apiServer}/cases/clone?projectId=${projectId}`;
+  try {
+    const response = await fetch(url, fetchOptions);
+    if (!response.ok) {
+      throw new Error(`HTTP error! Status: ${response.status}`);
+    }
+    const data = await response.json();
+    return data;
+  } catch (error: unknown) {
+    logError('Error cloning project', error);
+  }
+}
+
 async function exportCases(jwt: string, folderId: number, type: string) {
   if (type !== 'json' && type !== 'csv') {
     console.error('export type error. type:', type);
@@ -202,4 +224,4 @@ async function exportCases(jwt: string, folderId: number, type: string) {
   }
 }
 
-export { fetchCase, fetchCases, updateCase, createCase, deleteCases, exportCases };
+export { fetchCase, fetchCases, updateCase, createCase, deleteCases, cloneCases, exportCases };