public async Task <IActionResult> UploadFieldValueAttachment(
            [FromHeader(Name = CurrentPlantMiddleware.PlantHeader)]
            [Required]
            [StringLength(PlantEntityBase.PlantLengthMax, MinimumLength = PlantEntityBase.PlantLengthMin)]
            string plant,
            [FromRoute] int id,
            [FromRoute] int requirementId,
            [FromRoute] int fieldId,
            [FromForm] UploadAttachmentForceOverwriteDto dto)
        {
            await using var stream = dto.File.OpenReadStream();

            var command = new UploadFieldValueAttachmentCommand(
                id,
                requirementId,
                fieldId,
                dto.File.FileName,
                stream);

            var result = await _mediator.Send(command);

            return(this.FromResult(result));
        }
        public void Setup_OkState()
        {
            _projectValidatorMock = new Mock <IProjectValidator>();
            _tagValidatorMock     = new Mock <ITagValidator>();
            _tagValidatorMock.Setup(v => v.ExistsRequirementAsync(TagId, ReqId, default))
            .Returns(Task.FromResult(true));
            _tagValidatorMock
            .Setup(v => v.ExistsFieldForRequirementAsync(TagId, ReqId, AttachmentFieldId, default))
            .Returns(Task.FromResult(true));
            _tagValidatorMock.Setup(v => v.HasRequirementWithActivePeriodAsync(TagId, ReqId, default))
            .Returns(Task.FromResult(true));
            _fieldValidatorMock = new Mock <IFieldValidator>();
            _fieldValidatorMock.Setup(r => r.IsValidForAttachmentAsync(AttachmentFieldId, default))
            .Returns(Task.FromResult(true));

            _command = new UploadFieldValueAttachmentCommand(
                TagId,
                ReqId,
                AttachmentFieldId,
                "F",
                new MemoryStream());

            _dut = new UploadFieldValueAttachmentCommandValidator(_projectValidatorMock.Object, _tagValidatorMock.Object, _fieldValidatorMock.Object);
        }
        public void Setup()
        {
            var _tagId             = 1;
            var _attachmentFieldId = 12;
            var _reqId             = 21;

            _command = new UploadFieldValueAttachmentCommand(
                _tagId,
                _reqId,
                _attachmentFieldId,
                _fileName,
                new MemoryStream());

            _requirementDefinition = new Mock <RequirementDefinition>();
            _requirementDefinition.SetupGet(r => r.Id).Returns(_reqId);
            _requirementDefinition.SetupGet(r => r.Plant).Returns(TestPlant);

            var attachmentFieldMock = new Mock <Field>(TestPlant, "", FieldType.Attachment, 0, "", false);

            attachmentFieldMock.SetupGet(f => f.Id).Returns(_attachmentFieldId);
            attachmentFieldMock.SetupGet(f => f.Plant).Returns(TestPlant);
            _requirementDefinition.Object.AddField(attachmentFieldMock.Object);

            var requirementMock = new Mock <TagRequirement>(TestPlant, 2, _requirementDefinition.Object);

            requirementMock.SetupGet(r => r.Id).Returns(_reqId);
            requirementMock.SetupGet(r => r.Plant).Returns(TestPlant);
            _requirement = requirementMock.Object;

            var stepMock = new Mock <Step>();

            stepMock.SetupGet(s => s.Plant).Returns(TestPlant);
            var tag = new Tag(TestPlant, TagType.Standard, "", "", stepMock.Object, new List <TagRequirement>
            {
                _requirement
            });

            tag.StartPreservation();
            Assert.AreEqual(PreservationStatus.Active, tag.Status);
            Assert.IsTrue(_requirement.HasActivePeriod);

            var _projectRepositoryMock = new Mock <IProjectRepository>();

            _projectRepositoryMock
            .Setup(r => r.GetTagByTagIdAsync(_tagId))
            .Returns(Task.FromResult(tag));

            var _rtRepositoryMock = new Mock <IRequirementTypeRepository>();

            _rtRepositoryMock
            .Setup(r => r.GetRequirementDefinitionByIdAsync(_reqId))
            .Returns(Task.FromResult(_requirementDefinition.Object));

            _blobStorageMock = new Mock <IBlobStorage>();

            var attachmentOptionsMock = new Mock <IOptionsMonitor <AttachmentOptions> >();
            var options = new AttachmentOptions
            {
                MaxSizeMb         = 2,
                BlobContainer     = _blobContainer,
                ValidFileSuffixes = new[] { ".gif", ".jpg" }
            };

            attachmentOptionsMock
            .Setup(x => x.CurrentValue)
            .Returns(options);

            _dut = new UploadFieldValueAttachmentCommandHandler(
                _projectRepositoryMock.Object,
                _rtRepositoryMock.Object,
                UnitOfWorkMock.Object,
                PlantProviderMock.Object,
                _blobStorageMock.Object,
                attachmentOptionsMock.Object);
        }