/// <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;
}
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());
}
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 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;
}
