public OrderMediator(IOrderRepository orderRepository,
                      Action<OrderMatch, FixSessionID> orderMatchCallback)
 {
     _orderRepository = orderRepository;
     _orderMatchCallback = orderMatchCallback;
     _orderRepository.OrdersMatched += OnOrdersMatched;
 }

		public ImportService(IImportRepository importRepository, IAssetService blobProvider, ICatalogRepository catalogRepository, IOrderRepository orderRepository, IAppConfigRepository appConfigRepository, IRepositoryFactory<IAppConfigRepository> appConfigRepositoryFactory)
		{
			_orderRepository = orderRepository;
			_catalogRepository = catalogRepository;
			_importJobRepository = importRepository;
			_appConfigRepository = appConfigRepository;
			_appConfigRepositoryFactory = appConfigRepositoryFactory;
			_assetProvider = blobProvider;

			_entityImporters = new List<IEntityImporter>
				{
					new ItemImporter() { Name = "Product"},
					new ItemImporter() { Name = "Sku"},
					new ItemImporter() { Name = "Bundle"},
					new ItemImporter() { Name = "DynamicKit"},
					new ItemImporter() { Name = "Package"},
					new PriceImporter(_catalogRepository),
					new AssociationImporter(_catalogRepository),
					new RelationImporter(_catalogRepository),
					new CategoryImporter(),
					new LocalizationImporter(),
					new TaxValueImporter(),
					new ItemAssetImporter(),
					new TaxCategoryImporter(),
					new JurisdictionImporter(),
					new JurisdictionGroupImporter(),
					new SeoImporter()
				};

			_importResults = new Dictionary<string, ImportResult>();
		}

 public OrderApiService(
     ICommandHandler<MakeOrderCommand> commmHandler,
     IOrderRepository repository)
 {
     _commmHandler = commmHandler;
     _repository = repository;
 }

 public CustomerController(ICustomerRepository customerRepository, INotificationProvider notificationProvider, IOrderRepository ordersRepository, ILogger logger)
 {
     _customerRepository = customerRepository;
     _notificationProvider = notificationProvider;
     _ordersRepository = ordersRepository;
     _logger = logger;
 }

        public CheckoutSummaryPageViewModel(INavigationService navigationService,
            IOrderService orderService,
            IOrderRepository orderRepository,
            IShippingMethodService shippingMethodService,
            ICheckoutDataRepository checkoutDataRepository,
            IShoppingCartRepository shoppingCartRepository,
            IAccountService accountService,
            IResourceLoader resourceLoader,
            IAlertMessageService alertMessageService,
            ISignInUserControlViewModel signInUserControlViewModel)
        {
            _navigationService = navigationService;
            _orderService = orderService;
            _orderRepository = orderRepository;
            _shippingMethodService = shippingMethodService;
            _checkoutDataRepository = checkoutDataRepository;
            _shoppingCartRepository = shoppingCartRepository;
            _resourceLoader = resourceLoader;
            _accountService = accountService;
            _alertMessageService = alertMessageService;
            _signInUserControlViewModel = signInUserControlViewModel;

            SubmitCommand = DelegateCommand.FromAsyncHandler(SubmitAsync, CanSubmit);

            EditCheckoutDataCommand = new DelegateCommand(EditCheckoutData);
            SelectCheckoutDataCommand = new DelegateCommand(async () => await SelectCheckoutDataAsync());
            AddCheckoutDataCommand = new DelegateCommand(AddCheckoutData);
        }

		public OrderClient(IOrderStateController stateController, IOrderRepository orderRepository,
		                   ICacheRepository cacheRepository)
		{
			_stateController = stateController;
			_orderRepository = orderRepository;
			_cacheRepository = cacheRepository;
		}

 public AlertService(IOrderRepository orderRepository, IInstrumentRepository instrumentRepository, IAlertRepository alertRepository, IAlertManager alertManager )
 {
     _orderRepository = orderRepository;
     _instrumentRepository = instrumentRepository;
     _alertRepository = alertRepository;
     _alertManager = alertManager;
 }

 public CartService(
     IProductService productService,
     IPricingService pricingService,
     IOrderFactory orderFactory,
     CustomerContextFacade customerContext,
     IPlacedPriceProcessor placedPriceProcessor,
     IInventoryProcessor inventoryProcessor,
     ILineItemValidator lineItemValidator,
     IOrderRepository orderRepository,
     IPromotionEngine promotionEngine,
     IAddressBookService addressBookService,
     ICurrentMarket currentMarket,
     ICurrencyService currencyService)
 {
     _productService = productService;
     _pricingService = pricingService;
     _orderFactory = orderFactory;
     _customerContext = customerContext;
     _placedPriceProcessor = placedPriceProcessor;
     _inventoryProcessor = inventoryProcessor;
     _lineItemValidator = lineItemValidator;
     _promotionEngine = promotionEngine;
     _orderRepository = orderRepository;
     _addressBookService = addressBookService;
     _currentMarket = currentMarket;
     _currencyService = currencyService;
 }

        public ShoppingCartPageViewModel(IShoppingCartRepository shoppingCartRepository,
            INavigationService navigationService,
            IAccountService accountService,
            ISignInUserControlViewModel signInUserControlViewModel,
            IResourceLoader resourceLoader,
            IAlertMessageService alertMessageService,
            ICheckoutDataRepository checkoutDataRepository,
            IOrderRepository orderRepository,
            IEventAggregator eventAggregator)
        {
            _shoppingCartRepository = shoppingCartRepository;
            _navigationService = navigationService;
            _accountService = accountService;
            _signInUserControlViewModel = signInUserControlViewModel;
            _resourceLoader = resourceLoader;
            _alertMessageService = alertMessageService;
            _checkoutDataRepository = checkoutDataRepository;
            _orderRepository = orderRepository;

            CheckoutCommand = DelegateCommand.FromAsyncHandler(CheckoutAsync, CanCheckout);
            RemoveCommand = DelegateCommand<ShoppingCartItemViewModel>.FromAsyncHandler(Remove);
            IncrementCountCommand = DelegateCommand.FromAsyncHandler(IncrementCount);
            DecrementCountCommand = DelegateCommand.FromAsyncHandler(DecrementCount, CanDecrementCount);

            // Subscribe to the ShoppingCartUpdated event
            if (eventAggregator != null)
            {
                eventAggregator.GetEvent<ShoppingCartUpdatedEvent>().Subscribe(UpdateShoppingCartAsync);
            }
        }

 public OrderRepositoryCacheProxy(
     IOrderRepository innerRepository,
     ICache cache)
 {
     _innerRepository = innerRepository;
     _cache = cache;
 }

 public EmailOrderSubmitter(string mailTo, IOrderRepository orderRepository, IOrderItemRepository orderItemRepository, IDeliveryRepository deliveryRepository)
 {
     this.mailTo = mailTo;
     this.orderRepository = orderRepository;
     this.orderItemRepository = orderItemRepository;
     this.deliveryRepository = deliveryRepository;
 }

 public HomeController(IWaiterRepository waiterRepository, IRestaurantRepository restaurantRepository, IOrderRepository orderRepository, IOrderCreatingRepository orderCreatingRepository)
 {
     this.waiterRepository = waiterRepository;
     this.restaurantRepository = restaurantRepository;
     this.orderRepository = orderRepository;
     this.orderCreatingRepository = orderCreatingRepository;
 }

 public OrderControllerService(IOrderRepository orderRepository, ICatalogService catalogService, IOrderRequestService requestService, IShipmentService shipmentService )
 {
     _orderRepository = orderRepository;
     _catalogService = catalogService;
     _requestService = requestService;
     _shipmentService = shipmentService;
 }

 public OrderController(ICustomerRepository customerRepository,
     IOrderRepository orderRepository)
     : base(customerRepository)
 {
     _orderRepository = orderRepository;
     _customerRepository = customerRepository;
 }

 public OrderService(IOrderRepository orderRepository, ICustomerFactory customerFactory, IEmailService emailService, IOrderSettings orderSettings)
 {
     _orderRepository = orderRepository;
     _customerFactory = customerFactory;
     _emailService = emailService;
     _orderSettings = orderSettings;
 }

		public FeeDisbursementManager(IReferenceManagement referenceManager, IOrderRepository orderRepository, ICryptographicProvider cryptographicProvider)
		{
			_cryptographicProvider = ValidationUtil.CheckOnNullAndThrowIfNull(cryptographicProvider);
			_referenceManager = ValidationUtil.CheckOnNullAndThrowIfNull(referenceManager);
			_orderRepository = ValidationUtil.CheckOnNullAndThrowIfNull(orderRepository);
			_dateTimeManager = new DateTimeManager(_referenceManager);
		}

 public OrderApplicationService(IOrderRepository orderRepository, IUserRepository userRepository, IProductRepository productRepository, IUnitOfWork unitOfWork)
     : base(unitOfWork)
 {
     this._orderRepository = orderRepository;
     this._userRepository = userRepository;
     this._productRepository = productRepository;
 }

 public OrderService(IOrderRepository orderRepository, IBasketRepository basketRepository, ICustomerRepository customerRepository, IUnitOfWork uow)
 {
     _customerRepository = customerRepository;
     _orderRepository = orderRepository;
     _basketRepository = basketRepository;
     _uow = uow;
 }

        //    private readonly IApprovableDomainService _approvableDomainService;
        //    private readonly IGoodPartyAssignmentDomainService _goodPartyAssignmentDomainService;
        public OrderApplicationService(IOrderRepository orderRepository,
                                       IUnitOfWorkScope unitOfWorkScope,
            //  IGoodPartyAssignmentDomainService goodPartyAssignmentDomainService,
                                       //IFuelUserRepository userRepository,
                                       IVesselInCompanyDomainService vesselDomainService,
                                       IGoodDomainService goodDomainService,
                                       IOrderFactory iOrderFactory,
                                       ICompanyDomainService companyDomainService,
                                       IOrderItemDomainService orderItemDomainService,
                                       IEntityConfigurator<Order> orderConfigurator
            //,IApprovableDomainService approvableDomainService
            )
        {
            this.orderRepository = orderRepository;
            this.vesselDomainService = vesselDomainService;
            this.goodDomainService = goodDomainService;
            this.iOrderFactory = iOrderFactory;
            this.unitOfWorkScope = unitOfWorkScope;
            this.companyDomainService = companyDomainService;

            this.orderItemDomainService = orderItemDomainService;
            this.orderConfigurator = orderConfigurator;
            // _approvableDomainService = approvableDomainService;
            //  _goodPartyAssignmentDomainService = goodPartyAssignmentDomainService;
        }

 public MyAccountViewModelBuilder(string userEmail, ICustomerAccountService customerAccountService, IOrderRepository orderRepository, IMappingEngine mapper)
 {
     this.userEmail = userEmail;
     this.customerAccountService = customerAccountService;
     this.orderRepository = orderRepository;
     this.mapper = mapper;
 }