예제 #1
0
        public void Setup()
        {
            _command = new DeleteAppealFileCommand
            {
                ApplicationId = _applicationId,
                FileName      = _fileName,
                UserId        = "userId",
                UserName      = "******"
            };

            var upload = new AppealFile {
                Id = _appealUploadId, FileName = _fileName, ApplicationId = _applicationId
            };

            _appealUploadRepository = new Mock <IAppealFileRepository>();
            _appealUploadRepository.Setup(x => x.Get(_applicationId, _fileName)).ReturnsAsync(upload);
            _appealUploadRepository.Setup(x => x.Get(_appealUploadId)).ReturnsAsync(upload);
            _appealUploadRepository.Setup(x => x.Remove(It.IsAny <Guid>()));

            _auditService = new Mock <IAuditService>();
            _auditService.Setup(x => x.StartTracking(UserAction.RemoveAppealFile, _command.UserId, _command.UserName));
            _auditService.Setup(x => x.AuditDelete(It.IsAny <AppealFile>()));

            _handler = new DeleteAppealFileCommandHandler(_appealUploadRepository.Object, _auditService.Object);
        }
        public async Task PersistAdd(AppealFile entity)
        {
            var transaction = _unitOfWork.GetTransaction();

            await transaction.Connection.ExecuteAsync(
                @"INSERT INTO [AppealFile]
                    ([Id],
                    [ApplicationId],
                    [FileName],
                    [ContentType],
                    [Size],
                    [UserId],
                    [UserName],
                    [CreatedOn])
                    VALUES (
                    @Id,
                    @ApplicationId,
                    @FileName,
                    @ContentType,
                    @Size,
                    @UserId,
                    @UserName,
                    @CreatedOn)",
                entity, transaction);
        }
예제 #3
0
        public async Task Run_Downloads_and_Saves_Appeal_File_Into_BlobStorage()
        {
            var appealfile = new AppealFile {
                ApplicationId = _applicationId, FileName = "file.pdf"
            };

            var request = new AppealFileExtractRequest(appealfile);
            await _sut.Run(request);

            _applyApiClient.Verify(x => x.DownloadAppealFile(_applicationId, appealfile.FileName), Times.Once);
            _blobClient.Verify(x => x.UploadAsync(It.IsAny <Stream>(), true, It.IsAny <CancellationToken>()), Times.Once);
        }
        public async Task PersistUpdate(AppealFile entity)
        {
            var transaction = _unitOfWork.GetTransaction();

            await transaction.Connection.ExecuteAsync(
                @"UPDATE [AppealFile]
                    SET [FileName] = @FileName,
                    [ContentType] = @ContentType,
                    [Size] = @Size,
                    [UserId] =  @UserId,
                    [UserName] =  @UserName,
                    [CreatedOn] = @CreatedOn
                WHERE [Id] = @id",
                entity, transaction);
        }
        public void Setup()
        {
            _appealsQueries = new Mock <IAppealsQueries>();

            _appealFile = new AppealFile
            {
                FileName      = _fileName,
                ContentType   = _contentType,
                ApplicationId = _applicationId,
                Id            = _appealFileId
            };

            _appealsQueries.Setup(x => x.GetAppealFile(_applicationId, _fileName)).ReturnsAsync(_appealFile);

            _handler = new GetAppealFileQueryHandler(_appealsQueries.Object);
        }
 public APIResult AppealFileSave(AppealFile appealFile)
 {
     try
     {
         appealService.AppealFileSave(appealFile);
         return(new APIResult()
         {
             Status = true, Body = ""
         });
     }
     catch (Exception ex)
     {
         return(new APIResult()
         {
             Status = false, Body = ex.Message.ToString()
         });
     }
 }
예제 #7
0
        public async Task Handle_Records_Uploaded_File_When_Existing()
        {
            var existingFile = new AppealFile {
                ApplicationId = _command.ApplicationId, FileName = _command.AppealFile.FileName
            };

            _appealUploadRepository.Setup(x => x.Get(_command.ApplicationId, _command.AppealFile.FileName)).ReturnsAsync(existingFile);

            await _handler.Handle(_command, CancellationToken.None);

            _appealUploadRepository.Verify(x => x.Update(It.Is <AppealFile>(upload =>
                                                                            upload.ApplicationId == _command.ApplicationId &&
                                                                            upload.FileName == _command.AppealFile.FileName &&
                                                                            upload.ContentType == _command.AppealFile.ContentType &&
                                                                            upload.UserId == _command.UserId &&
                                                                            upload.UserName == _command.UserName &&
                                                                            upload.Size == _command.AppealFile.Data.Length
                                                                            )));

            _auditService.Verify(x => x.Save());
        }
 /// <summary>
 ///
 /// </summary>
 /// <param name="appealFile"></param>
 public void AppealFileSave(AppealFile appealFile)
 {
     if (appealFile.SeqNO == 0)
     {
         AppealFile findOneMax = db.AppealFile.Where(x => (x.AppealId == appealFile.AppealId)).OrderByDescending(x => x.SeqNO).FirstOrDefault();
         if (findOneMax == null)
         {
             appealFile.SeqNO = 1;
         }
         else
         {
             appealFile.SeqNO = findOneMax.SeqNO + 1;
         }
         appealFile.InDateTime = DateTime.Now;
         db.AppealFile.Add(appealFile);
     }
     else
     {
     }
     db.SaveChanges();
 }
        public async Task <Unit> Handle(UploadAppealFileCommand request, CancellationToken cancellationToken)
        {
            _auditService.StartTracking(UserAction.UploadAppealFile, request.UserId, request.UserName);

            var appealFile = await _appealFileRepository.Get(request.ApplicationId, request.AppealFile.FileName);

            if (appealFile is null)
            {
                appealFile = new AppealFile
                {
                    ApplicationId = request.ApplicationId,
                    ContentType   = request.AppealFile.ContentType,
                    FileName      = request.AppealFile.FileName,
                    Size          = request.AppealFile.Data.Length,
                    UserId        = request.UserId,
                    UserName      = request.UserName
                };

                _auditService.AuditInsert(appealFile);
                _appealFileRepository.Add(appealFile);
            }
            else
            {
                _auditService.AuditUpdate(appealFile);

                appealFile.ContentType = request.AppealFile.ContentType;
                appealFile.Size        = request.AppealFile.Data.Length;
                appealFile.UserId      = request.UserId;
                appealFile.UserName    = request.UserName;
                appealFile.CreatedOn   = DateTime.UtcNow;

                _appealFileRepository.Update(appealFile);
            }

            _auditService.Save();

            return(await Task.FromResult(Unit.Value));
        }
예제 #10
0
 public AppealFileExtractRequest(AppealFile appealFile)
 {
     ApplicationId = appealFile.ApplicationId;
     FileName      = appealFile.FileName;
 }
 public void Update(AppealFile entity)
 {
     _unitOfWork.Register(() => PersistUpdate(entity));
 }
 public void Add(AppealFile entity)
 {
     _unitOfWork.Register(() => PersistAdd(entity));
 }