public OrderDetailsPresentationModel(IOrderDetailsView view, IAccountPositionService accountPositionService, IOrdersService ordersService)
{
View = view;
this.accountPositionService = accountPositionService;
this.ordersService = ordersService;
_transactionInfo = new TransactionInfo();
//use localizable enum descriptions
AvailableOrderTypes = new List<ValueDescription<OrderType>>
{
new ValueDescription<OrderType>(OrderType.Limit, Resources.OrderType_Limit),
new ValueDescription<OrderType>(OrderType.Market, Resources.OrderType_Market),
new ValueDescription<OrderType>(OrderType.Stop, Resources.OrderType_Stop)
};
AvailableTimesInForce = new List<ValueDescription<TimeInForce>>
{
new ValueDescription<TimeInForce>(TimeInForce.EndOfDay, Resources.TimeInForce_EndOfDay),
new ValueDescription<TimeInForce>(TimeInForce.ThirtyDays, Resources.TimeInForce_ThirtyDays)
};
View.Model = this;
ValidateModel();
SubmitCommand = new DelegateCommand<object>(Submit, CanSubmit);
CancelCommand = new DelegateCommand<object>(Cancel);
SubmitCommand.IsActive = view.IsActive;
CancelCommand.IsActive = view.IsActive;
view.IsActiveChanged += view_IsActiveChanged;
}
public OrderDetailsViewModel(IAccountPositionService accountPositionService, IOrdersService ordersService)
{
this.accountPositionService = accountPositionService;
this.ordersService = ordersService;
this.transactionInfo = new TransactionInfo();
//use localizable enum descriptions
this.AvailableOrderTypes = new ValueDescriptionList<OrderType>
{
new ValueDescription<OrderType>(OrderType.Limit, Resources.OrderType_Limit),
new ValueDescription<OrderType>(OrderType.Market, Resources.OrderType_Market),
new ValueDescription<OrderType>(OrderType.Stop, Resources.OrderType_Stop)
};
this.AvailableTimesInForce = new ValueDescriptionList<TimeInForce>
{
new ValueDescription<TimeInForce>(TimeInForce.EndOfDay, Resources.TimeInForce_EndOfDay),
new ValueDescription<TimeInForce>(TimeInForce.ThirtyDays, Resources.TimeInForce_ThirtyDays)
};
this.SubmitCommand = new DelegateCommand<object>(this.Submit, this.CanSubmit);
this.CancelCommand = new DelegateCommand<object>(this.Cancel);
this.SetInitialValidState();
}
public OrdersController(
[ServiceDependency] IOrdersService ordersService,
[ServiceDependency] IHttpContextLocatorService httpContextLocatorService,
[ServiceDependency] IOrderEntryFlowService orderEntryFlowService)
{
_ordersService = ordersService;
_httpContextLocatorService = httpContextLocatorService;
_orderEntryFlowService = orderEntryFlowService;
}
public HomeController(IOrdersService ordersService, IEmployeeRegistrationService employeeRegistrationService, IEmployeeService employeeService,
IAuthenticationService authenticationService, IWorkContext workContext)
{
_workContext = workContext;
_authenticationService = authenticationService;
_ordersService = ordersService;
_employeeRegistrationService = employeeRegistrationService;
_employeeService = employeeService;
}
public OrderController(IShoppingCartService shoppingCartService,
ITicketsService ticketsService,
IDelliveryAddressesService delliveryAddressesService,
IOrdersService ordersService)
{
this.shoppingCartService = shoppingCartService;
this.ticketsService = ticketsService;
this.delliveryAddressesService = delliveryAddressesService;
this.ordersService = ordersService;
}
public OrdersController(
IContentManager contentManager,
IOrdersService ordersService,
ISiteService siteService,
IShapeFactory shapeFactory
)
{
_contentManager = contentManager;
_ordersService = ordersService;
_siteService = siteService;
Shape = shapeFactory;
}
public OrderPartHandler(
IRepository<OrderPartRecord> repository,
IContentManager contentManager,
IRepository<OrderDetailRecord> orderDetailsRepository,
IOrdersService ordersService,
IRepository<OrderAddressRecord> orderAddressRepository)
{
_orderDetailsRepository = orderDetailsRepository;
Filters.Add(StorageFilter.For(repository));
OnActivated<OrderPart>((context, part) => {
// Details
part._details.Loader(details => _orderDetailsRepository.Fetch(d => d.OrderId == part.Id)
.Select(d => new OrderDetail(d))
.ToList());
// Order total
part._orderTotal.Loader(orderTotal => BuildOrderTotal(part));
// BillingAddress
part._billingAddress.Loader(shippingAddress => orderAddressRepository.Get(part.BillingAddressId));
});
OnLoading<OrderPart>((context, part) => {
// Order total
part._orderTotal.Loader(orderTotal => part.Retrieve(x => x.OrderTotal));
});
OnCreating<OrderPart>((context, part) => {
if (String.IsNullOrWhiteSpace(part.Reference)) {
part.Reference = ordersService.BuildOrderReference();
}
});
OnCreated<OrderPart>((context, part) => {
// Order total
part.OrderTotal = BuildOrderTotal(part);
SaveDetails(part);
part.BillingAddressId = orderAddressRepository.CreateOrUpdate(part.BillingAddress);
});
OnUpdated<OrderPart>((context, part) => {
// Order total
part.OrderTotal = BuildOrderTotal(part);
SaveDetails(part);
part.BillingAddressId = orderAddressRepository.CreateOrUpdate(part.BillingAddress);
});
}
public CheckoutController(
ICustomersService customersService,
IShoppingCartService shoppingCartService,
IOrdersService ordersService,
IOrchardServices services,
IShapeFactory shapeFactory,
IEnumerable<IPaymentProvider> paymentProviders,
IShippingService shippingService = null)
{
_customersService = customersService;
_shoppingCartService = shoppingCartService;
_ordersService = ordersService;
_shapeFactory = shapeFactory;
_shippingService = shippingService;
_paymentProviders = paymentProviders.OrderByDescending(p => p.Priority);
Services = services;
T = NullLocalizer.Instance;
}
public Shop(IProductsCatalogService productsCatalogService, IOrdersService ordersService)
{
_id = Guid.NewGuid();
_productsCatalogService = productsCatalogService;
_ordersService = ordersService;
}
public SearchService(IOrdersService ordersService, IProductService productService, ICustomersService customersService)
{
this.ordersService = ordersService;
this.productService = productService;
this.customersService = customersService;
}
public CartController(IProductsService productsService, IOrderDetailsService orderDetailsService, IOrdersService ordersService, ICartService cartService, ICategoriesService categoriesService)
{
_productsService = productsService;
_ordersService = ordersService;
_cartService = cartService;
_categoriesService = categoriesService;
_orderDetailsService = orderDetailsService;
}
/// <summary>
/// Constructor for Orders functions of McKenzies Pharmacy API
/// </summary>
public OrdersController(IOrdersService service, ICustomersService customersService)
{
_service = service;
_customersService = customersService;
}
public CompareController(IShippersService shipperService, IOrdersService orderService, IConfiguration iconfiguration)
{
_shipperService = shipperService;
_orderService = orderService;
_iconfiguration = iconfiguration;
}
public OrdersController(IProductsService productsService, IOrdersService ordersService)
: base(productsService)
{
this.ordersService = ordersService;
}
public OrdersController(IOrdersService ordersService, IReceiptsService receiptsService)
{
this.ordersService = ordersService;
this.receiptsService = receiptsService;
}
public HomeController(ILogger <HomeController> logger, IOrdersService ordersService)
{
_logger = logger;
_ordersService = ordersService;
}
public CartController(ICartService cartService, IOrdersService ordersService)
{
this.cartService = cartService;
this.ordersService = ordersService;
}
public SearchService(IOrdersService ordersService, IProductsService productsService)
{
this.ordersService = ordersService;
this.productsService = productsService;
}
public OrdersController(LinkGenerator linkGenerator, IOrdersService ordersService)
{
_linkGenerator = linkGenerator;
_ordersService = ordersService;
}
//User manager is required to use User.Identity
public OrdersController(IOrdersService ordersService, IOrderDetailsService orderDetailsService, UserManager <IdentityUser> userManager, IProductsService productsService)
{
_ordersService = ordersService;
_orderDetailsService = orderDetailsService;
_productsService = productsService;
}
public EventsController(IEventsService eventsService, IMapper mapper, ILogger <EventsController> logger, IOrdersService ordersService)
{
this.eventsService = eventsService;
this.mapper = mapper;
this.logger = logger;
this.ordersService = ordersService;
}
public CartController(ICartService cartService, IOrdersService ordersService)
{
_cartService = cartService;
_ordersService = ordersService;
}
public OrdersController(IProducts productService, IOrdersService ordersService)
{
this.ProductService = productService;
this.OrdersService = ordersService;
}
public OrderStateMachine(ISpeechSubsystem speechSubsystem, ILogger logger, IOrdersService ordersService)
{
this.speechSubsystem = speechSubsystem;
this.logger = logger;
this.ordersService = ordersService;
this.stateMachine = new StateMachine <State, Trigger>(State.Initial);
this.processResponseTrigger = this.stateMachine.SetTriggerParameters <String>(Trigger.ProcessResponse);
this.stateMachine.Configure(State.Initial)
.Permit(Trigger.Proceed, State.Greeting);
#region Greeting
this.stateMachine.Configure(State.Greeting)
.OnEntryAsync(this.Greeting_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidYes, State.OrderFrom)
.Case(this.IsValidNo, State.NotOrder)
.Default(State.GreetingFailed01))
.Permit(Trigger.RecognitionError, State.GreetingFailed01);
this.stateMachine.Configure(State.GreetingFailed01)
.OnEntryAsync(this.GreetingFailed01_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidYes, State.OrderFrom)
.Case(this.IsValidNo, State.NotOrder)
.Default(State.GreetingFailed02))
.Permit(Trigger.RecognitionError, State.GreetingFailed02);
this.stateMachine.Configure(State.GreetingFailed02)
.OnEntryAsync(this.GreetingFailed02_Entry)
.Permit(Trigger.Proceed, State.Aborted);
#endregion
#region NotOrder
this.stateMachine.Configure(State.NotOrder)
.OnEntryAsync(this.NotOrder_Entry)
.Permit(Trigger.Proceed, State.Aborted);
#endregion
#region OrderFrom
this.stateMachine.Configure(State.OrderFrom)
.OnEntryAsync(this.OrderFrom_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidAddress, State.OrderFromConfirm)
.Default(State.OrderFromFailed01))
.Permit(Trigger.RecognitionError, State.OrderFromFailed01);
this.stateMachine.Configure(State.OrderFromFailed01)
.OnEntryAsync(this.OrderFromFailed01_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidAddress, State.OrderFromConfirm)
.Default(State.OrderFromFailed02))
.Permit(Trigger.RecognitionError, State.OrderFromFailed02);
this.stateMachine.Configure(State.OrderFromFailed02)
.OnEntryAsync(this.OrderFromFailed02_Entry)
.Permit(Trigger.Proceed, State.Aborted);
#endregion
#region OrderFromConfirm
this.stateMachine.Configure(State.OrderFromConfirm)
.OnEntryFromAsync(this.processResponseTrigger, this.OrderFromConfirm_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidYes, State.OrderTo)
.Case(this.IsValidNo, State.OrderFromNotConfirmed)
.Default(State.OrderFromConfirmFailed01))
.Permit(Trigger.RecognitionError, State.OrderFromConfirmFailed01);
this.stateMachine.Configure(State.OrderFromConfirmFailed01)
.OnEntryAsync(this.OrderFromConfirmFailed01_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidYes, State.OrderTo)
.Case(this.IsValidNo, State.OrderFromNotConfirmed)
.Default(State.OrderFromConfirmFailed02))
.Permit(Trigger.RecognitionError, State.OrderFromConfirmFailed02);
this.stateMachine.Configure(State.OrderFromConfirmFailed02)
.OnEntryAsync(this.OrderFromConfirmFailed02_Entry)
.Permit(Trigger.Proceed, State.Aborted);
this.stateMachine.Configure(State.OrderFromNotConfirmed)
.OnEntryAsync(this.OrderFromNotConfirmed_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidAddress, State.OrderFromConfirm)
.Default(State.OrderFromFailed01))
.Permit(Trigger.RecognitionError, State.OrderFromFailed01);
#endregion
#region OrderTo
this.stateMachine.Configure(State.OrderTo)
.OnEntryAsync(this.OrderTo_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidAddress, State.OrderToConfirm)
.Default(State.OrderToFailed01))
.Permit(Trigger.RecognitionError, State.OrderToFailed01);
this.stateMachine.Configure(State.OrderToFailed01)
.OnEntryAsync(this.OrderToFailed01_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidAddress, State.OrderToConfirm)
.Default(State.OrderToFailed02))
.Permit(Trigger.RecognitionError, State.OrderToFailed02);
this.stateMachine.Configure(State.OrderToFailed02)
.OnEntryAsync(this.OrderToFailed02_Entry)
.Permit(Trigger.Proceed, State.Aborted);
#endregion
#region OrderToConfirm
this.stateMachine.Configure(State.OrderToConfirm)
.OnEntryFromAsync(this.processResponseTrigger, this.OrderToConfirm_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidYes, State.OrderNowConfirm)
.Case(this.IsValidNo, State.OrderToNotConfirmed)
.Default(State.OrderToConfirmFailed01))
.Permit(Trigger.RecognitionError, State.OrderToConfirmFailed01);
this.stateMachine.Configure(State.OrderToConfirmFailed01)
.OnEntryAsync(this.OrderToConfirmFailed01_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidYes, State.OrderNowConfirm)
.Case(this.IsValidNo, State.OrderToNotConfirmed)
.Default(State.OrderToConfirmFailed02))
.Permit(Trigger.RecognitionError, State.OrderToConfirmFailed02);
this.stateMachine.Configure(State.OrderToConfirmFailed02)
.OnEntryAsync(this.OrderToConfirmFailed02_Entry)
.Permit(Trigger.Proceed, State.Aborted);
this.stateMachine.Configure(State.OrderToNotConfirmed)
.OnEntryAsync(this.OrderToNotConfirmed_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidAddress, State.OrderToConfirm)
.Default(State.OrderToFailed01))
.Permit(Trigger.RecognitionError, State.OrderToFailed01);
#endregion
#region OrderNowConfirm
this.stateMachine.Configure(State.OrderNowConfirm)
.OnEntryAsync(this.OrderNowConfirm_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidYes, State.OrderNowConfirmApply)
.Case(this.IsValidNo, State.OrderTodayConfirm)
.Default(State.OrderNowConfirmFailed01))
.Permit(Trigger.RecognitionError, State.OrderNowConfirmFailed01);
this.stateMachine.Configure(State.OrderNowConfirmFailed01)
.OnEntryAsync(this.OrderNowConfirmFailed01_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidYes, State.OrderNowConfirmApply)
.Case(this.IsValidNo, State.OrderTodayConfirm)
.Default(State.OrderNowConfirmFailed02))
.Permit(Trigger.RecognitionError, State.OrderNowConfirmFailed02);
this.stateMachine.Configure(State.OrderNowConfirmFailed02)
.OnEntryAsync(this.OrderNowConfirmFailed02_Entry)
.Permit(Trigger.Proceed, State.Aborted);
this.stateMachine.Configure(State.OrderNowConfirmApply)
.OnEntryAsync(this.OrderNowConfirmApply_Entry)
.Permit(Trigger.Proceed, State.OrderCallerPhoneConfirm);
#endregion
#region OrderTodayConfirm
this.stateMachine.Configure(State.OrderTodayConfirm)
.OnEntryAsync(this.OrderTodayConfirm_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidYes, State.OrderTodayTime)
.Case(this.IsValidNo, State.OrderCustomDateTime)
.Default(State.OrderTodayConfirmFailed01))
.Permit(Trigger.RecognitionError, State.OrderTodayConfirmFailed01);
this.stateMachine.Configure(State.OrderTodayConfirmFailed01)
.OnEntryAsync(this.OrderTodayConfirmFailed01_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidYes, State.OrderTodayTime)
.Case(this.IsValidNo, State.OrderCustomDateTime)
.Default(State.OrderTodayConfirmFailed02))
.Permit(Trigger.RecognitionError, State.OrderTodayConfirmFailed02);
this.stateMachine.Configure(State.OrderTodayConfirmFailed02)
.OnEntryAsync(this.OrderTodayConfirmFailed02_Entry)
.Permit(Trigger.Proceed, State.Aborted);
#endregion
#region OrderTodayTime
this.stateMachine.Configure(State.OrderTodayTime)
.OnEntryAsync(this.OrderTodayTime_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidTime, State.OrderTodayTimeApply)
.Default(State.OrderTodayTimeFailed01))
.Permit(Trigger.RecognitionError, State.OrderTodayTimeFailed01);
this.stateMachine.Configure(State.OrderTodayTimeFailed01)
.OnEntryAsync(this.OrderTodayTimeFailed01_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidTime, State.OrderTodayTimeApply)
.Default(State.OrderTodayTimeFailed02))
.Permit(Trigger.RecognitionError, State.OrderTodayTimeFailed02);
this.stateMachine.Configure(State.OrderTodayTimeFailed02)
.OnEntryAsync(this.OrderTodayTimeFailed02_Entry)
.Permit(Trigger.Proceed, State.Aborted);
this.stateMachine.Configure(State.OrderTodayTimeApply)
.OnEntryFromAsync(this.processResponseTrigger, this.OrderTodayTimeApply_Entry)
.Permit(Trigger.Proceed, State.OrderCallerPhoneConfirm);
#endregion
#region OrderCustomDateTime
this.stateMachine.Configure(State.OrderCustomDateTime)
.OnEntryAsync(this.OrderCustomDateTime_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidDateTime, State.OrderCustomDateTimeApply)
.Default(State.OrderCustomDateTimeFailed01))
.Permit(Trigger.RecognitionError, State.OrderCustomDateTimeFailed01);
this.stateMachine.Configure(State.OrderCustomDateTimeFailed01)
.OnEntryAsync(this.OrderCustomDateTimeFailed01_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidDateTime, State.OrderCustomDateTimeApply)
.Default(State.OrderCustomDateTimeFailed02))
.Permit(Trigger.RecognitionError, State.OrderCustomDateTimeFailed02);
this.stateMachine.Configure(State.OrderCustomDateTimeFailed02)
.OnEntryAsync(this.OrderCustomDateTimeFailed02_Entry)
.Permit(Trigger.Proceed, State.Aborted);
this.stateMachine.Configure(State.OrderCustomDateTimeApply)
.OnEntryFromAsync(this.processResponseTrigger, this.OrderCustomDateTimeApply_Entry)
.Permit(Trigger.Proceed, State.OrderCallerPhoneConfirm);
#endregion
#region CallerPhoneConfirm
this.stateMachine.Configure(State.OrderCallerPhoneConfirm)
.OnEntryAsync(this.OrderCallerPhoneConfirm_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidYes, State.OrderCallerPhoneConfirmApply)
.Case(this.IsValidNo, State.OrderPhoneRequest)
.Default(State.OrderCallerPhoneConfirmFailed01))
.Permit(Trigger.RecognitionError, State.OrderCallerPhoneConfirmFailed01);
this.stateMachine.Configure(State.OrderCallerPhoneConfirmFailed01)
.OnEntryAsync(this.OrderCallerPhoneConfirmFailed01_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidYes, State.OrderCallerPhoneConfirmApply)
.Case(this.IsValidNo, State.OrderPhoneRequest)
.Default(State.OrderCallerPhoneConfirmFailed02))
.Permit(Trigger.RecognitionError, State.OrderCallerPhoneConfirmFailed02);
this.stateMachine.Configure(State.OrderCallerPhoneConfirmFailed02)
.OnEntryAsync(this.OrderCallerPhoneConfirmFailed02_Entry)
.Permit(Trigger.Proceed, State.Aborted);
this.stateMachine.Configure(State.OrderCallerPhoneConfirmApply)
.OnEntryAsync(this.OrderCallerPhoneConfirmApply_Entry)
.Permit(Trigger.Proceed, State.OrderAdditionalInfoRequest);
#endregion
#region PhoneRequest
this.stateMachine.Configure(State.OrderPhoneRequest)
.OnEntryAsync(this.OrderPhoneRequest_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidPhone, State.OrderPhoneRequestApply)
.Default(State.OrderPhoneRequestFailed01))
.Permit(Trigger.RecognitionError, State.OrderPhoneRequestFailed01);
this.stateMachine.Configure(State.OrderPhoneRequestFailed01)
.OnEntryAsync(this.OrderPhoneRequestFailed01_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidPhone, State.OrderPhoneRequestApply)
.Default(State.OrderPhoneRequestFailed02))
.Permit(Trigger.RecognitionError, State.OrderPhoneRequestFailed02);
this.stateMachine.Configure(State.OrderPhoneRequestFailed02)
.OnEntryAsync(this.OrderPhoneRequestFailed02_Entry)
.Permit(Trigger.Proceed, State.Aborted);
this.stateMachine.Configure(State.OrderPhoneRequestApply)
.OnEntryFromAsync(this.processResponseTrigger, this.OrderPhoneRequestApply_Entry)
.Permit(Trigger.Proceed, State.OrderAdditionalInfoRequest);
#endregion
#region AdditionalInfoRequest
this.stateMachine.Configure(State.OrderAdditionalInfoRequest)
.OnEntryAsync(this.OrderAdditionalInfoRequest_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidYes, State.OrderAdditionalInfo)
.Case(this.IsValidNo, State.OrderAdditionalInfoNoneApply)
.Default(State.OrderAdditionalInfoFailed01))
.Permit(Trigger.RecognitionError, State.OrderAdditionalInfoRequestFailed01);
this.stateMachine.Configure(State.OrderAdditionalInfoRequestFailed01)
.OnEntryAsync(this.OrderAdditionalInfoRequestFailed01_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidYes, State.OrderAdditionalInfo)
.Case(this.IsValidNo, State.OrderAdditionalInfoNoneApply)
.Default(State.OrderAdditionalInfoFailed02))
.Permit(Trigger.RecognitionError, State.OrderAdditionalInfoRequestFailed02);
this.stateMachine.Configure(State.OrderAdditionalInfoRequestFailed02)
.OnEntryAsync(this.OrderAdditionalInfoRequestFailed02_Entry)
.Permit(Trigger.Proceed, State.Aborted);
this.stateMachine.Configure(State.OrderAdditionalInfoNoneApply)
.OnEntryAsync(this.OrderAdditionalInfoNoneApply_Entry)
.Permit(Trigger.Proceed, State.OrderCreated);
#endregion
#region AdditionalInfo
this.stateMachine.Configure(State.OrderAdditionalInfo)
.OnEntryAsync(this.OrderAdditionalInfo_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidAdditionalInfo, State.OrderAdditionalInfoApply)
.Default(State.OrderAdditionalInfoFailed01))
.Permit(Trigger.RecognitionError, State.OrderAdditionalInfoFailed01);
this.stateMachine.Configure(State.OrderAdditionalInfoFailed01)
.OnEntryAsync(this.OrderAdditionalInfoFailed01_Entry)
.PermitWhen(this.processResponseTrigger, builder => builder
.Case(this.IsValidAdditionalInfo, State.OrderAdditionalInfoApply)
.Default(State.OrderAdditionalInfoFailed02))
.Permit(Trigger.RecognitionError, State.OrderAdditionalInfoFailed02);
this.stateMachine.Configure(State.OrderAdditionalInfoFailed02)
.OnEntryAsync(this.OrderAdditionalInfoFailed02_Entry)
.Permit(Trigger.Proceed, State.Aborted);
this.stateMachine.Configure(State.OrderAdditionalInfoApply)
.OnEntryFromAsync(this.processResponseTrigger, this.OrderAdditionalInfoApply_Entry)
.Permit(Trigger.Proceed, State.OrderCreated);
#endregion
#region OrderCreated
this.stateMachine.Configure(State.OrderCreated)
.OnEntryAsync(this.OrderCreated_Entry)
.Permit(Trigger.Proceed, State.Complete);
#endregion
this.stateMachine.Configure(State.Aborted)
.OnEntryAsync(this.Aborted_Entry);
this.stateMachine.Configure(State.Complete)
.OnEntryAsync(this.Complete_Entry);
}
public CancelOrderHandler(IOrdersService ordersService)
{
_ordersService = ordersService;
}
public ReportsController(IOrdersService ordersService)
{
_ordersService = ordersService;
}
public OrdersControllerTests()
{
_ordersService = new OrdersService();
_productsService = new ProductsService();
_ordersController = new OrdersController(_ordersService, _productsService);
}
public OrderController(IOrdersDetailsService ordersDetailsService, IOrdersService ordersService, IProductsService productsService)
{
_ordersService = ordersService;
_ordersDetailsService = ordersDetailsService;
_productsService = productsService;
}
protected OrderController(IOrdersService ordersService)
{
_ordersService = ordersService;
}
public RootDialog(string checkoutUriFormat, IContosoFlowersDialogFactory dialogFactory, IOrdersService ordersService)
{
this.checkoutUriFormat = checkoutUriFormat;
this.dialogFactory = dialogFactory;
this.ordersService = ordersService;
}
public TicketsController(ITicketsService ticketsService, IEventsService eventsService, IVenuesService venuesService, ICitiesService citiesService, IUsersAndRolesService usersAndRolesService, IOrdersService ordersService, IStringLocalizer <TicketsController> localizer)
{
this.localizer = localizer;
this.ticketsService = ticketsService;
this.eventsService = eventsService;
this.venuesService = venuesService;
this.citiesService = citiesService;
this.usersAndRolesService = usersAndRolesService;
this.ordersService = ordersService;
}
public ProfileController(IOrdersService ordersService)
{
_ordersService = ordersService;
}
public DetailsModel(IOrdersService ordersService)
{
this._ordersService = ordersService;
}
public HomeController()
{
service = new OrdersService();
}
public ProfileController(IUserService usersService, ISubscriptionsService subscriptions, IMembershipService membershipService, ICoursesContentService coursesContentService, ICertificatesService certificatesService, IPaymentService paymentService, IOrdersService ordersService)
{
_usersService = usersService;
_subscriptions = subscriptions;
_membershipService = membershipService;
_coursesContentService = coursesContentService;
_certificatesService = certificatesService;
_paymentService = paymentService;
_ordersService = ordersService;
}
public OrdersController(ICustomerService customerService, IOrdersService ordersService, IContentLoader contentLoader)
{
_customerService = customerService;
_ordersService = ordersService;
_contentLoader = contentLoader;
}
public OrdersController(IOrdersService ordersService)
{
_ordersService = ordersService;
}
public InvoicesService(DreamBuilderDbContext context, IOrdersService ordersService)
{
this.context = context;
this.ordersService = ordersService;
}
public TestableOrderDetailsPresenter(IOrderDetailsView view, IAccountPositionService accountPositionService, IOrdersService ordersService)
: base(view, accountPositionService, ordersService)
{
}
public AdminController(IOrdersService ordersService)
{
this.ordersService = ordersService;
}
public OrdersController(IOrdersService ordersService, IMapper mapper)
{
this.mapper = mapper;
this.ordersService = ordersService;
}
public OrdersController(IOrdersService ordersService, ICustomerService customerService)
{
_ordersService = ordersService;
_customerService = customerService;
}
