public void UploadFile_CsvFile_CallHangfireToEnqueueJobDefinition()
        {
            var projectId = new Guid("4d75753e-618d-4067-9019-f91a64407bca");
            //Arrange
            var coupaHeaderDTO = new CoupaImporterJobDefinitionDTO
            {
                Id       = new Guid("93281c6c-8e96-429c-bb8a-d838b6abe621"),
                FileName = "Test"
            };

            _controller.ControllerContext = new ControllerContext(ContextWithValidRequest());

            _service.CreateInvoiceImportJobDefinition(projectId, Arg.Any <MemoryStream>(), Arg.Any <string>())
            .Returns(coupaHeaderDTO);

            _service.CreatePurchaseOrderImportJobDefinition(projectId, Arg.Any <MemoryStream>(), Arg.Any <string>())
            .Returns(coupaHeaderDTO);

            _service.CreateRequisitionImportJobDefinition(projectId, Arg.Any <MemoryStream>(), Arg.Any <string>())
            .Returns(coupaHeaderDTO);

            //Act
            var invoiceResult       = _controller.UploadInvoice(projectId).Result as OkObjectResult;
            var purchaseOrderResult = _controller.UploadPurchaseOrder(projectId).Result as OkObjectResult;
            var requisitionResult   = _controller.UploadRequisition(projectId).Result as OkObjectResult;

            //TODO: test this
            //Assert
            //_backgroundJobClient.ReceivedWithAnyArgs(1)
            //    .Enqueue(() => { });
        }
        public CoupaImporterJobDefinitionDTO ProcessInvoiceImportJob(Guid jobDefinitionId)
        {
            var jobDefinition = _coupaImporterRepository.Get(jobDefinitionId);

            var allInvoices    = new List <InvoiceDTO>();
            var invoiceHeaders = new List <InvoiceHeader>();

            if (jobDefinition == null)
            {
                return(null);
            }

            _unitOfWork.AutoDetectChanges(false);

            // Here we use 1000 records batch so that we can reduce the number of loops.
            var noOfRotation = jobDefinition.CoupaImporterJobDefinitionDetails.Count() / 1000;

            noOfRotation += jobDefinition.CoupaImporterJobDefinitionDetails.Count() % 1000 > 0 ? 1 : 0;

            for (var i = 0; i < noOfRotation; i++)
            {
                var strCoupaImporterJobDefinitionDetails = "[ ";
                strCoupaImporterJobDefinitionDetails += string.Join(", ", jobDefinition.CoupaImporterJobDefinitionDetails
                                                                    .Skip(i * 1000).Take(1000).Select(x => x.RawContent));
                strCoupaImporterJobDefinitionDetails += " ]";

                // Convert the RawContent to Invoice Header
                invoiceHeaders.AddRange(JsonConvert.DeserializeObject <List <InvoiceHeader> >(strCoupaImporterJobDefinitionDetails));
                // Convert the RawContent to InvoiceDTO
                allInvoices.AddRange(JsonConvert.DeserializeObject <List <InvoiceDTO> >(strCoupaImporterJobDefinitionDetails));
            }

            // In every InvoiceHeader Entity ProjectId is added
            invoiceHeaders.ForEach(i => { i.ProjectId = jobDefinition.ProjectId; i.Id = Guid.NewGuid(); });

            // Grouping InvoiceHeaders in terms of Unique combination of Supplier & InvoiceNumber
            invoiceHeaders = invoiceHeaders.GroupBy(i => new { i.InvoiceNumber, i.Supplier }).Select(x => x.First()).ToList();

            foreach (var objInvoiceHeader in invoiceHeaders)
            {
                // Allocate all line items for a invoice header + InvoiceHeaderId added in every associated Line Items.
                objInvoiceHeader.InvoiceLineItems = allInvoices.Where(x => x.Supplier == objInvoiceHeader.Supplier && x.InvoiceNumber == objInvoiceHeader.InvoiceNumber)
                                                    .Select(x => InvoiceLineItem.MapFromDomainEntity(InvoiceDTO.MapToInvoiceLineItemDTO(x))).ToList();
                objInvoiceHeader.InvoiceLineItems.ToList().ForEach(x => x.InvoiceHeaderId = objInvoiceHeader.Id);

                _projectInvoiceRepository.Add(objInvoiceHeader);
            }

            // At last update all job definition details records
            jobDefinition.CoupaImporterJobDefinitionDetails.ToList().ForEach(c => { c.IsProcessed = true; c.IsSuccessful = true; });
            _coupaImporterRepository.UpdateAllJobDefinitionDetail(jobDefinitionId, jobDefinition.CoupaImporterJobDefinitionDetails);

            jobDefinition.Status = (int)CoupaImporterStatus.Processed;
            _coupaImporterRepository.Update(jobDefinitionId, jobDefinition);

            _unitOfWork.SaveChanges();
            _unitOfWork.AutoDetectChanges(true);

            return(CoupaImporterJobDefinitionDTO.MapFromDatabaseEntity(jobDefinition));
        }
