public SaleCommissionDistributionService(
ISalesUnitOfWork uow,
SaleCommissionCalculator commissionCalculator)
{
this.uow = uow;
this.commissionCalculator = commissionCalculator;
}
public void GithubHookConsumer_NothingInDb_WhenHandlingBadHook()
{
ISalesHandlerFactory fileHandlerFactory = new TestGithubSalesHandlerFactory(DependencyContainer.Container);
IHookConsumer hookConsumer = DependencyContainer.Container.Resolve <IHookConsumer>(new ResolverOverride[]
{
new ParameterOverride(typeof(ISalesHandlerFactory), fileHandlerFactory),
new ParameterOverride("githubRepoToken", Token),
new ParameterOverride("hookParser", new GithubHookParser(f => FileNameValidator.Validate(f)))
});
using (ISalesUnitOfWork unitOfWork = DependencyContainer.Container.Resolve <ISalesUnitOfWork>())
{
lock (lockObject)
{
int customersCount = unitOfWork.Customers.Get().Count();
int productsCount = unitOfWork.Products.Get().Count();
int sourceFilesCount = unitOfWork.SourceFiles.Get().Count();
int salesCount = unitOfWork.Sales.Get().Count();
int errorsCount = unitOfWork.ErrorFiles.Get().Count();
hookConsumer.ConsumeHookAsync("../../Data/bad_hook1.json").GetAwaiter().GetResult();
int customersCountAfter = unitOfWork.Customers.Get().Count();
int productsCountAfter = unitOfWork.Products.Get().Count();
int sourceFilesCountAfter = unitOfWork.SourceFiles.Get().Count();
int salesCountAfter = unitOfWork.Sales.Get().Count();
int errorsCountAfter = unitOfWork.ErrorFiles.Get().Count();
Assert.AreEqual(customersCount, customersCountAfter);
Assert.AreEqual(productsCount, productsCountAfter);
Assert.AreEqual(sourceFilesCount, sourceFilesCountAfter);
Assert.AreEqual(salesCount, salesCountAfter);
Assert.AreEqual(errorsCount, errorsCountAfter);
}
}
}
public RegisterCustomerHandler(
ISalesUnitOfWork unitOfWork,
ICustomerRepository repository)
{
_unitOfWork = unitOfWork;
_repository = repository;
}
public OrdersApplicationService(IAppLogger logger, IOrdersRepository ordersRepository, IOffersRepository offersRepository, ISalesUnitOfWork unitOfWork)
{
this.logger = logger;
this.ordersRepository = ordersRepository;
this.offersRepository = offersRepository;
this.unitOfWork = unitOfWork;
}
public OffersApplicationService(IAppLogger logger, ISalesUnitOfWork unitOfWork, IOffersRepository offersRepository, IPriceCalculationService priceCalculationService)
{
this.logger = logger;
this.unitOfWork = unitOfWork;
this.offersRepository = offersRepository;
this.priceCalculationService = priceCalculationService;
}
public EditProductHandler(
ISalesUnitOfWork unitOfWork,
IProductRepository repository)
{
_unitOfWork = unitOfWork;
_repository = repository;
}
public RemoveCustomerChileProductAttributeRangesCommand(ISalesUnitOfWork salesUnitOfWork)
{
if (salesUnitOfWork == null)
{
throw new ArgumentNullException("salesUnitOfWork");
}
_salesUnitOfWork = salesUnitOfWork;
}
public CreateInterWarehouseOrderConductor(ISalesUnitOfWork interWarehouseOrderUnitOfWork)
{
if (interWarehouseOrderUnitOfWork == null)
{
throw new ArgumentNullException("interWarehouseOrderUnitOfWork");
}
_interWarehouseOrderUnitOfWork = interWarehouseOrderUnitOfWork;
}
protected SalesOrderConductorBase(ISalesUnitOfWork salesUnitOfWork)
{
if (salesUnitOfWork == null)
{
throw new ArgumentNullException("salesUnitOfWork");
}
SalesUnitOfWork = salesUnitOfWork;
}
internal SetSalesOrderItemsCommand(ISalesUnitOfWork salesUnitOfWork)
{
if (salesUnitOfWork == null)
{
throw new ArgumentNullException("salesUnitOfWork");
}
_salesUnitOfWork = salesUnitOfWork;
}
internal SetCustomerProductCodeCommand(ISalesUnitOfWork salesUnitOfWork)
{
if (salesUnitOfWork == null)
{
throw new ArgumentNullException("salesUnitOfWork");
}
_salesUnitOfWork = salesUnitOfWork;
}
internal UpdateCustomerContractConductor(ISalesUnitOfWork salesUnitOfWork)
{
if (salesUnitOfWork == null)
{
throw new ArgumentNullException("salesUnitOfWork");
}
_salesUnitOfWork = salesUnitOfWork;
}
internal SetSalesOrderPickedInventoryConductor(ISalesUnitOfWork salesSalesUnitOfWork)
{
if (salesSalesUnitOfWork == null)
{
throw new ArgumentNullException("salesSalesUnitOfWork");
}
_salesUnitOfWork = salesSalesUnitOfWork;
}
internal CompleteExpiredContractsCommand(ISalesUnitOfWork salesUnitOfWork)
{
if (salesUnitOfWork == null)
{
throw new ArgumentNullException("salesUnitOfWork");
}
_salesUnitOfWork = salesUnitOfWork;
}
internal RemoveContractCommand(ISalesUnitOfWork salesUnitOfWork)
{
if (salesUnitOfWork == null)
{
throw new ArgumentNullException("salesUnitOfWork");
}
_salesUnitOfWork = salesUnitOfWork;
}
static void Main(string[] args)
{
CreateDepenencies();
ISalesUnitOfWork unitOfWork = container.Resolve <ISalesUnitOfWork>();
var cust = unitOfWork.Customers.Get().ToList();
//GetFileContent_Example();
Console.ReadKey();
}
public void SaleDbDataManager_AddSaleData_AddsWithNoDuplicates()
{
SaleDataDto saleDataDto = GetSaleData();
var groupedSales = saleDataDto.Sales
.GroupBy(sale => new { sale.CustomerName, sale.ProductName, sale.SaleDate },
(key, sales) => new SaleDto()
{
CustomerName = key.CustomerName,
ProductName = key.ProductName,
SaleDate = key.SaleDate,
TotalSum = sales.Sum(s => s.TotalSum)
});
int customersCount = saleDataDto.Sales.Select(s => s.CustomerName).Distinct().Count();
int productsCount = saleDataDto.Sales.Select(s => s.ProductName).Distinct().Count();
int salesCount = groupedSales.Count();
using (ISalesUnitOfWork unitOfWork = DependencyContainer.Container.Resolve <ISalesUnitOfWork>())
using (ISalesDataManager manager = DependencyContainer.Container.Resolve <ISalesDataManager>())
{
int initialCustomersCount = unitOfWork.Customers.Get().Count();
int initialProductsCount = unitOfWork.Products.Get().Count();
int initialSalesCount = unitOfWork.Sales.Get().Count();
var res = manager.AddOrUpdateSaleDataAsync(saleDataDto).GetAwaiter().GetResult();
int savedSalesCount = unitOfWork.Sales.Get().Count();
int savedCustomersCount = unitOfWork.Customers.Get().Count();
int savedProductsCount = unitOfWork.Products.Get().Count();
Assert.IsTrue(res.Succeeded);
Assert.AreEqual(customersCount + initialCustomersCount, savedCustomersCount);
Assert.AreEqual(productsCount + initialProductsCount, savedProductsCount);
Assert.AreEqual(salesCount + initialSalesCount, savedSalesCount);
// Second time same file
saleDataDto = GetSaleData(1);
groupedSales = saleDataDto.Sales
.GroupBy(sale => new { sale.CustomerName, sale.ProductName, sale.SaleDate },
(key, sales) => new SaleDto()
{
CustomerName = key.CustomerName,
ProductName = key.ProductName,
SaleDate = key.SaleDate,
TotalSum = sales.Sum(s => s.TotalSum)
});
res = manager.AddOrUpdateSaleDataAsync(saleDataDto).GetAwaiter().GetResult();
savedSalesCount = unitOfWork.Sales.Get().Count();
savedCustomersCount = unitOfWork.Customers.Get().Count();
savedProductsCount = unitOfWork.Products.Get().Count();
Assert.IsTrue(res.Succeeded);
Assert.AreEqual(customersCount + initialCustomersCount, savedCustomersCount);
Assert.AreEqual(productsCount + initialProductsCount, savedProductsCount);
Assert.AreEqual(salesCount + initialSalesCount, savedSalesCount);
}
}
public void SaleFileHandling_ErrorRemovedWhenDataHandled_And_SecondTimeSameDataReplacedOld()
{
string url = "https://api.github.com/repos/NAlex2004/SalesData/contents/Manager_2/AlNaz_04032019.json";
lock (lockObject)
{
ISalesDataManager manager = DependencyContainer.Container.Resolve <ISalesDataManager>();
using (GithubSalesHandler fileHandler = new GithubSalesHandler(manager))
{
using (ISalesUnitOfWork unitOfWork = DependencyContainer.Container.Resolve <ISalesUnitOfWork>())
{
var errorAdded = manager.ErrorManager.AddErrorAsync(new SaleManagementResult()
{
FileName = "AlNaz_04032019.json", ErrorMessage = "Test error"
}).GetAwaiter().GetResult();
int errors = unitOfWork.ErrorFiles.Get().Count();
ISaleDataSource saleDataSource = DependencyContainer.Container.Resolve <ISaleDataSource>(new ResolverOverride[]
{
new ParameterOverride("fileEntry", new GithubFileEntry()
{
Url = url, CommitDate = DateTime.Now
}),
new ParameterOverride("githubRepoToken", Token)
});
var fileLoadResult = saleDataSource.GetSaleDataAsync().GetAwaiter().GetResult();
fileHandler.HandleSaleDataAsync(fileLoadResult).GetAwaiter().GetResult();
int errorsAfter = unitOfWork.ErrorFiles.Get().Count();
Assert.IsTrue(errorAdded.Succeeded);
Assert.AreEqual(errors - 1, errorsAfter);
// Second time same data
fileHandler.HandleSaleDataAsync(fileLoadResult).GetAwaiter().GetResult();
var sourceFile = unitOfWork.SourceFiles.Get(f => f.FileName.Equals("AlNaz_04032019.json")).Single();
int salesCount = unitOfWork.Sales.Get(s => s.SourceFileId == sourceFile.Id).Count();
int errorsCount = unitOfWork.ErrorFiles.Get(e => e.FileName.Equals("AlNaz_04032019.json")).Count();
Assert.AreEqual(5, salesCount);
Assert.AreEqual(0, errorsCount);
}
}
}
}
public void GithubHookConsumer_HandlingSameHookInParallelThreads_EachFileSavedOnlyOnce()
{
ISalesHandlerFactory fileHandlerFactory = new TestGithubSalesHandlerFactory(DependencyContainer.Container);
IHookConsumer hookConsumer = DependencyContainer.Container.Resolve <IHookConsumer>(new ResolverOverride[]
{
new ParameterOverride(typeof(ISalesHandlerFactory), fileHandlerFactory),
new ParameterOverride("githubRepoToken", Token),
new ParameterOverride("hookParser", new GithubHookParser(f => FileNameValidator.Validate(f)))
});
IHookConsumer hookConsumer2 = DependencyContainer.Container.Resolve <IHookConsumer>(new ResolverOverride[]
{
new ParameterOverride(typeof(ISalesHandlerFactory), fileHandlerFactory),
new ParameterOverride("githubRepoToken", Token),
new ParameterOverride("hookParser", new GithubHookParser(f => FileNameValidator.Validate(f)))
});
using (ISalesUnitOfWork unitOfWork = DependencyContainer.Container.Resolve <ISalesUnitOfWork>())
{
lock (lockObject)
{
unitOfWork.Customers.Delete(x => true);
unitOfWork.Products.Delete(x => true);
unitOfWork.SourceFiles.Delete(x => true);
unitOfWork.Sales.Delete(x => true);
unitOfWork.ErrorFiles.Delete(x => true);
unitOfWork.SaveChanges();
string hookJson = File.ReadAllText("../../Data/hook1.json");
var task1 = hookConsumer.ConsumeHookAsync(hookJson);
var task2 = hookConsumer2.ConsumeHookAsync(hookJson);
Task.WaitAll(task1, task2);
int customersCountAfter = unitOfWork.Customers.Get().Count();
int productsCountAfter = unitOfWork.Products.Get().Count();
int sourceFilesCountAfter = unitOfWork.SourceFiles.Get().Count();
int salesCountAfter = unitOfWork.Sales.Get().Count();
int errorsCountAfter = unitOfWork.ErrorFiles.Get().Count();
Assert.AreEqual(5, customersCountAfter);
Assert.AreEqual(4, productsCountAfter);
Assert.AreEqual(2, sourceFilesCountAfter);
Assert.AreEqual(10, salesCountAfter);
Assert.IsTrue(errorsCountAfter >= 2);
}
}
}
public void GithubHookConsumer_DbHasCorrectData_WhenHandlingGoodHook()
{
ISalesHandlerFactory fileHandlerFactory = new TestGithubSalesHandlerFactory(DependencyContainer.Container);
IHookConsumer hookConsumer = DependencyContainer.Container.Resolve <IHookConsumer>(new ResolverOverride[]
{
new ParameterOverride(typeof(ISalesHandlerFactory), fileHandlerFactory),
new ParameterOverride("githubRepoToken", Token),
new ParameterOverride("hookParser", new GithubHookParser(f => FileNameValidator.Validate(f)))
});
using (ISalesUnitOfWork unitOfWork = DependencyContainer.Container.Resolve <ISalesUnitOfWork>())
{
lock (lockObject)
{
unitOfWork.Customers.Delete(x => true);
unitOfWork.Products.Delete(x => true);
unitOfWork.SourceFiles.Delete(x => true);
unitOfWork.Sales.Delete(x => true);
unitOfWork.ErrorFiles.Delete(x => true);
unitOfWork.SaveChanges();
string hookJson = File.ReadAllText("../../Data/hook1.json");
hookConsumer.ConsumeHookAsync(hookJson).GetAwaiter().GetResult();
int customersCountAfter = unitOfWork.Customers.Get().Count();
int productsCountAfter = unitOfWork.Products.Get().Count();
int sourceFilesCountAfter = unitOfWork.SourceFiles.Get().Count();
int salesCountAfter = unitOfWork.Sales.Get().Count();
int errorsCountAfter = unitOfWork.ErrorFiles.Get().Count();
Assert.AreEqual(5, customersCountAfter);
Assert.AreEqual(4, productsCountAfter);
Assert.AreEqual(2, sourceFilesCountAfter);
Assert.AreEqual(10, salesCountAfter);
Assert.AreEqual(2, errorsCountAfter);
}
}
}
public SaleService(ISalesUnitOfWork uow)
{
this.uow = uow;
}
public ErrorManager(ISalesUnitOfWork unitOfWork)
{
this.unitOfWork = unitOfWork ?? throw new ArgumentNullException();
}
internal static IEnumerable <Expression <Func <PickedInventoryItem, PickedInventoryItemReturn> > > SplitSelect(IInventoryUnitOfWork inventoryUnitOfWork, DateTime currentDate, ISalesUnitOfWork salesUnitOfWork = null)
{
if (inventoryUnitOfWork == null)
{
throw new ArgumentNullException("inventoryUnitOfWork");
}
var pickedInventoryItemKey = SelectKey();
var inventoryKey = SelectInventoryKey();
var inventoryQuantity = SelectInventoryQuantity();
var treatment = InventoryTreatmentProjectors.SelectInventoryTreatment();
var location = LocationProjectors.SelectLocation();
var packagingProduct = ProductProjectors.SelectPackagingProduct();
var results = LotProjectors.SplitSelectLotSummary(inventoryUnitOfWork, currentDate)
.Select(p => p.Merge((Expression <Func <PickedInventoryItem, PickedInventoryItemReturn> >)(n => new PickedInventoryItemReturn {
}), n => n.Lot))
.ToListWithModifiedElement(0, p => p.Merge(i => new PickedInventoryItemReturn
{
PickedInventoryItemKeyReturn = pickedInventoryItemKey.Invoke(i),
InventoryKeyReturn = inventoryKey.Invoke(i),
ToteKey = i.ToteKey,
QuantityPicked = i.Quantity,
CustomerLotCode = i.CustomerLotCode,
CustomerProductCode = i.CustomerProductCode
}))
.ToAppendedList(i => new PickedInventoryItemReturn
{
PackagingProduct = packagingProduct.Invoke(i.PackagingProduct),
Location = location.Invoke(i.FromLocation),
InventoryTreatment = treatment.Invoke(i.Treatment),
},
i => new PickedInventoryItemReturn
{
PackagingReceived = packagingProduct.Invoke(i.Lot.ReceivedPackaging),
Quantity = inventoryQuantity.Invoke(i),
CurrentLocation = location.Invoke(i.CurrentLocation),
});
if (salesUnitOfWork != null)
{
var orderItemKey = InventoryPickOrderItemProjectors.SelectKey();
var customerPickedItems = salesUnitOfWork.SalesOrderPickedItemRepository.All();
results.Add(i => new PickedInventoryItemReturn
{
PickOrderItemKeyReturn = customerPickedItems
.Where(c => c.DateCreated == i.DateCreated && c.Sequence == i.Sequence && c.ItemSequence == i.ItemSequence)
.Select(c => orderItemKey.Invoke(c.SalesOrderItem.InventoryPickOrderItem))
.FirstOrDefault()
});
}
return(results.Select(p => p.ExpandAll()));
}
public CustomerService(ISalesUnitOfWork uow)
{
this.uow = uow;
}
public CategoryHandler(ISalesUnitOfWork unitOfWork)
{
this._unitOfWork = unitOfWork;
}
internal CreateSalesOrderConductor(ISalesUnitOfWork salesUnitOfWork) : base(salesUnitOfWork)
{
}
public ProductHandler(ISalesUnitOfWork unitOfWork)
{
this._unitOfWork = unitOfWork;
}
public void AddNewSaleWithNewProduct_AddsProduct()
{
using (ISalesUnitOfWork unitOfWork = DependencyContainer.Container.Resolve <ISalesUnitOfWork>())
{
SourceFile sourceFile = new SourceFile()
{
FileName = "shit",
FileDate = DateTime.UtcNow
};
Customer customer1 = new Customer()
{
CustomerName = "Customer"
};
Product product1 = new Product()
{
ProductName = "Product"
};
Sale sale1 = new Sale()
{
SourceFile = sourceFile,
Customer = customer1,
Product = product1,
SaleDate = DateTime.UtcNow,
TotalSum = 10
};
Customer customer2 = new Customer()
{
CustomerName = "Customer 2"
};
Product product2 = new Product()
{
ProductName = "Product 2"
};
Sale sale2 = new Sale()
{
SourceFile = sourceFile,
Customer = customer1,
Product = product2,
SaleDate = DateTime.UtcNow,
TotalSum = 122
};
var added = unitOfWork.Sales.AddRange(new Sale[] { sale1, sale2 });
int oldSalesCount = unitOfWork.Sales.Get().Count();
int oldCustomersCount = unitOfWork.Customers.Get().Count();
int oldProductCount = unitOfWork.Products.Get().Count();
int res = unitOfWork.SaveChanges();
int salesCount = unitOfWork.Sales.Get().Count();
int customersCount = unitOfWork.Customers.Get().Count();
int productCount = unitOfWork.Products.Get().Count();
Assert.AreEqual(2 + oldSalesCount, salesCount);
Assert.AreEqual(1 + oldCustomersCount, customersCount);
Assert.AreEqual(2 + oldProductCount, productCount);
}
}
public OrderService(ISalesUnitOfWork uow)
{
_uow = uow;
_mapper = new Mapper(AutoMapperBLConfig.Configure());
}
internal static IResult <Expression <Func <SalesOrder, bool> > > BuildPredicate(ISalesUnitOfWork salesUnitOfWork, PredicateBuilderFilters filters)
{
if (salesUnitOfWork == null)
{
throw new ArgumentNullException("salesUnitOfWork");
}
var predicate = PredicateBuilder.True <SalesOrder>();
if (filters != null)
{
if (filters.SalesOrderStatus != null)
{
predicate = predicate.And(CustomerOrderPredicates.ByCustomerOrderStatus(filters.SalesOrderStatus.Value).ExpandAll());
}
if (filters.OrderReceivedRangeStart != null || filters.OrderReceivedRangeEnd != null)
{
predicate = predicate.And(CustomerOrderPredicates.ByDateOrderReceivedInRange(filters.OrderReceivedRangeStart, filters.OrderReceivedRangeEnd).ExpandAll());
}
if (filters.ScheduledShipDateRangeStart != null || filters.ScheduledShipDateRangeEnd != null)
{
predicate = predicate.And(CustomerOrderPredicates.ByScheduledShipDateInRange(filters.ScheduledShipDateRangeStart, filters.ScheduledShipDateRangeEnd).ExpandAll());
}
if (filters.CustomerKey != null)
{
predicate = predicate.And(CustomerOrderPredicates.ByCustomer(new CustomerKey(filters.CustomerKey)).ExpandAll());
}
if (filters.BrokerKey != null)
{
predicate = predicate.And(CustomerOrderPredicates.ByBrokeyKey(new CompanyKey(filters.BrokerKey)).ExpandAll());
}
}
return(new SuccessResult <Expression <Func <SalesOrder, bool> > >(predicate.ExpandAll()));
}
internal static IEnumerable <Expression <Func <InventoryShipmentOrder, InventoryShipmentOrderDetailBaseReturn> > > SplitSelectInventoryShipmentOrderDetailBase(IInventoryUnitOfWork inventoryUnitOfWork, DateTime currentDate, InventoryOrderEnum inventoryOrder, ISalesUnitOfWork salesUnitOfWork = null)
{
if (inventoryUnitOfWork == null)
{
throw new ArgumentNullException("inventoryUnitOfWork");
}
var pickedInventory = PickedInventoryProjectors.SplitSelectDetail(inventoryUnitOfWork, currentDate, salesUnitOfWork);
var shipmentInfo = ShipmentInformationProjectors.SelectDetail(inventoryOrder);
return(new Projectors <InventoryShipmentOrder, InventoryShipmentOrderDetailBaseReturn>
{
SelectShipmentOrderBase().Merge(o => new InventoryShipmentOrderDetailBaseReturn
{
PurchaseOrderNumber = o.PurchaseOrderNumber,
DateOrderReceived = o.DateReceived,
OrderRequestedBy = o.RequestedBy,
OrderTakenBy = o.TakenBy
}),
{ pickedInventory, s => i => new InventoryShipmentOrderDetailBaseReturn
{
PickedInventory = s.Invoke(i.PickedInventory)
} },
i => new InventoryShipmentOrderDetailBaseReturn
{
Shipment = shipmentInfo.Invoke(i.ShipmentInformation)
}
});
}
internal static IEnumerable <Expression <Func <PickedInventory, PickedInventoryReturn> > > SplitSelectDetail(IInventoryUnitOfWork inventoryUnitOfWork, DateTime currentDate, ISalesUnitOfWork salesUnitOfWork = null)
{
if (inventoryUnitOfWork == null)
{
throw new ArgumentNullException("inventoryUnitOfWork");
}
var attributeNames = AttributeNameProjectors.SelectActiveAttributeNames(inventoryUnitOfWork);
var itemSelector = PickedInventoryItemProjectors.SplitSelect(inventoryUnitOfWork, currentDate, salesUnitOfWork);
return(new Projectors <PickedInventory, PickedInventoryReturn>
{
SelectBase().Merge(i => new PickedInventoryReturn
{
AttributeNamesAndTypes = attributeNames.Invoke()
}),
{ itemSelector, s => i => new PickedInventoryReturn
{
PickedInventoryItems = i.Items.Select(m => s.Invoke(m))
} }
});
}
public CustomerRepository(ISalesUnitOfWork unitOfWork)
: base(unitOfWork)
{
}
