public AccountController(
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
ILogger <AccountController> logger,
IIdentityServerInteractionService interaction,
IClientStore clientStore,
IHttpContextAccessor httpContextAccessor,
IAuthenticationSchemeProvider schemeProvider,
dna.core.auth.IAuthenticationService authServices,
IHostingEnvironment hostingEnvironment,
ISenderFactory sender,
IUserDetailService userDetailService
)
{
_userManager = userManager;
_signInManager = signInManager;
_logger = logger;
_interaction = interaction;
_account = new AccountService(interaction, httpContextAccessor, schemeProvider, clientStore);
_authServices = authServices;
_hostingEnvironment = hostingEnvironment;
_sender = sender;
_userDetailService = userDetailService;
}
public void Setup()
{
requestRouter = mockRequestRouter.Object;
monitorCache = mockMonitorCache.Object;
factory = mockFactory.Object;
senderMonitor = mockSenderMonitor.Object;
sender = mockSender.Object;
address = mockAddress.Object;
senderRouting = SenderRouting.For <ISender>(address);
mockFactory
.SetupGet(m => m.SenderType)
.Returns(typeof(ISender));
mockFactory
.SetupGet(m => m.SenderMonitor)
.Returns(senderMonitor);
mockRequestRouter
.Setup(m => m.RoutingFor <object>(out senderRouting))
.Returns(true);
mockFactory
.Setup(m => m.CreateSender(It.IsAny <IAddress>()))
.Returns(sender);
mockFactory
.SetupGet(m => m.SenderMonitor)
.Returns(senderMonitor);
}
public OrderController(ISenderFactory senderFactory,
IBasketRepository basketRepository,
IOrderService orderService)
{
_senderFactory = senderFactory;
_basketRepository = basketRepository;
_orderService = orderService;
}
public AuthenticationService(IHttpContextAccessor contextAccessor, UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager, RoleManager <ApplicationRole> roleManager,
ISenderFactory sender)
{
_context = contextAccessor.HttpContext;
_userManager = userManager;
_signInManager = signInManager;
_roleManager = roleManager;
_sender = sender;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:MediCore.Api.Controllers.AccountController"/> class.
/// </summary>
/// <param name="userService">User Service</param>
/// <param name="authServices">Auth services.</param>
/// <param name="userDetailService">User detail service.</param>
/// <param name="patientService">File service.</param>
/// <param name="fileServices">Patient service.</param>
/// <param name="sender">Sender.</param>
/// <param name="hostingEnvironment">Hosting environment.</param>
public AccountController(IUserService userService, IAuthenticationService authServices, IUserDetailService userDetailService, IPatientService patientService, IFileServices fileServices, ISenderFactory sender, IHostingEnvironment hostingEnvironment)
{
_userService = userService;
_authServices = authServices;
_userDetailService = userDetailService;
_patientService = patientService;
_sender = sender;
_fileServices = fileServices;
_hostingEnvironment = hostingEnvironment;
}
private ISender GetSenderFromFactory(ISenderFactory senderFactory, Configuration.SenderConfiguration configuration)
{
try
{
var sender = senderFactory.GetSender(_loggerFactory, configuration);
_logger.LogDebug($"Using sender {sender}");
return(sender);
}
catch (Exception e)
{
_logger.LogWarning("Failed to get a sender from the sender factory.", e);
throw;
}
}
public ServiceFactory(IStorage storage, ITelegramBotClient client, ILogger logger)
{
this.storage = storage;
this.logger = logger;
userServiceFactory = new UserServiceFactory(storage, logger);
var metricFactory = new MetricsFactory(Settings.Instance.Env, Settings.Logger);
var metricService = metricFactory.Create();
senderFactory = new SenderFactory(client, metricService);
parserService = new CommandHandlerFactory();
stateFactory = new StateFactory(logger);
contextFactory = new ContextFactory(storage, userServiceFactory, stateFactory, this);
}
/// <summary>
/// Adds a <see cref="ISenderFactory{TSender}"/> to the registered factories
/// </summary>
/// <param name="factory">Factory used to create <see cref="ISender"/>s at when required to send first message to remote <see cref="IReceiver"/></param>
public void AddFactory(ISenderFactory factory)
{
if (factory is null)
{
throw new ArgumentNullException(nameof(factory));
}
if (factories.ContainsKey(factory.SenderType))
{
return;
}
factories.Add(factory.SenderType, factory);
monitorCache.AddMonitor(factory.SenderMonitor);
}
public TestController(ISenderFactory factory)
{
_factory = factory;
}
public SomethingHappenedHandler(ISettingsRepository settingsRepository, ISenderFactory senderFactory)
{
_settingsRepository = settingsRepository;
_senderFactory = senderFactory;
}
public HospitalAppointmentService(ISenderFactory senderFact, IAuthenticationService authService, IHostingEnvironment env, IMediCoreUnitOfWork unitofWork)
: base(authService, unitofWork)
{
_senderFact = senderFact;
_env = env;
}
internal Connection(IConnectionHandler connectionHandler, IReceiverFactory receiverFactory, ISenderFactory senderFactory)
{
_connectionHandler = connectionHandler;
_receiverFactory = receiverFactory;
_senderFactory = senderFactory;
}
/// <summary>
/// Register a <see cref="ISenderFactory"/> to the this SenderResolver. These will be checked
/// </summary>
/// <param name="factory">The factory to register by it's <see cref="ISenderFactory.FactoryName"/></param>
/// <returns>A reference to itself for easy chaining</returns>
public SenderResolver RegisterSenderFactory(ISenderFactory factory)
{
_senderFactories[factory.FactoryName] = factory;
return(this);
}
/// <summary>
/// Initialize
/// </summary>
/// <param name="sender"></param>
/// <param name="hostingEnvironment"></param>
public TestController(ISenderFactory sender, IHostingEnvironment hostingEnvironment)
{
_sender = sender;
_hostingEnvironment = hostingEnvironment;
}
