public UnitOfWork(IOrderRepository orderRepository, IOrderHistoryRepository orderHistoryRepository, IOrderDetailsRepository orderDetailsRepository)
{
this.orderRepository = orderRepository;
this.orderDetailsRepository = orderDetailsRepository;
this.orderHistoryRepository = orderHistoryRepository;
SetupContext();
}
public OrderProcessor(
ISalesOrderRepository orderRepository,
IOrderHistoryRepository orderHistoryRepository)
{
this.orderRepository = orderRepository;
this.orderHistoryRepository = orderHistoryRepository;
}
public LocationController(ILocationRepository locationRepo, IOrderHistoryRepository orderHistoryRepo, IInventoryRepository inventoryRepo, IOrdersRepository ordersRepo)
{
_locationRepo = locationRepo ?? throw new ArgumentNullException(nameof(locationRepo));
_orderhistoryRepo = orderHistoryRepo ?? throw new ArgumentNullException(nameof(orderHistoryRepo));
_inventoryRepo = inventoryRepo ?? throw new ArgumentNullException(nameof(inventoryRepo));
_ordersRepo = ordersRepo ?? throw new ArgumentNullException(nameof(ordersRepo));
}
public void SetupTest()
{
selenium = new DefaultSelenium("localhost", 4444, "*chrome", "http://*****:*****@"Data Source=.\SQLEXPRESS;AttachDbFilename=C:\Documents and Settings\RolandoV\My Documents\PWAS\PWAS_Site\PWAS_Site\App_Data\PWAS_DB.mdf;Integrated Security=True;User Instance=True");
orderRepo = new OrderRepository(@"Data Source=.\SQLEXPRESS;AttachDbFilename=C:\Documents and Settings\RolandoV\My Documents\PWAS\PWAS_Site\PWAS_Site\App_Data\PWAS_DB.mdf;Integrated Security=True;User Instance=True");
orderHistoryRepo = new OrderHistoryRepository(@"Data Source=.\SQLEXPRESS;AttachDbFilename=C:\Documents and Settings\RolandoV\My Documents\PWAS\PWAS_Site\PWAS_Site\App_Data\PWAS_DB.mdf;Integrated Security=True;User Instance=True");
if (orderRepo.Orders.Where(o => o.job_name == "Salsa Impulse").Count() > 0)
{
List <Order> orders = orderRepo.Orders.Where(o => o.job_name == "Salsa Impulse").ToList();
List <OrderHistory> ohistories = (from oh in orderHistoryRepo.OrderHistories
where (from o in orders
select o.orderID).Contains(oh.orderId)
select oh).ToList();
Table <OrderHistory> ohTable = (Table <OrderHistory>)orderHistoryRepo.OrderHistories;
ohTable.DeleteAllOnSubmit(ohistories);
Table <Order> orderTable = (Table <Order>)orderRepo.Orders;
orderTable.DeleteAllOnSubmit(orders);
ohTable.Context.SubmitChanges();
orderTable.Context.SubmitChanges();
}
if (userRepo.Users.Where(u => u.email == "*****@*****.**").Count() > 0)
{
User user = userRepo.Users.First(u => u.email.Trim() == "*****@*****.**");
userRepo.DeleteUser(user.userID);
userRepo.SubmitChanges();
}
verificationErrors = new StringBuilder();
}
public OrderService(
IOrderHistoryRepository orderHistoryRepository,
IOrderQueue orderQueue)
{
this.orderHistoryRepository = orderHistoryRepository;
this.orderQueue = orderQueue;
}
public OrderHistoryManager(IOrderHistoryRepository orderHistoryRepository, ISecurityContext securityContext,
IReferenceManagement referenceManagement, IOrderRepository orderRepository)
{
_orderHistoryRepository = ValidationUtil.CheckOnNullAndThrowIfNull(orderHistoryRepository);
_securityContext = ValidationUtil.CheckOnNullAndThrowIfNull(securityContext);
_referenceManagement = ValidationUtil.CheckOnNullAndThrowIfNull(referenceManagement);
_orderRepository = ValidationUtil.CheckOnNullAndThrowIfNull(orderRepository);
}
public AuroraShipmentJob(ILog log,
IAuroraShipmentRepository auroraShipmentRepository,
IShipmentRepository shipmentRepository,
IOrderHistoryRepository orderHistoryRepository)
{
_auroraShipmentRepository = auroraShipmentRepository;
_shipmentRepository = shipmentRepository;
_orderHistoryRepository = orderHistoryRepository;
_log = log;
}
public PickJob(ILog logger,
IOrderReader sourceRepository,
IOrderWriter destinationRepository,
IOmsManhattanOrderMapRepository omsManhattanOrderMapRepository,
IOrderHistoryRepository orderHistoryRepository)
{
_logger = logger;
_orderHistoryRepository = orderHistoryRepository;
DestinationRepository = destinationRepository;
_omsManhattanOrderMapRepository = omsManhattanOrderMapRepository;
SourceRepository = sourceRepository;
}
public OrderHistoriesController(BdContext context,
IOrderHistoryRepository orderHistoryRepository,
IUnitOfWork <OrderHistory> unitOfWork,
IHttpContextAccessor httpContextAccessor,
IMapper mapper) : base(httpContextAccessor)
{
_orderHistoryRepository = orderHistoryRepository;
_unitOfWorkOrderhistory = unitOfWork;
_mapper = mapper;
_httpContextAccessor = httpContextAccessor;
_context = context;
_cancellationToken = new CancellationToken();
}
public static string getCurrentOrderStatusDate(int orderID)
{
IOrderRepository orderRepository = RepositoryFactory.Get <IOrderRepository>();
IOrderHistoryRepository historyRepository = RepositoryFactory.Get <IOrderHistoryRepository>();
Order currentOrder = orderRepository.GetById(orderID);
//OrderHistory currentHistory = historyRepository.OrderHistories.Single(x => x.orderId == orderID
// && x.statusId == currentOrder.Status.statusId);
OrderHistory currentHistory = (from history in historyRepository.OrderHistories
where history.orderId == orderID && history.statusId == currentOrder.currentStatus
orderby history.modifiedDate descending
select history).First();
return(currentHistory.modifiedDate.ToString());
}
public OrdersController(
IOrderHistoryRepository orderHistoryRepository,
IShoppingCartRepository shoppingCartItemRepository,
IPersonRepository personRepository,
IProductRepository productRepository,
IOrderService orderService,
IInventoryService inventoryService)
{
this.orderHistoryRepository = orderHistoryRepository;
this.shoppingCartItemRepository = shoppingCartItemRepository;
this.personRepository = personRepository;
this.productRepository = productRepository;
this.orderService = orderService;
this.inventoryService = inventoryService;
}
public PixReturnJob(ILog log,
IPixReturnRepository pixReturnRepository,
IDatabaseRowReturnRepository databaseRowReturnRepository,
IPerpetualInventoryTransferRepository perpetualInventoryTransferRepository,
IManhattanConditionCodeRepository manhattanConditionCodeRepository,
IOmsManhattanOrderMapRepository omsManhattanOrderMapRepository,
IOrderHistoryRepository orderHistoryRepository)
{
_log = log;
_pixReturnRepository = pixReturnRepository;
_databaseRowReturnRepository = databaseRowReturnRepository;
_perpetualInventoryTransferRepository = perpetualInventoryTransferRepository;
_manhattanConditionCodeRepository = manhattanConditionCodeRepository;
_omsManhattanOrderMapRepository = omsManhattanOrderMapRepository;
_orderHistoryRepository = orderHistoryRepository;
}
public PickTicketJob(ILog logger,
IOrderWriter destinationRepository,
IConfigurationManager configurationManager,
IFileIo fileIo,
IJobRepository jobRepository,
ITransferControlRepository transferControlRepository,
IManhattanOrderRepository manhattanOrderRepository,
IAuroraPickTicketRepository auroraPickTicketRepository,
IOrderHistoryRepository orderHistoryRepository,
ITransferControlConfigurationManager transferControlConfigurationManager)
: base(logger, configurationManager, fileIo, jobRepository, transferControlRepository, transferControlConfigurationManager)
{
_destinationRepository = destinationRepository;
_manhattanOrderRepository = manhattanOrderRepository;
_auroraPickTicketRepository = auroraPickTicketRepository;
_orderHistoryRepository = orderHistoryRepository;
}
public PickTicketConfirmationJob(ILog logger,
IOrderReader sourceRepository,
IOrderWriter destinationRepository,
IPickTicketProcessingRepository pickTicketProcessingRepository,
IAuroraPickTicketRepository auroraPickTicketRepository,
IOmsManhattanOrderMapRepository omsManhattanOrderMapRepository,
IOrderHistoryRepository orderHistoryRepository,
ICarrierReadRepository carrierReadRepository)
{
_logger = logger;
SourceRepository = sourceRepository;
DestinationRepository = destinationRepository;
_pickTicketProcessingRepository = pickTicketProcessingRepository;
_auroraPickTicketRepository = auroraPickTicketRepository;
_omsManhattanOrderMapRepository = omsManhattanOrderMapRepository;
_orderHistoryRepository = orderHistoryRepository;
_carrierReadRepository = carrierReadRepository;
}
public OrderHistoryService(IOrderHistoryRepository orderHistoryRepository,
ILogger <OrderService> logger)
{
_orderHistoryRepository = orderHistoryRepository;
_logger = logger;
}
public CustomerController(ICustomerRepository customerRepository, IOrderHistoryRepository orderHistoryRepo)
{
_customerRepo = customerRepository ?? throw new ArgumentNullException(nameof(customerRepository));
_orderhistoryRepo = orderHistoryRepo ?? throw new ArgumentNullException(nameof(orderHistoryRepo));
}
public OrderHistoryController(IStorefrontContext storefrontContext, IVisitorContext visitorContext, IOrderHistoryRepository orderHistoryRepository)
: base(storefrontContext)
{
Assert.IsNotNull((object)storefrontContext, nameof(storefrontContext));
Assert.IsNotNull((object)visitorContext, nameof(visitorContext));
Assert.IsNotNull((object)orderHistoryRepository, nameof(orderHistoryRepository));
this.OrderHistoryRepository = orderHistoryRepository;
this.VisitorContext = visitorContext;
}
public OrderHistoryServices(IOrderHistoryRepository repository, IMapper mapper)
{
_repository = repository;
_mapper = mapper;
}
public OrderHistoryService(IOrderHistoryRepository repository)
{
_repository = repository;
}
public OrderHistoryReadModel(IOrderHistoryRepository repo)
{
_repo = repo;
}
public OrderHistoryService(IOrderHistoryRepository orderHistoryRepository, IEmailSender emailSender)
{
_orderHistoryRepository = orderHistoryRepository;
_emailSender = emailSender;
}
public PGatwayController(IOrderHistoryRepository orderHistoryRepository)
{
_orderHistoryRepository = orderHistoryRepository;
}
public OrderHistoryController(IOrderHistoryRepository orderhistoryRepo, IOrdersRepository ordersRepo)
{
_orderhistoryRepo = orderhistoryRepo ?? throw new ArgumentNullException(nameof(orderhistoryRepo));
_ordersRepo = ordersRepo ?? throw new ArgumentNullException(nameof(ordersRepo));
}
