public OrderRepositoryCacheProxy(
IOrderRepository innerRepository,
ICache cache)
{
_innerRepository = innerRepository;
_cache = cache;
}
public ClientPresenter(IClientView view, ClientModel model)
{
_view = view;
_model = model;
_clientRepository = _model.ClientRepository;
_orderRepository = _model.OrderRepository;
}
public AciManager(IAciXmlFieldsRepository aciXmlFieldsRepository, IAciXmlRepository aciXmlRepository, IOrderRepository orderRepository, ICommitProvider commitProvider)
{
_aciXmlFieldsRepository = aciXmlFieldsRepository;
_aciXmlRepository = aciXmlRepository;
_orderRepository = orderRepository;
_commitProvider = commitProvider;
}
public OrderPlacedsController(IWaiterRepository waiterRepository, IRestaurantRepository restaurantRepository, IOrderPlacedRepository orderplacedRepository, IOrderRepository orderRepository)
{
this.waiterRepository = waiterRepository;
this.restaurantRepository = restaurantRepository;
this.orderplacedRepository = orderplacedRepository;
this.orderRepository = orderRepository;
}
public OrderMediator(IOrderRepository orderRepository,
Action<OrderMatch, FixSessionID> orderMatchCallback)
{
_orderRepository = orderRepository;
_orderMatchCallback = orderMatchCallback;
_orderRepository.OrdersMatched += OnOrdersMatched;
}
public WarehouseController()
{
events = new EventRepository(db);
assets = new AssetRepository(db);
customers = new CustomerRepository(db);
orders = new OrderRepository(db);
}
public OrderOperations()
{
_orderRepository = OrderRepositoryFactory.CreateOrderRepository();
_productsRepository = ProductsRepositoryFactory.CreateProductsRepository();
_statesRepository = StatesRepositoryFactory.CreateStatesRepository();
_response = new Response();
}
public ClientDashboardManager(IOrderRepository orderRepo, IAppraisalFormsService formService, IOrderManager orderManager, IClientUserOrdersRepository clientUserOrdersRepository)
{
_orderRepo = ValidationUtil.CheckOnNullAndThrowIfNull(orderRepo);
_formsService = ValidationUtil.CheckOnNullAndThrowIfNull(formService);
_orderManager = ValidationUtil.CheckOnNullAndThrowIfNull(orderManager);
_clientUserOrdersRepository = ValidationUtil.CheckOnNullAndThrowIfNull(clientUserOrdersRepository);
}
private AccountCheckStream()
{
walletRepository = new WalletRepository();
accountRepository = AccountRepository.Instance;
orderRepository = OrderRepository.Instance;
profitCalculator = ProfitCalculator.Instance;
tradeManager = ManagerTrade.Instance.tradeManager;
brokerRepository = new BrokerRepository();
threadIntervalMils = AppConfig.GetIntParam("CheckLoop.Interval", 100);
schedules = new[]
{
new Schedule(CheckOrders, AppConfig.GetIntParam("CheckLoop.IntervalOrders", 300)),
new Schedule(CheckMargin, AppConfig.GetIntParam("CheckLoop.IntervalMargin", 15000)),
new Schedule(CheckSwap, AppConfig.GetIntParam("CheckLoop.IntervalSwap", 1000)),
new Schedule(RenewSubscriptions, AppConfig.GetIntParam("CheckLoop.UpdateSubscriptions", 1000))
};
// параметры начисления свопов
var dicMetadata = brokerRepository.GetMetadataByCategory("SWAP");
object swapHourGmtObj, minutesToCheckSwapObj;
if (!dicMetadata.TryGetValue("Hour.GMT", out swapHourGmtObj))
swapHourGmtObj = 21;
swapCheckHourGmt = (int) swapHourGmtObj;
if (!dicMetadata.TryGetValue("MinutesToCheck", out minutesToCheckSwapObj))
minutesToCheckSwapObj = 0;
minutesToCheckSwap = (int)minutesToCheckSwapObj;
}
public OrderApplicationService(IOrderRepository orderRepository, IUserRepository userRepository, IProductRepository productRepository, IUnitOfWork unitOfWork)
: base(unitOfWork)
{
this._orderRepository = orderRepository;
this._userRepository = userRepository;
this._productRepository = productRepository;
}
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>();
}
// 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 void Startup()
{
_orderRepository = new TestOrderRepository();
_catalogRepository = new TestCatalogRepository();
_addressValidation = new TestAddressValidator();
_shippingRepository = new TestShippingRepository();
_shippingService = new SimpleShippingService(_shippingRepository);
_taxRepository = new TestTaxRepository();
_taxService = new RegionalSalesTaxService(_taxRepository);
_orderService = new OrderService(_orderRepository,_catalogRepository,_shippingRepository,_shippingService);
_personalizationRepository = new TestPersonalizationRepository();
_personalizationService = new PersonalizationService(_personalizationRepository,_orderRepository, _orderService,_catalogRepository);
_catalogService = new CatalogService(_catalogRepository,_orderService);
_paymentService = new FakePaymentService();
_incentiveRepository = new TestIncentiveRepository();
_incentiveService = new IncentiveService(_incentiveRepository);
//this service throws the sent mailers into a collection
//and does not use SMTP
_mailerService = new TestMailerService();
_inventoryRepository = new TestInventoryRepository();
_inventoryService = new InventoryService(_inventoryRepository,_catalogService);
_mailerRepository = new TestMailerRepository();
_pipeline=new DefaultPipeline(
_addressValidation,_paymentService,
_orderService,_mailerService,
_inventoryService
);
}
public OrderControllerService(IOrderRepository orderRepository, ICatalogService catalogService, IOrderRequestService requestService, IShipmentService shipmentService )
{
_orderRepository = orderRepository;
_catalogService = catalogService;
_requestService = requestService;
_shipmentService = shipmentService;
}
public CustomerController(ICustomerRepository customerRepository, INotificationProvider notificationProvider, IOrderRepository ordersRepository, ILogger logger)
{
_customerRepository = customerRepository;
_notificationProvider = notificationProvider;
_ordersRepository = ordersRepository;
_logger = logger;
}
public OrderService(IOrderRepository orderRepository, ICustomerFactory customerFactory, IEmailService emailService, IOrderSettings orderSettings)
{
_orderRepository = orderRepository;
_customerFactory = customerFactory;
_emailService = emailService;
_orderSettings = orderSettings;
}
public OrderApiService(
ICommandHandler<MakeOrderCommand> commmHandler,
IOrderRepository repository)
{
_commmHandler = commmHandler;
_repository = repository;
}
public MyAccountViewModelBuilder(string userEmail, ICustomerAccountService customerAccountService, IOrderRepository orderRepository, IMappingEngine mapper)
{
this.userEmail = userEmail;
this.customerAccountService = customerAccountService;
this.orderRepository = orderRepository;
this.mapper = mapper;
}
public EmailOrderSubmitter(string mailTo, IOrderRepository orderRepository, IOrderItemRepository orderItemRepository, IDeliveryRepository deliveryRepository)
{
this.mailTo = mailTo;
this.orderRepository = orderRepository;
this.orderItemRepository = orderItemRepository;
this.deliveryRepository = deliveryRepository;
}
public void InitTest()
{
base.InitDbContext();
_backgroundService = Substitute.For<IBackgroundService>();
_appraiserOrderRepository = new AppraiserOrderRepository(this.DbFactory);
_orderRepository = new OrderRepository(this.DbFactory);
_commitProvider = new CommitProvider(this.DbFactory);
_userRepository = new UserRepository(this.DbFactory);
_taskManager = new TaskManager(_backgroundService, _userRepository);
_referenceManagement = new ReferenceManagement(new ReferenceRepository(this.DbFactory), new WebCacheService());
_dateTimeManager = new DateTimeManager(_referenceManagement);
_appraiserManagement = Substitute.For<IAppraiserManagement>();
_configHelper = Substitute.For<IConfigurationHelper>();
_orderManager = new OrderManager(
_orderRepository,
Substitute.For<IClientUserRepository>(),
_referenceManagement,
_appraiserManagement,
_configHelper,
Substitute.For<IAppraiserOrderRepository>(),
Substitute.For<IChangeTrackingRepository>(),
Substitute.For<IOrderHistoryManager>(),
Substitute.For<IOrderDocumentsRepository>());
_appraiserOrderDeliveryService = new AppraiserOrderDeliveryService(_taskManager, _appraiserOrderRepository, _commitProvider, _orderManager,
new DateTimeManager(_referenceManagement), Substitute.For<IOrderHistoryManager>(), Substitute.For<IAppraiserOrderSetPointsRepository>(),
Substitute.For<IAppraiserOrderListItemRepository>(),
Substitute.For<IOrderPeriodicalNotificationManager>());
}
public ProductController(IProductDataService productDataService,
IBrandDataService brandDataService,
IOrderRepository orderRepo,
IOrderItemRepository orderItemRepo,
IOrderLogRepository orderLogRepo,
IProductRepository productRepo,
IFavoriteRepository favoriteRepo,
IPromotionRepository promotionRepo,
IOrder2ExRepository orderexRepo,
IRMA2ExRepository rmaexRepo,
IInventoryRepository inventoryRepo)
{
_productDataService = productDataService;
_passHelper = new PassHelper(brandDataService);
_orderRepo = orderRepo;
_orderItemRepo = orderItemRepo;
_orderLogRepo = orderLogRepo;
_productRepo = productRepo;
_favoriteRepo = favoriteRepo;
_promotionRepo = promotionRepo;
_orderexRepo = orderexRepo;
_rmaexRepo = rmaexRepo;
_inventoryRepo = inventoryRepo;
}
public HomeController(IWaiterRepository waiterRepository, IRestaurantRepository restaurantRepository, IOrderRepository orderRepository, IOrderCreatingRepository orderCreatingRepository)
{
this.waiterRepository = waiterRepository;
this.restaurantRepository = restaurantRepository;
this.orderRepository = orderRepository;
this.orderCreatingRepository = orderCreatingRepository;
}
public OrderService(IOrderRepository orderRepository, IBasketRepository basketRepository, ICustomerRepository customerRepository, IUnitOfWork uow)
{
_customerRepository = customerRepository;
_orderRepository = orderRepository;
_basketRepository = basketRepository;
_uow = uow;
}
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 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 OrderController(ICustomerRepository customerRepository,
IOrderRepository orderRepository)
: base(customerRepository)
{
_orderRepository = orderRepository;
_customerRepository = customerRepository;
}
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 WaiterMapService(IOrderRepository orderRepository, IOrderItemRepository orderItemRepository)
{
this.orderRepository = orderRepository;
this.orderItemRepository = orderItemRepository;
}
public OrderService(IOrderRepository orderRepository, ILocationRepository locationRepository)
{
_orderRepository = orderRepository;
_locationRepository = locationRepository;
}
public NoDbContextFactoryController(IOrderRepository orderRepository)
{
_orderRepository = orderRepository;
}
public BusinessmanService(IBusinessmanRepository businessmanRepository, IPaymentClientProxy payMentClientProxy, IRoleRepository roleRepository, ISmsTemplateRepository smsTemplateRepository, ISMSChargeSetRepository smsChargeRepository, IOrderRepository orderRepository, IAfterSaleOrderRepository afterSaleOrderRepository, IOPENScanRepository openScanRepository, CustomerInfoDomainService customerInfoDomainService, StationBuyGroupDomainService stationBuyGroupDomainService)
{
this.businessmanRepository = businessmanRepository;
this.roleRepository = roleRepository;
this.payMentClientProxy = payMentClientProxy;
this.smsTemplateRepository = smsTemplateRepository;
this.smsChargeRepository = smsChargeRepository;
this.orderRepository = orderRepository;
this.afterSaleOrderRepository = afterSaleOrderRepository;
this.openScanRepository = openScanRepository;
this._customerInfoDomainService = customerInfoDomainService;
this._stationBuyGroupDomainService = stationBuyGroupDomainService;
}
public OrderService(IOrderRepository orderRepository)
{
_orderRepository = orderRepository;
}
public OrderController(IOrderRepository repoService, Cart cartService)
{
repository = repoService;
cart = cartService;
}
public GenericPaymentController(IContentRepository contentRepository, IOrderRepository orderRepository)
{
_contentRepository = contentRepository;
_orderRepository = orderRepository;
_siteConfiguration = SiteConfiguration.Current();
}
public EventBusRabbitMQConsumer(IRabbitMQConnection connection, IMediator mediator, IMapper mapper, IOrderRepository repository)
{
_connection = connection;
_mediator = mediator;
_mapper = mapper;
_repository = repository;
}
/// <summary>
/// Initializes a new instance of the <see cref="OrderCreatedConsumer" /> class.
/// </summary>
/// <param name="cartService">The cart service.</param>
/// <param name="orderService">The order service.</param>
/// <param name="eventStoreRepository">The event store repository.</param>
public OrderCreatedConsumer(IService <Cart> cartService, IService <Order> orderService, IOrderRepository eventStoreRepository)
{
this.orderService = orderService;
this.cartService = cartService;
this.eventStoreRepository = eventStoreRepository;
}
public UpdateOrderWhenBuyerAndPaymentMethodVerifiedDomainEventHandler(
IOrderRepository orderRepository, ILoggerFactory logger)
{
_orderRepository = orderRepository ?? throw new ArgumentNullException(nameof(orderRepository));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public GetOrdersListQueryHandler(IOrderRepository orderRepository, IMapper mapper)
{
_orderRepository = orderRepository;
this.mapper = mapper;
}
public CustomerRepository(IOrderRepository repo)
{
this._repo = repo;
}
public OrderController(IOrderRepository orderRepository)
{
_orderRepository = orderRepository;
}
public OrderService(IOrderRepository repo) => repository = repo;
public HomeController(IOrderRepository _ORepo, IMenuItemRepository _MIRepo)
{
ORepo = _ORepo;
MIRepo = _MIRepo;
}
public OrderUpdatedEventHandler(IAutomapHelper automapHelper, IOrderRepository repository)
{
AutomapHelper = automapHelper;
OrderRepository = repository;
}
public CancelOrderCommandHandler(IOrderRepository orderRepository)
{
_orderRepository = orderRepository;
}
public OrderService(IOrderContext context)
{
_orderRepository = new OrderRepository(context);
}
public OrdersController(IOrderRepository orderRepository, IProductRepository productRepository, DataContext context)
{
this.orderRepository = orderRepository;
this.productRepository = productRepository;
this.context = context;
}
public VippsExpressController(IOrderGroupCalculator orderGroupCalculator,
IOrderRepository orderRepository)
{
_orderGroupCalculator = orderGroupCalculator;
_orderRepository = orderRepository;
}
public OrderWithoutCommisionService(ISalesFactory salesFactory, ISalesmanRepository salesmanRepository, IOrderRepository orderRepository)
{
_salesFactory = salesFactory;
_salesmanRepository = salesmanRepository;
_orderRepository = orderRepository;
}
public GetOpenOrderConsumer(IOrderRepository repo, IMapper mapper)
{
this.repo = repo;
this.mapper = mapper;
}
public OrderService(IOrderRepository orders, IBuyerRepository buyers, ISellerRepository sellers)
{
orderRepository = orders;
buyerRepository = buyers;
sellerRepository = sellers;
}
public OrderManager(IOrderRepository orderRepository)
{
_orderRepository = orderRepository;
}
public HospitalPartnerService(IEventCustomerRepository eventCustomerRepository, ICustomerRepository customerRepository, IOrderRepository orderRepository, IEventPackageRepository eventPackageRepository,
IEventTestRepository eventTestRepository, IHospitalPartnerCustomerViewModelFactory hospitalPartnerCustomerViewModelFactory, IEventCustomerResultRepository eventCustomerResultRepository, IHospitalPartnerRepository hospitalPartnerRepository,
IHospitalPartnerCustomerRepository hospitalPartnerCustomerRepository, IOrganizationRoleUserRepository organizationRoleUserRepository, IEventRepository eventRepository, IPodRepository podRepository, IOrganizationRepository organizationRepository,
IHostRepository hostRepository, IHospitalPartnerEventListFactory hospitalPartnerEventListFactory, IUniqueItemRepository <ShippingDetail> shippingDetailRepository, IShippingOptionRepository shippingOptionRepository,
ICorporateAccountRepository corporateAccountRepository, INotesRepository notesRepository, IPrimaryCarePhysicianRepository primaryCarePhysicianRepository, IHealthAssessmentRepository healthAssessmentRepository,
IHospitalPartnerDashboardViewModelFactory hospitalPartnerViewModelFactory, ICustomerCallNotesRepository customerCallNotesRepository, IEventCustomerNotificationRepository eventCustomerNotificationRepository,
IHospitalFacilityRepository hospitalFacilityRepository, ISettings settings, ILanguageRepository languageRepository)
{
_eventCustomerRepository = eventCustomerRepository;
_customerRepository = customerRepository;
_orderRepository = orderRepository;
_eventPackageRepository = eventPackageRepository;
_eventTestRepository = eventTestRepository;
_hospitalPartnerCustomerViewModelFactory = hospitalPartnerCustomerViewModelFactory;
_eventCustomerResultRepository = eventCustomerResultRepository;
_hospitalPartnerCustomerRepository = hospitalPartnerCustomerRepository;
_organizationRoleUserRepository = organizationRoleUserRepository;
_eventRepository = eventRepository;
_hostRepository = hostRepository;
_hospitalPartnerEventListFactory = hospitalPartnerEventListFactory;
_shippingDetailRepository = shippingDetailRepository;
_shippingOptionRepository = shippingOptionRepository;
_podRepository = podRepository;
_hospitalPartnerRepository = hospitalPartnerRepository;
_organizationRepository = organizationRepository;
_corporateAccountRepository = corporateAccountRepository;
_notesRepository = notesRepository;
_primaryCarePhysicianRepository = primaryCarePhysicianRepository;
_healthAssessmentRepository = healthAssessmentRepository;
_hospitalPartnerViewModelFactory = hospitalPartnerViewModelFactory;
_customerCallNotesRepository = customerCallNotesRepository;
_eventCustomerNotificationRepository = eventCustomerNotificationRepository;
_hospitalFacilityRepository = hospitalFacilityRepository;
_settings = settings;
_languageRepository = languageRepository;
}
public CheckoutService(ICustomerRepository customerRepository, IShippingRepository shippingRepository, IOrderRepository orderRepository, IShoppingCartService shoppingCartService, IHttpContextAccessor httpContextAccessor)
{
_customerRepository = customerRepository;
_shippingRepository = shippingRepository;
_orderRepository = orderRepository;
_shoppingCartService = shoppingCartService;
_httpContextAccessor = httpContextAccessor;
_storeDB = new StoreDbContext();
}
public UnitOfWork(IOrderRepository orderRepository, IProductRepository productRepository)
{
Orders = orderRepository;
Products = productRepository;
}
public OrderController(IOrderRepository orderRepository, ShoppingCart shoppingCart)
{
_orderRepository = orderRepository;
_shoppingCart = shoppingCart;
}
public CheckoutOrderHandler(IOrderRepository orderRepository)
{
this.orderRepository = orderRepository ?? throw new ArgumentNullException(nameof(orderRepository));
}
public OrderController(IOrderRepository repoOrder, IPackageRepository repoPackage)
{
_repoOrder = repoOrder;
_repoPackage = repoPackage;
}