Example #3
0
        public void MapFromDomainEntity_ValidEntity_ReturnDatabaseEntity()
        {
            //Arrange
            var domainEntity = new CoupaImporterJobDefinitionDTO
            {
                Id        = new Guid("45744a2e-3dc1-472f-9bb5-378a0a9eeda4"),
                FileName  = "fileTest.csv",
                Status    = CoupaImporterStatus.Pending,
                TimeStamp = DateTime.UtcNow,
                ProjectId = new  Guid("4d75753e-618d-4067-9019-f91a64407bca"),
                CoupaImporterJobDefinitionDetails = new List <CoupaImporterJobDefinitionDetailDTO>
                {
                    new CoupaImporterJobDefinitionDetailDTO
                    {
                        Id           = new Guid("dd797697-6e95-4175-9637-f84ee3002088"),
                        IsProcessed  = true,
                        IsSuccessful = false
                    }
                }
            };

            //Act
            var result = domain.DatabaseEntities.CoupaImporterJobDefinitions.CoupaImporterJobDefinition.MapFromDomainEntity(domainEntity);

            //Assert
            Assert.AreEqual(domainEntity.Id, result.Id);
            Assert.AreEqual(domainEntity.ProjectId, result.ProjectId);
            Assert.AreEqual(domainEntity.FileName, result.FileName);
            Assert.AreEqual(domainEntity.TimeStamp, result.TimeStamp);
            Assert.AreEqual(domainEntity.Status, (CoupaImporterStatus)result.Status);
            Assert.IsNotNull(result.CoupaImporterJobDefinitionDetails);
            Assert.AreEqual(1, result.CoupaImporterJobDefinitionDetails.Count);
        }
Example #4
0
        public void CreateNewEntity_EmptyEntity_CreateEmptyEntityWithValidId()
        {
            //Act
            var result = new CoupaImporterJobDefinitionDTO();

            //Assert
            Assert.IsNotNull(result.Id);
            Assert.AreNotEqual(new Guid(), result.Id);
        }
        public CoupaImporterJobDefinitionDTO CreateRequisitionImportJobDefinition(Guid projectId, MemoryStream memoryStream, string fileName)
        {
            var requisitionList = CsvExtensionMethods.GetCsvValues <RequisitionDTO>(memoryStream);

            if (requisitionList == null)
            {
                return(null);
            }

            var coupaImporter = SetCoupaImporterJobDefinitionDTO(requisitionList, projectId, fileName, FileType.Requisition);
            var result        = _coupaImporterRepository.Add(CoupaImporterJobDefinition.MapFromDomainEntity(coupaImporter));

            return(CoupaImporterJobDefinitionDTO.MapFromDatabaseEntity(result));
        }
        public CoupaImporterJobDefinitionDTO SetCoupaImporterJobDefinitionDTO <T>(IEnumerable <T> dataList, Guid projectId, string fileName, FileType fileType) where T : new()
        {
            var coupaImporter = new CoupaImporterJobDefinitionDTO
            {
                FileName  = fileName,
                Status    = CoupaImporterStatus.Pending,
                TimeStamp = DateTime.UtcNow,
                ProjectId = projectId,
                FileType  = fileType.ToString(),
                CoupaImporterJobDefinitionDetails = dataList.Select((line, index) => new CoupaImporterJobDefinitionDetailDTO
                {
                    IsProcessed  = false,
                    IsSuccessful = null,
                    RawContent   = JsonConvert.SerializeObject(line),
                    LineNumber   = index + 1
                }).ToList()
            };

            return(coupaImporter);
        }
