private async Task <Tag> DuplicateTagAsync(DuplicateAreaTagCommand request, Tag sourceTag)
        {
            if (!sourceTag.IsReadyToBeDuplicated())
            {
                throw new Exception($"Tag {sourceTag.TagNo} of type {sourceTag.TagType} can't be duplicated");
            }

            var reqDefIds = sourceTag.Requirements.Select(r => r.RequirementDefinitionId).ToList();
            var reqDefs   = await _requirementTypeRepository.GetRequirementDefinitionsByIdsAsync(reqDefIds);

            var requirements = new List <TagRequirement>();

            foreach (var requirement in sourceTag.Requirements)
            {
                var reqDef = reqDefs.Single(rd => rd.Id == requirement.RequirementDefinitionId);
                requirements.Add(new TagRequirement(_plantProvider.Plant, requirement.IntervalWeeks, reqDef));
            }

            var step = await _journeyRepository.GetStepByStepIdAsync(sourceTag.StepId);

            var duplicatedTag = new Tag(
                _plantProvider.Plant,
                request.TagType,
                request.GetTagNo(),
                request.Description,
                step,
                requirements)
            {
                Remark      = request.Remark,
                StorageArea = request.StorageArea
            };

            return(duplicatedTag);
        }
        public async Task <Result <int> > Handle(DuplicateAreaTagCommand request, CancellationToken cancellationToken)
        {
            var sourceTag = await _projectRepository.GetTagByTagIdAsync(request.TagId);

            var duplicatedTag = await DuplicateTagAsync(request, sourceTag);

            if (!await SetAreaDataSuccessfullyAsync(duplicatedTag, request.AreaCode))
            {
                return(new NotFoundResult <int>($"Area with code {request.AreaCode} not found"));
            }

            if (!await SetDisciplineDataSuccessfullyAsync(duplicatedTag, request.DisciplineCode))
            {
                return(new NotFoundResult <int>($"Discipline with code {request.DisciplineCode} not found"));
            }

            var project = await _projectRepository.GetProjectOnlyByTagIdAsync(request.TagId);

            project.AddTag(duplicatedTag);

            await _unitOfWork.SaveChangesAsync(cancellationToken);

            return(new SuccessResult <int>(duplicatedTag.Id));
        }