/// <summary> /// Initializes a new instance of the <see cref="T:Login.SignUpManager"/> class. /// </summary> /// <param name="loginManager">Login manager.</param> /// <param name="registrationManager">Registration manager.</param> /// <param name="configurationManager">Configuration manager.</param> /// <param name="dataFile">Data file.</param> public SignUpManager(ILoginManager loginManager, IRegistrationManager registrationManager, IConfigurationManager configurationManager, string dataFile) { _loginManager = loginManager; _registrationManager = registrationManager; _configurationManager = configurationManager; _dataFile = dataFile; }
internal LanguageClient( Connection connection, IOptions <LanguageClientOptions> options, IEnumerable <ICapability> capabilities, ClientInfo clientInfo, ClientCapabilities clientCapabilities, ILspClientReceiver lspClientReceiver, TextDocumentIdentifiers textDocumentIdentifiers, IServiceProvider serviceProvider, IEnumerable <OnLanguageClientStartedDelegate> startedDelegates, IEnumerable <IOnLanguageClientStarted> startedHandlers, ITextDocumentLanguageClient textDocumentLanguageClient, IClientLanguageClient clientLanguageClient, IGeneralLanguageClient generalLanguageClient, IWindowLanguageClient windowLanguageClient, IWorkspaceLanguageClient workspaceLanguageClient, LanguageProtocolSettingsBag languageProtocolSettingsBag, SharedHandlerCollection handlerCollection, IResponseRouter responseRouter, IProgressManager progressManager, IClientWorkDoneManager clientWorkDoneManager, IRegistrationManager registrationManager, ILanguageClientWorkspaceFoldersManager languageClientWorkspaceFoldersManager, IEnumerable <OnLanguageClientInitializeDelegate> initializeDelegates, IEnumerable <IOnLanguageClientInitialize> initializeHandlers, IEnumerable <OnLanguageClientInitializedDelegate> initializedDelegates, IEnumerable <IOnLanguageClientInitialized> initializedHandlers ) : base(handlerCollection, responseRouter) { _connection = connection; _capabilities = capabilities; _clientCapabilities = clientCapabilities; _clientInfo = clientInfo; _receiver = lspClientReceiver; _textDocumentIdentifiers = textDocumentIdentifiers; _startedDelegates = startedDelegates; _startedHandlers = startedHandlers; _rootUri = options.Value.RootUri; _trace = options.Value.Trace; _initializationOptions = options.Value.InitializationOptions; _settingsBag = languageProtocolSettingsBag; _collection = handlerCollection; Services = serviceProvider; _responseRouter = responseRouter; ProgressManager = progressManager; WorkDoneManager = clientWorkDoneManager; RegistrationManager = registrationManager; WorkspaceFoldersManager = languageClientWorkspaceFoldersManager; _initializeDelegates = initializeDelegates; _initializeHandlers = initializeHandlers; _initializedDelegates = initializedDelegates; _initializedHandlers = initializedHandlers; _concurrency = options.Value.Concurrency; // We need to at least create Window here in case any handler does loggin in their constructor TextDocument = textDocumentLanguageClient; Client = clientLanguageClient; General = generalLanguageClient; Window = windowLanguageClient; Workspace = workspaceLanguageClient; }
private static async void Test_NewUserRegistration() { Uri uri = new Uri("fabric:/Phoenix.Microservice.Registration/Phoenix.Manager.Registration.Service"); IRegistrationManager registrationProxy = ServiceProxy.Create <IRegistrationManager>(uri); var user = await registrationProxy.CreateNewUser(Guid.NewGuid(), "Sylvester", "Stallone"); Console.WriteLine($"New user: {user.UserObjectId} {user.FirstName} {user.LastName}"); }
public RegistrationController(ISessionManager sessionManager, IRegistrationManager registrationManager) { if (sessionManager == null) throw new ArgumentNullException("sessionManager"); if (registrationManager == null) throw new ArgumentNullException("registrationManager"); _sessionManager = sessionManager; _registrationManager = registrationManager; }
public RemoteNotificationManager(IRemoteNotificationChannel channel, IRegistrationManager registrationManager, IEventBus eventBus, INotificationManager notificationManager) { _channel = channel; _registrationManager = registrationManager; _notificationManager = notificationManager; eventBus.Subscribe<RemoteChannelDetailsChanged>(HandleChannelDetailsChanged); eventBus.Subscribe<RemoteNotificationReceivedEvent>(HandleNotificationReceived); }
internal Push(IRegistrationManager registrationManager) { if (registrationManager == null) { throw new ArgumentNullException("registrationManager"); } this.RegistrationManager = registrationManager; }
public void Setup() { Dictionary <string, string> users = new Dictionary <string, string> { { "*****@*****.**", CryptographyController.EncryptPassword("bobLikesThaiFood") }, { "*****@*****.**", CryptographyController.EncryptPassword("stuartLikesThaiFood") }, { "*****@*****.**", CryptographyController.EncryptPassword("kevinLikesThaiFood") } }; _registrationManager = new RegistrationManager(users); }
internal Push(MobileServiceClient client) { if (client == null) { throw new ArgumentNullException("client"); } var storageManager = new LocalStorageManager(client.ApplicationUri.Host); var pushHttpClient = new PushHttpClient(client); this.RegistrationManager = new RegistrationManager(pushHttpClient, storageManager); }
public IEnumerable <string> Get() { // return .ToList(); Uri uri = new Uri("fabric:/Phoenix.Microservice.Registration/Phoenix.Manager.Registration.Service"); IRegistrationManager registrationProxy = ServiceProxy.Create <IRegistrationManager>(uri); var user = registrationProxy.CreateNewUser(Guid.NewGuid(), "Sylvester", "Stallone").Result; var list = HttpContext.User.Claims.Select(claim => string.Concat(claim.Type, " : ", claim.Value)).ToList(); list.Add($"New user: {user.UserObjectId} {user.FirstName} {user.LastName}"); return(list); }
public ActionResult Create(List <Attendee> attendees) { IRegistrationManager regManager = UnityCache.ResolveDefault <IRegistrationManager>(); UserContext uc = new UserContext(); uc.AuditUserName = "******"; uc.ConnectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString; var reg = regManager.ProcessRegistration(uc, attendees); return(View()); }
public ActionResult Create(Attendee attendee) { List <Attendee> attendees = new List <Attendee>(); attendees.Add(attendee); IRegistrationManager regManager = UnityCache.ResolveDefault <IRegistrationManager>(); UserContext uc = new UserContext(); uc.ConnectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString; regManager.ProcessRegistration(uc, attendees); return(View()); }
public RegistrationCsvManager( IRegistrationManager manager, IEventAccessor eventAccessor, ICsvWriter csvWriter) { Guard.NotNull(manager, nameof(manager)); Guard.NotNull(eventAccessor, nameof(eventAccessor)); Guard.NotNull(csvWriter, nameof(csvWriter)); _manager = manager; _eventAccessor = eventAccessor; _csvWriter = csvWriter; }
public EntileClient( IChannelManager channelManager, IRegistrationManager registrationManager, IRemoteTileManager remoteTileManager, ISettingsProvider settingsProvider ) { _settingsProvider = settingsProvider; _channelManager = channelManager; _registrationManager = registrationManager; _remoteTileManager = remoteTileManager; ChannelManager.OpenChannelCompleted += OnOpenChannelCompleted; ChannelManager.HttpNotificationReceived += OnHttpNotificationReceived; ChannelManager.ShellToastNotificationReceived += OnShellToastNotificationReceived; RegistrationManager.RegisterCompleted += OnRegisterWithProviderCompleted; RegistrationManager.UpdateExtraInfoCompleted += OnUpdateExtraInfoCompleted; _extraInfo = _settingsProvider.GetExtraInfo(); _enable = _settingsProvider.GetEnabled(); }
protected virtual void ConfigureContainer() { _log.Info("Container Configuration started"); try { //Container.RegisterInstance(typeof(IUnityContainer), Container); RegistrationSettings settings = GetRegistrationSettings(); _registrationManager = new RegistrationManager(settings.RunMode, Container as ExtendedUnityContainer); _registrationManager.AutoRegisterUsingMefCatalog(settings.MefInitialCatalog); _registrationManager.CommitRegistrationsToContainer(); } catch (ReflectionTypeLoadException ex) { if (ex.LoaderExceptions != null) { foreach (Exception loaderException in ex.LoaderExceptions) { _log.Fatal(loaderException.Message, loaderException); } } _log.Fatal("Container Configuration failed", ex); throw; } catch (Exception ex) { _log.Fatal("Container Configuration failed", ex); throw; } finally { _log.Info("Container Configuration completed"); } }
public RegistrationFeature(ILoggerFactory loggerFactory, NodeSettings nodeSettings, RegistrationManager registrationManager, RegistrationStore registrationStore, ConcurrentChain chain, Signals signals, IWatchOnlyWalletManager watchOnlyWalletManager, IBlockNotification blockNotification, IWalletSyncManager walletSyncManager) { this.loggerFactory = loggerFactory; this.logger = loggerFactory.CreateLogger(this.GetType().FullName); this.nodeSettings = nodeSettings; this.registrationManager = registrationManager; this.registrationStore = registrationStore; this.chain = chain; this.signals = signals; this.network = nodeSettings.Network; this.watchOnlyWalletManager = watchOnlyWalletManager; this.blockNotification = blockNotification as BlockNotification; this.walletSyncManager = walletSyncManager; if (nodeSettings.Network == Network.Main || nodeSettings.Network == Network.TestNet || nodeSettings.Network == Network.RegTest) { // Bitcoin networks - these currently only interrogate the registration store for initial masternode selection this.isBitcoin = true; } else { // Stratis networks - these write to the registration store as new registrations come in via blocks this.isBitcoin = false; // Force registration store to be kept in same folder as other node data this.registrationStore.SetStorePath(this.nodeSettings.DataDir); } }
public RegistrationController(IRegistrationManager registrationManager) { Guard.NotNull(registrationManager, nameof(registrationManager)); _registrationManager = registrationManager; }
public FrontendUserManager(IUserStore <FrontendUser> store, IRegistrationManager registrationManger) : base(store) { this.registrationManger = registrationManger; }
internal LanguageClient(LanguageClientOptions options) : base(options) { _capabilities = options.SupportedCapabilities; _clientCapabilities = options.ClientCapabilities; var services = options.Services; services.AddLogging(builder => options.LoggingBuilderAction(builder)); options.RequestProcessIdentifier ??= (options.SupportsContentModified ? new RequestProcessIdentifier(RequestProcessType.Parallel) : new RequestProcessIdentifier(RequestProcessType.Serial)); // services.AddSingleton<IOptionsMonitor<LoggerFilterOptions>, LanguageClientLoggerFilterOptions>(); _clientInfo = options.ClientInfo; _receiver = options.Receiver; var serializer = options.Serializer; var supportedCapabilities = new SupportedCapabilities(); _textDocumentIdentifiers = new TextDocumentIdentifiers(); var collection = new SharedHandlerCollection(supportedCapabilities, _textDocumentIdentifiers); services.AddSingleton <IHandlersManager>(collection); _collection = collection; // _initializeDelegates = initializeDelegates; // _initializedDelegates = initializedDelegates; _startedDelegates = options.StartedDelegates; _rootUri = options.RootUri; _trace = options.Trace; _initializationOptions = options.InitializationOptions; services.AddSingleton <IOutputHandler>(_ => new OutputHandler(options.Output, options.Serializer, options.Receiver.ShouldFilterOutput, _.GetService <ILogger <OutputHandler> >())); services.AddSingleton(_collection); services.AddSingleton(_textDocumentIdentifiers); services.AddSingleton(serializer); services.AddSingleton <OmniSharp.Extensions.JsonRpc.ISerializer>(serializer); services.AddSingleton(options.RequestProcessIdentifier); services.AddSingleton <OmniSharp.Extensions.JsonRpc.IReceiver>(options.Receiver); services.AddSingleton(options.Receiver); services.AddSingleton <ILanguageClient>(this); services.AddSingleton <LspRequestRouter>(); services.AddSingleton <IRequestRouter <ILspHandlerDescriptor> >(_ => _.GetRequiredService <LspRequestRouter>()); services.AddSingleton <IRequestRouter <IHandlerDescriptor> >(_ => _.GetRequiredService <LspRequestRouter>()); services.AddSingleton <IResponseRouter, ResponseRouter>(); services.AddSingleton <IProgressManager, ProgressManager>(); services.AddSingleton(_ => _.GetRequiredService <IProgressManager>() as IJsonRpcHandler); services.AddSingleton <IClientWorkDoneManager, ClientWorkDoneManager>(); services.AddSingleton(_ => _.GetRequiredService <IClientWorkDoneManager>() as IJsonRpcHandler); EnsureAllHandlersAreRegistered(); services.AddSingleton <RegistrationManager>(); services.AddSingleton <IRegistrationManager>(_ => _.GetRequiredService <RegistrationManager>()); if (options.DynamicRegistration) { services.AddSingleton(_ => _.GetRequiredService <RegistrationManager>() as IJsonRpcHandler); } var workspaceFoldersManager = new WorkspaceFoldersManager(this); services.AddSingleton(workspaceFoldersManager); services.AddSingleton <IWorkspaceFoldersManager>(workspaceFoldersManager); if (options.WorkspaceFolders) { services.AddSingleton <IJsonRpcHandler>(workspaceFoldersManager); } var serviceProvider = services.BuildServiceProvider(); _disposable.Add(serviceProvider); _serviceProvider = serviceProvider; collection.SetServiceProvider(_serviceProvider); _responseRouter = _serviceProvider.GetRequiredService <IResponseRouter>(); _progressManager = _serviceProvider.GetRequiredService <IProgressManager>(); _workDoneManager = _serviceProvider.GetRequiredService <IClientWorkDoneManager>(); _registrationManager = _serviceProvider.GetRequiredService <RegistrationManager>(); _workspaceFoldersManager = _serviceProvider.GetRequiredService <IWorkspaceFoldersManager>(); _connection = new Connection( options.Input, _serviceProvider.GetRequiredService <IOutputHandler>(), options.Receiver, options.RequestProcessIdentifier, _serviceProvider.GetRequiredService <IRequestRouter <IHandlerDescriptor> >(), _responseRouter, _serviceProvider.GetRequiredService <ILoggerFactory>(), options.OnUnhandledException ?? (e => { }), options.CreateResponseException, options.MaximumRequestTimeout, options.SupportsContentModified, options.Concurrency ); // We need to at least create Window here in case any handler does loggin in their constructor TextDocument = new TextDocumentLanguageClient(this, _serviceProvider); Client = new ClientLanguageClient(this, _serviceProvider); General = new GeneralLanguageClient(this, _serviceProvider); Window = new WindowLanguageClient(this, _serviceProvider); Workspace = new WorkspaceLanguageClient(this, _serviceProvider); workspaceFoldersManager.Add(options.Folders); var serviceHandlers = _serviceProvider.GetServices <IJsonRpcHandler>().ToArray(); var serviceIdentifiers = _serviceProvider.GetServices <ITextDocumentIdentifier>().ToArray(); _disposable.Add(_textDocumentIdentifiers.Add(serviceIdentifiers)); _disposable.Add(_collection.Add(serviceHandlers)); options.AddLinks(_collection); }
public void RegisterWithResources(IRegistrationManager registrationManager) { //RegisterResources(); Register(registrationManager); }
//protected virtual void RegisterResources() //{ // try // { // Application.Current.Resources.MergedDictionaries.Add( // new ResourceDictionary // { // Source = // new Uri($@"pack://application:,,,/{GetType().Assembly};component/Resources.xaml") // }); // } // catch (Exception ex) // { // _log.Warn($"Failed to load Resource file for module {GetType().Assembly.FullName}", ex); // } //} public virtual void Register(IRegistrationManager registrationManager) { registrationManager.AutoRegisterAssembly(GetType().Assembly); }
public RegistrationController(IRegistrationManager registrationManager, ILogger <RegistrationController> logger) { this.registrationManager = registrationManager; this.logger = logger; }
public EarthquakeService() { earthquakeRepository = new EarthquakeRepository(new AplicationContextFactory()); registrationManager = new RegistrationManager(earthquakeRepository); }
public RegistrationController(IRegistrationManager registrationManager) { this.registrationManager = registrationManager; }
public RegistrationController(IRegistrationManager registrationManager, IUserAccountService userAccountService, IEmailService emailService) { _registrationManager = registrationManager; _userAccountService = userAccountService; _emailService = emailService; }
public RegistrationBlockObserver(ConcurrentChain chain, IRegistrationManager registrationManager) { this.chain = chain; this.registrationManager = registrationManager; }
public HomeController(IClassManager classManager, IUserManager userManager, IRegistrationManager registrationManager) { this.classManager = classManager; this.userManager = userManager; this.registrationManager = registrationManager; }