Example #7
0
        public void MapFromDatabaseEntity_ValidEntity_ReturnDomainEntity()
        {
            //Arrange
            var databaseEntity = new domain.DatabaseEntities.CoupaImporterJobDefinitions.CoupaImporterJobDefinition
            {
                Id        = new Guid("45744a2e-3dc1-472f-9bb5-378a0a9eeda4"),
                FileName  = "fileTest.csv",
                Status    = (int)CoupaImporterStatus.Pending,
                TimeStamp = DateTime.UtcNow,
                ProjectId = new Guid("4d75753e-618d-4067-9019-f91a64407bca")
            };

            //Act
            var result = CoupaImporterJobDefinitionDTO.MapFromDatabaseEntity(databaseEntity);

            //Assert
            Assert.AreEqual(databaseEntity.Id, result.Id);
            Assert.AreEqual(databaseEntity.ProjectId, result.ProjectId);
            Assert.AreEqual(databaseEntity.FileName, result.FileName);
            Assert.AreEqual(databaseEntity.TimeStamp, result.TimeStamp);
            Assert.AreEqual(databaseEntity.Status, (int)result.Status);
        }
        public static CoupaImporterJobDefinition MapFromDomainEntity(CoupaImporterJobDefinitionDTO domainEntity)
        {
            if (domainEntity == null)
            {
                return(null);
            }

            return(new CoupaImporterJobDefinition
            {
                Id = domainEntity.Id,
                FileName = domainEntity.FileName,
                TimeStamp = domainEntity.TimeStamp,
                Status = (int)domainEntity.Status,
                ProjectId = domainEntity.ProjectId,
                FileType = domainEntity.FileType,

                CoupaImporterJobDefinitionDetails =
                    domainEntity.CoupaImporterJobDefinitionDetails
                    ?.Select(CoupaImporterJobDefinitionDetail.MapFromDomainEntity).ToList() ??
                    new List <CoupaImporterJobDefinitionDetail>()
            });
        }
        public void UploadFile_CsvFileAndProjectId_CallServiceToSaveFileCorrectly()
        {
            //Arrange
            var projectId      = new Guid("4d75753e-618d-4067-9019-f91a64407bca");
            var coupaHeaderDTO = new CoupaImporterJobDefinitionDTO
            {
                Id       = new Guid("93281c6c-8e96-429c-bb8a-d838b6abe621"),
                FileName = "Test"
            };

            _controller.ControllerContext = new ControllerContext(ContextWithValidRequest());
            _service.CreateInvoiceImportJobDefinition(projectId, Arg.Any <MemoryStream>(), Arg.Any <string>())
            .Returns(coupaHeaderDTO);

            _service.CreatePurchaseOrderImportJobDefinition(projectId, Arg.Any <MemoryStream>(), Arg.Any <string>())
            .Returns(coupaHeaderDTO);

            _service.CreateRequisitionImportJobDefinition(projectId, Arg.Any <MemoryStream>(), Arg.Any <string>())
            .Returns(coupaHeaderDTO);

            //Act
            var invoiceResult       = _controller.UploadInvoice(projectId).Result as OkObjectResult;
            var purchaseOrderResult = _controller.UploadPurchaseOrder(projectId).Result as OkObjectResult;
            var requisitionResult   = _controller.UploadRequisition(projectId).Result as OkObjectResult;

            //Assert
            Assert.IsNotNull(invoiceResult);
            Assert.AreEqual(200, invoiceResult.StatusCode);

            Assert.IsNotNull(purchaseOrderResult);
            Assert.AreEqual(200, purchaseOrderResult.StatusCode);

            Assert.IsNotNull(requisitionResult);
            Assert.AreEqual(200, requisitionResult.StatusCode);
            _unitOfWork.Received(3).SaveChangesAsync();
        }
        public void SetCoupaImporterJobDefinitionDTO_ReturnValidEntity()
        {
            //Arrange
            var projectId = Guid.NewGuid();
            var coupaImporterJobDefinitionDTO = new CoupaImporterJobDefinitionDTO()
            {
                FileName  = "test.csv",
                Status    = CoupaImporterStatus.Pending,
                TimeStamp = DateTime.UtcNow,
                ProjectId = projectId,
                CoupaImporterJobDefinitionDetails = ValidCoupaImporterJobDefinationDetails()
            };

            //Act
            var response = _service.SetCoupaImporterJobDefinitionDTO <InvoiceDTO>(ValidInvoiceDTOList(), projectId, "test.csv", FileType.Invoice);

            //Assert
            Assert.AreEqual(projectId, response.ProjectId);
            Assert.AreEqual(coupaImporterJobDefinitionDTO.FileName, response.FileName);
            Assert.AreEqual(coupaImporterJobDefinitionDTO.Status, response.Status);
            Assert.AreEqual(coupaImporterJobDefinitionDTO.CoupaImporterJobDefinitionDetails.Count(), response.CoupaImporterJobDefinitionDetails.Count());
            Assert.AreEqual(coupaImporterJobDefinitionDTO.CoupaImporterJobDefinitionDetails.First().RawContent, coupaImporterJobDefinitionDTO.CoupaImporterJobDefinitionDetails.First().RawContent);
            Assert.AreEqual(coupaImporterJobDefinitionDTO.CoupaImporterJobDefinitionDetails.Last().RawContent, coupaImporterJobDefinitionDTO.CoupaImporterJobDefinitionDetails.Last().RawContent);
        }