示例#1
0
        public async Task <Result <int> > Handle(CreateClaimCommand request, CancellationToken cancellationToken)
        {
            var claim = new Claim
            {
                Title             = request.Title,
                RequesterId       = request.RequesterId,
                ApproverId        = request.ApproverId,
                SubmitDate        = request.SubmitDate,
                TotalAmount       = request.TotalAmount,
                RequesterComments = request.RequesterComments,
                ClaimItems        = new List <ClaimItem>(),
            };

            foreach (CreateClaimCommandItemDto i in request.ClaimItems)
            {
                claim.ClaimItems.Add(new ClaimItem
                {
                    Payee           = i.Payee,
                    Date            = i.Date,
                    Description     = i.Description,
                    Amount          = i.Amount,
                    USDAmount       = i.USDAmount,
                    Image           = i.Image,
                    CurrencyId      = i.CurrencyId,
                    ClaimCategoryId = i.ClaimCategoryId,
                });
            }

            await _claimsRepository.InsertAsync(claim);

            await _unitOfWork.Commit(cancellationToken);

            return(Result <int> .Success(claim.Id));
        }
        public async void AddClaimDocument()
        {
            _logger.LogInformation("AddClaimDocument...");
            {
                var newItem = A.New <TestClaim>();
                var policy  = _policiesFixture.Items[A.Random.Next(0, _policiesFixture.Items.Count - 1)];
                newItem.PolicyId = policy.PolicyId;
                using (var dbTransaction = await _dbConnectionFactory.BeginUserTransactionAsync(_userId))
                {
                    try
                    {
                        newItem = await _claimsRepository.InsertAsync(dbTransaction, newItem);

                        dbTransaction.Commit();

                        Assert.NotNull(newItem);
                        Assert.NotEqual(0, newItem.ClaimId);
                    }
                    catch
                    {
                        dbTransaction.Rollback();
                        throw;
                    }
                }
            }

            int claimId = -1;

            using (var dbConnection = await _dbConnectionFactory.OpenUserConnectionAsync(_userId))
            {
                claimId = (await _claimsRepository.GetAsync <TestClaim>(dbConnection)).Last().ClaimId;
            }

            Document insertedDocument;

            using (var dbTransaction = await _dbConnectionFactory.BeginUserTransactionAsync(_userId))
            {
                var newItem = new Document()
                {
                    Name = $"REPOSITORY_TEST_{DateTime.Now:yyyyMMddHHmmssfff}.jpg",
                    Type = "jpg",
                    Data = await File.ReadAllBytesAsync("./TestFiles/Test.jpg")
                };
                insertedDocument = await _repository.InsertDocumentAsync(dbTransaction, newItem);

                await _repository.AddClaimDocument(dbTransaction, claimId, insertedDocument.DocumentId);

                dbTransaction.Commit();
            }
            using (var dbConnection = await _dbConnectionFactory.OpenUserConnectionAsync(_userId))
            {
                var result = await _repository.GetClaimDocumentsAsync(dbConnection, claimId);

                Assert.NotNull(result);
                Assert.Contains(result, candidate => candidate.DocumentId == insertedDocument.DocumentId);
            }
        }