public EditPizzaModel(IPizzaRepository repository) //And lastly Use this IPizzaRepository "repository" parameter to initialize the
// reference(named _catalog)
//And then proceed to use the methods as we used to since
//did not changed the variable name
{
_catalog = repository;
}
public PizzaService(
IPizzaRepository pizzaRepository,
IUnitOfWork unitOfWork)
{
_unitOfWork = unitOfWork;
_pizzaRepository = pizzaRepository;
}
public OrderController(IOrderRepository ORepo, IUserRepository URepo, IPizzaRepository PRepo, ILocationRepository LRepo)
{
this.ORepo = ORepo;
this.URepo = URepo;
this.PRepo = PRepo;
this.LRepo = LRepo;
}
public HomeController(IPizzaRepository pizzaRepository, IStringLocalizer <HomeController> stringLocalizer, ILogger <HomeController> logger, IMemoryCache memoryCache)
{
_pizzaRepository = pizzaRepository;
_stringLocalizer = stringLocalizer;
_logger = logger;
_memoryCache = memoryCache;
}
public PizzaController(IConfiguration configuration)
{
//pizzaRepository = new InMemoryPizzaRepository();
//pizzaRepository = new SqlPizzaRepository(configuration["ConnectionString"]);
//pizzaRepository = new DapperPizzaRepository(configuration["ConnectionString"]);
pizzaRepository = new EntityFrameworkPizzaRepository();
}
protected override Task ExecuteAsync(CancellationToken stoppingToken)
{
using (var scope = _serviceScopeFactory.CreateScope())
{
#region RabbitMQ
var appSettings = scope.ServiceProvider.GetRequiredService <AppSettings>();
var rabbitMQ = appSettings.ConnectionStrings.RabbitMQ;
var factory = new ConnectionFactory()
{
HostName = rabbitMQ.HostName, UserName = rabbitMQ.UserName, Password = rabbitMQ.Password
};
_connection = factory.CreateConnection();
_connection.ConnectionShutdown += _connection_ConnectionShutdown;
#endregion
#region MongoDB
_userRepo = scope.ServiceProvider.GetRequiredService <IUserRepository>();
_customerRepo = scope.ServiceProvider.GetRequiredService <ICustomerRepository>();
_pizzaRepo = scope.ServiceProvider.GetRequiredService <IPizzaRepository>();
_requestRepo = scope.ServiceProvider.GetRequiredService <IRequestRepository>();
_requestPizzaRepo = scope.ServiceProvider.GetRequiredService <IRequestPizzaRepository>();
PreemptiveInsertsMongoDB(scope);
#endregion
stoppingToken.ThrowIfCancellationRequested();
rabbitMQ.Queues.ToList().ForEach(e => CreateChannel(e));
}
return(Task.CompletedTask);
}
public OrderServices(IOrderRepository orderRepository, IFlavorRepository flavorRepository, IClientRepository clientRepository, IPizzaRepository pizzaRepository)
{
_orderRepository = orderRepository;
_flavorRepository = flavorRepository;
_clientRepository = clientRepository;
_pizzaRepository = pizzaRepository;
}
public OrderService(IRepository <Order> orderRepository, IRepository <User> userRepository, IPizzaRepository pizzaRepository)
{
//_orderRepository = new OrderRepository();
_orderRepository = orderRepository;
_userRepository = userRepository;
_pizzaRepository = pizzaRepository;
}
private Pizza loadPizza(IResolveFieldContext <object> context, IPizzaRepository pizzaRepository)
{
int id = (int)context.Arguments["id"];
var loadToppings = context.SubFields.FirstOrDefault(kv => kv.Key == "toppings").Key != null;
return(pizzaRepository.GetById(id, loadToppings));
}
private IPizzaRepository _catalog; //create the interface reference
public CreatePizzaModel(IPizzaRepository repository) //inject the interface created
{
_catalog = repository; //And lastly Use this IPizzaRepository "repository" parameter to initialize the
// reference(named _catalog)
//And then proceed to use the methods as we used to since
//did not changed the variable name
}
public ShoppingCartController(IPizzaRepository pizzaRepository,
ShoppingCart shoppingCart, AppDbContext context)
{
_pizzaRepository = pizzaRepository;
_shoppingCart = shoppingCart;
_context = context;
}
public OrderPizzaBot(ConversationState conversationState, UserState userState, OrderPizzaRecognizer recognizer, IPizzaRepository pizzaRepository)
{
_conversationState = conversationState;
_userState = userState;
_recognizer = recognizer;
_pizzaRepository = pizzaRepository;
_dialog = new MainDialog(_recognizer, userState, _pizzaRepository);
}
public PizzaService(IPizzaRepository pizzaRepository, IPizzaIngredientRepository pizzaIngredientRepository,
IRepository <Price> priceRepository, IRepository <OrderPrice> orderPriceRepository)
{
_pizzaRepository = pizzaRepository;
_pizzaIngredientRepository = pizzaIngredientRepository;
_priceRepository = priceRepository;
_orderPriceRepository = orderPriceRepository;
}
static void Main(string[] args)
{
pRepo = new PizzaRepository(new PizzaBoxContext());
oRepo = new OrderRepository(new PizzaBoxContext());
uRepo = new UserRepository(new PizzaBoxContext());
lRepo = new LocationRepository(new PizzaBoxContext());
MainOptions();
}
public PizzaAppService(IPizzaRepository repository,
IPizzaService service,
IUnitOfWork uow)
{
_repository = repository;
_service = service;
_uow = uow;
}
public PizzaService(IPizzaRepository pizzaRepository)
{
// before
//_pizzaRepository = new PizzaRepository();
// after new implemetation
//_pizzaRepository = new EfPizzaRepository();
_pizzaRepository = pizzaRepository;
_userRepository = new UserRepository();
}
public PizzaController(IPizzaRepository pizzaRepository, ICategoryRepository categoryRepository, ILogger <PizzaController> logger,
IPizzaReviewRepository pizzaReviewRepository, HtmlEncoder htmlEncoder)
{
_pizzaRepository = pizzaRepository;
_categoryRepository = categoryRepository;
_pizzaReviewRepository = pizzaReviewRepository;
_htmlEncoder = htmlEncoder;
_logger = logger;
}
public OrderService(IRepository <Order> orderRepository, IRepository <User> userRepository, IPizzaRepository pizzaRepository) // in order for the service to be instantiated, the repository is needed
{
//implementation of the IRepository<Order> interface
//_orderRepository = new OrderRepository();
_orderRepository = orderRepository;
_userRepository = userRepository;
_pizzaRepository = pizzaRepository;
}
public CartController(IPizzaRepository repo, IOrderlineRepository orderlineRepo, IOrderRepository orderRepo, IDeliveryRepository deliveryRepo, IVoucherRepository voucherRepo, IPizzaToppingOrderRepository pizzaToppingOrderRepo)
{
repository = repo;
orderlineRepository = orderlineRepo;
orderRepository = orderRepo;
deliveryRepository = deliveryRepo;
voucherRepository = voucherRepo;
pizzaToppingOrderRepository = pizzaToppingOrderRepo;
}
public CartController(IPizzaRepository repo, IOrderlineRepository orderlineRepo, IOrderRepository orderRepo, IDeliveryRepository deliveryRepo, IVoucherRepository voucherRepo, IPizzaToppingOrderRepository pizzaToppingOrderRepo)
{
repository = repo;
orderlineRepository = orderlineRepo;
orderRepository = orderRepo;
deliveryRepository = deliveryRepo;
voucherRepository = voucherRepo;
pizzaToppingOrderRepository = pizzaToppingOrderRepo;
}
public MenuCardService(IDrinkRepository drinkRepository,
IPizzaRepository pizzaRepository,
ISaladRepository saladRepository,
ISauceRepository sauceRepository)
{
_drinkRepository = drinkRepository;
_pizzaRepository = pizzaRepository;
_saladRepository = saladRepository;
_sauceRepository = sauceRepository;
}
public OrderPizzaBot(ConversationState conversationState, UserState userState, ILogger <OrderPizzaBot> logger, OrderPizzaRecognizer recognizer, IPizzaRepository pizzaRepository, IIngredientRepository ingredientRepository)
{
ConversationState = conversationState;
UserState = userState;
Logger = logger;
_recognizer = recognizer;
_pizzaRepository = pizzaRepository;
_ingredientRepository = ingredientRepository;
Dialog = new MainDialog(_recognizer, userState, pizzaRepository, ingredientRepository);
}
public HomeController(ILogger <HomeController> logger,
IPizzaRepository pizzaRepository,
IToppingRepository toppingRepository,
AppDbContext context)
{
_logger = logger;
_pizzaRepository = pizzaRepository;
_toppingRepository = toppingRepository;
_context = context;
}
public PizzaToppingService(
IMapper mapper,
IPizzaToppingRepository pizzaToppingRepository,
IPizzaRepository pizzaRepository,
IIngredientRepository ingredientRepository)
{
_mapper = mapper;
_pizzaToppingRepository = pizzaToppingRepository;
_pizzaRepository = pizzaRepository;
_ingredientRepository = ingredientRepository;
}
public PizzaService([Named("shopUnit")] IUnitOfWork unityOfWork,
IPizzaRepository pizzaRepository,
IComponentRepository componentRepository,
IPizzaSizePriceRepository pizzaSizePriceRepository,
IPizzaSizeRepository pizzaSizeRepsitory)
{
_unityOfWork = unityOfWork;
_pizzaRepository = pizzaRepository;
_componentRepository = componentRepository;
_pizzaSizePriceRepository = pizzaSizePriceRepository;
_pizzaSizeRepsitory = pizzaSizeRepsitory;
}
public static async Task PrintMenuAsync(WaterfallStepContext stepContext, IPizzaRepository pizzaRepository, CancellationToken cancellationToken)
{
var pizzas = pizzaRepository.GetPizzas();
var menu = new StringBuilder();
menu.AppendLine("¡Nuestra carta!");
foreach (var pizza in pizzas)
{
menu.AppendLine($"- {pizza.Name}: {(String.Join(", ", pizza.Ingredients.Select(i => i.Name)))}.");
}
var menuStr = menu.ToString();
await stepContext.Context.SendActivityAsync(menuStr, menuStr, InputHints.IgnoringInput, cancellationToken);
}
public PedidoController(IConfiguration config,
IClienteRepository clienteRepository,
IPedidoRepository pedidoRepository,
IPedidoItemRepository pedidoItemRepository,
IPizzaRepository pizzaRepository,
ISubItemRepository subItemRepository)
{
_configuration = config;
_clienteRepository = clienteRepository;
_pedidoRepository = pedidoRepository;
_pedidoItemRepository = pedidoItemRepository;
_pizzaRepository = pizzaRepository;
_subItemRepository = subItemRepository;
}
public PedidoAppService(IPedidoRepository repository,
IClienteRepository clienteRepository,
IPedidoService service,
IClienteService clienteService,
IPizzaRepository pizzaRepository,
IUnitOfWork uow)
{
_repository = repository;
_clienteRepository = clienteRepository;
_service = service;
_pizzaRepository = pizzaRepository;
_clienteService = clienteService;
_uow = uow;
}
public MainDialog(OrderPizzaRecognizer recognizer, UserState userState, IPizzaRepository pizzaRepository)
: base(nameof(MainDialog), recognizer)
{
_recognizer = recognizer;
_userState = userState;
_pizzaRepository = pizzaRepository;
_orderInfo = _userState.CreateProperty <OrderInfo>("OrderInfo");
AddDialog(new TextPrompt(nameof(TextPrompt)));
AddDialog(new OrderPizzaDialog(userState, _recognizer, _pizzaRepository));
AddDialog(new WaterfallDialog(nameof(WaterfallDialog), new WaterfallStep[]
{
ActAsync
}));
InitialDialogId = nameof(WaterfallDialog);
}
public bool IsRepositoryValid(Entities.Request request, IPizzaRepository pizzaRepository, ICustomerRepository customerRepository)
{
foreach (var rp in request.RequestPizzas)
{
Validate(rp, new CreateRequestPizzaRepositoryValidation(pizzaRepository));
if (!Valid)
{
return(false);
}
}
if (request.IdCustomer != null)
{
var customer = new Entities.Customer((int)request.IdCustomer, 0, null, null);
Validate(customer, new CreateRequestCustomerRepositoryValidation(customerRepository));
}
return(Valid);
}
public OrderPizzaDialog(UserState userState, OrderPizzaRecognizer recognizer, IPizzaRepository pizzaRepository)
: base(nameof(OrderPizzaDialog), recognizer)
{
_userState = userState;
_pizzaRepository = pizzaRepository;
_orderInfo = _userState.CreateProperty <OrderInfo>("OrderInfo");
AddDialog(new TextPrompt(nameof(TextPrompt)));
AddDialog(new NumberPrompt <int>(nameof(NumberPrompt <int>), null, "es"));
AddDialog(new ChoicePrompt(nameof(ChoicePrompt), null, "es"));
AddDialog(new ConfirmPrompt(nameof(ConfirmPrompt), ValidateConfirmation, "es"));
AddDialog(new PizzaSelectionDialog(_userState, Recognizer, _pizzaRepository));
AddDialog(new WaterfallDialog(nameof(WaterfallDialog), new WaterfallStep[]
{
NumberOfPizzasAsync,
OrderTypeAsync,
ConfirmPizzaSelectionAsync,
StartPizzaConfigurationAsync,
}));
InitialDialogId = nameof(WaterfallDialog);
}
public PizzaController()
{
ApplicationDbContext context = new ApplicationDbContext();
_repository = new PizzaRepository(context);
}
public PizzaQuery(IPizzaRepository pizzaRepository)
{
this.pizzaRepository = pizzaRepository;
}
public PizzaService(IPizzaRepository pizzasRepository)
{
_pizzasRepository = pizzasRepository;
}
public PizzaController(IPizzaRepository pizzaRepository, IToppingRepository toppingRepo)
{
repository = pizzaRepository;
toppingRepository = toppingRepo;
}
public AddPizzaCommand(IPizzaRepository pizzaRepository)
{
this.pizzaRepository = pizzaRepository;
}
