public void can_log_failed_authentication() { var providerId = Guid.NewGuid(); const string providerName = "TestProvider"; const string ipAddress = "127.0.0.1"; var provider = new ExternalProvider( providerId, providerName, _command); provider.NotAuthenticatedInvalidCredentials(ipAddress); var events = provider.TakeEvents(); Assert.Collection( events, e => Assert.IsType <ExternalProviderMsgs.ProviderCreated>(e), e => { if (e is ExternalProviderMsgs.AuthenticationFailedInvalidCredentials failed) { Assert.Equal(providerId, failed.ProviderId); Assert.Equal(ipAddress, failed.HostIPAddress); } else { throw new Exception("wrong event."); } }); }
public void can_add_external_provider() { var providerId = Guid.NewGuid(); const string providerName = "TestProvider"; var provider = new ExternalProvider( providerId, providerName, _command); var events = provider.TakeEvents(); Assert.Collection( events, e => { if (e is ExternalProviderMsgs.ProviderCreated created) { Assert.Equal(providerId, created.ProviderId); Assert.Equal(providerName, created.ProviderName); } else { throw new Exception("wrong event."); } }); }
private static bool HandlerArgs(string[] args) { bool endApp = false; if (args.Length > 0) { Log.Notice("Program CLI", "App started as CLI with " + args.Length + " args"); for (int i = 0; i < args.Length; i++) { switch (args[i]) { case "--set-status": i++; if (i > args.Length) { throw new Exception("New status not found"); } string status = args[i]; endApp = true; ExternalProvider.WriteStatusFile(status); break; } } } return(endApp); }
private dynamic AuthorizeByExternalProvider(ProviderAndAccessToken model, ExternalProvider externalProvider) { IKernel kernel = Infrastructure.DependencyResolver.GetKernel(); IOauthProvider oauthProvider = kernel.Get <IOauthProvider>(externalProvider.ToString()); try { dynamic userData = oauthProvider.Authorize(model); userData.userName = userData.userData.userName.Replace(" ", ""); if (!userData.userName.ToString().Contains("@")) //google already adds @gmail.com to returned data so this should be optional. { userData.userName = userData.userName + "@" + externalProvider.ToString() + ".com"; } return(userData); } catch (Exception ex) { HttpContent contentPost = new StringContent("Facebook : " + ex.Message, Encoding.UTF8, "application/text"); var msg = new HttpResponseMessage(HttpStatusCode.Unauthorized) { Content = contentPost }; throw new HttpResponseException(msg); } }
private void SetKindName(ExternalProvider provider) { var hanlderType = _serializer.DeserializeType(provider.SerializedHandlerType); var optionsType = hanlderType.GetAuthenticationSchemeOptionsType(); provider.KindName = optionsType.Name.Replace("Options", ""); }
public static ExternalProvider GetExternalProviderImpl(string service) { ExternalProvider externalProviderImpl = null; if (GetGXServices() != null) { GXService providerService = GetGXServices().Get(service); if (providerService != null) { try { string typeFullName = providerService.ClassName; GXLogging.Debug(log, "Loading storage provider:", typeFullName); #if !NETCORE Type type = Type.GetType(typeFullName, true, true); #else Type type = new AssemblyLoader(FileUtil.GetStartupDirectory()).GetType(typeFullName); #endif externalProviderImpl = (ExternalProvider)Activator.CreateInstance(type); } catch (Exception e) { GXLogging.Error(log, "Couldn´t connect to external storage provider.", e.Message, e); throw e; } } } return(externalProviderImpl); }
public GxExternalFileInfo(string storageObjectFullname, ExternalProvider provider, GxFileType fileType) { storageObjectFullname = storageObjectFullname != null?storageObjectFullname.Replace('\\', '/') : storageObjectFullname; _name = storageObjectFullname; _provider = provider; Uri result; if (Uri.TryCreate(storageObjectFullname, UriKind.Absolute, out result) && result.IsAbsoluteUri) { _url = storageObjectFullname; } else { if (fileType.HasFlag(GxFileType.Attribute)) //Attributes multimedia consider Storage Provider Folder { _url = provider.GetBaseURL() + storageObjectFullname; _name = _url.Replace(provider.StorageUri, string.Empty); if (_name.StartsWith("/")) { _name = _name.Substring(1, _name.Length - 1); } } } _fileTypeAtt = fileType; }
public GxExternalFileInfo(string storageObjectFullname, string url, ExternalProvider provider, GxFileType fileType = GxFileType.Public) { _name = storageObjectFullname; _provider = provider; _url = url; _fileTypeAtt = fileType; }
public ExternalAccount(ExternalProvider provider, string name, string externalId, Guid profileId) { Provider = provider; Name = name; ExternalId = externalId; UserProfileId = profileId; }
public async Task <ExternalProvider> UpdateAsync(ExternalProvider entity, CancellationToken cancellationToken = default) { await _manager.UpdateAsync(CreateSchemeDefinition(entity), cancellationToken).ConfigureAwait(false); await _providerClient.ProviderUpdatedAsync(entity.Id, cancellationToken).ConfigureAwait(false); return(entity); }
public static ExternalProvider GetExternalProvider() { if (externalProvider == null) { externalProvider = GetExternalProviderImpl(GXServices.STORAGE_SERVICE); } return(externalProvider); }
public WsFederationOptionsValidator(ExternalProvider _, IStringLocalizer localizer) { RuleFor(m => m.MetadataAddress).NotEmpty().WithMessage(localizer["Metadata address is required."]); RuleFor(m => m.MetadataAddress).Uri().WithMessage(localizer["Metadata address must be a valid uri."]); RuleFor(m => m.MetadataAddress).Must((options, value) => !options.RequireHttpsMetadata || value.ToUpperInvariant().StartsWith("HTTPS")) .WithMessage(localizer["Metadata address must be a valid HTTPS url when 'required https metadata is true'."]); RuleFor(m => m.Wtrealm).NotEmpty().WithMessage(localizer["Wtrealm is required."]); }
protected void SignInWith(ExternalProvider provider) { if (!string.IsNullOrEmpty(ReturnUrl)) { ReturnUrl = Uri.EscapeDataString(ReturnUrl); } navigationManager.NavigateTo($"{navigationManager.BaseUri}api/externalauth/challenge/{provider.AuthenticationScheme}/{ReturnUrl}", true); }
public ExternalProviderCredentials(ExternalProvider type, string consumerKey, string consumerSecret) { if (string.IsNullOrWhiteSpace(consumerKey)) throw new ArgumentNullException("consumerKey"); if (string.IsNullOrWhiteSpace(consumerSecret)) throw new ArgumentNullException("consumerSecret"); Type = type; ConsumerKey = consumerKey; ConsumerSecret = consumerSecret; }
public OAuthOptionsValidator(ExternalProvider _, IStringLocalizer localizer) { RuleFor(m => m.ClientId).NotEmpty().WithMessage(localizer["Client Id is required."]); RuleFor(m => m.AuthorizationEndpoint).NotEmpty().WithMessage(localizer["Authorization endpoint is required."]); RuleFor(m => m.AuthorizationEndpoint).Uri().WithMessage(localizer["Authorization endpoint must be a valid uri."]); RuleFor(m => m.TokenEndpoint).NotEmpty().WithMessage(localizer["Token endpoint is required."]); RuleFor(m => m.TokenEndpoint).Uri().WithMessage(localizer["Token endpoint must be a valid uri."]); RuleFor(m => m.UserInformationEndpoint).NotEmpty().WithMessage(localizer["User information endpoint is required."]); RuleFor(m => m.UserInformationEndpoint).Uri().WithMessage(localizer["User information endpoint must be a valid uri."]); }
private TSchemeDefinition FromEntity(ExternalProvider entity) { var hanlderType = _serializer.DeserializeType(entity.SerializedHandlerType); return(new TSchemeDefinition { Scheme = entity.Id, DisplayName = entity.DisplayName, HandlerType = hanlderType, Options = _serializer.DeserializeOptions(entity.SerializedOptions, hanlderType.GetAuthenticationSchemeOptionsType()) }); }
private SchemeDefinition CreateSchemeDefinition(ExternalProvider entity) { var handlerType = _serializer.DeserializeType(entity.SerializedHandlerType); return(new() { DisplayName = entity.DisplayName, HandlerType = handlerType, Options = _serializer.DeserializeOptions(entity.SerializedOptions, handlerType.GetAuthenticationSchemeOptionsType()), Scheme = entity.Id }); }
public async Task Subscribe_should_subcribe_to_hub_events() { var waitHandle = new ManualResetEvent(false); var configuration = new Dictionary <string, string> { ["ApiAuthentication:Authority"] = "http://localhost", ["SignalR:HubUrl"] = "http://localhost/providerhub", ["SignalR:UseMessagePack"] = "false" }; TestServer server = null; server = TestUtils.CreateTestServer(services => { services.RemoveAll <HubHttpMessageHandlerAccessor>(); services.AddTransient(p => new HubHttpMessageHandlerAccessor { Handler = new MockHttpMessageHandler(waitHandle, server.CreateHandler()) }); services.RemoveAll <HttpClient>(); services.AddTransient(p => server.CreateClient()); services.RemoveAll <HttpClientHandler>(); services.AddTransient <HttpClientHandler>(p => new MockHttpClientHandler(p.GetRequiredService <HttpClient>())); }, configuration); server.CreateWebSocketClient(); Assert.True(waitHandle.WaitOne(5000)); var provider = server.Host.Services; var store = provider.GetRequiredService <IAdminStore <ExternalProvider> >(); var serializer = provider.GetRequiredService <IAuthenticationSchemeOptionsSerializer>(); var extProvider = new ExternalProvider { DisplayName = "Google", Id = "google", KindName = "Google", SerializedHandlerType = serializer.SerializeType(typeof(GoogleHandler)), SerializedOptions = serializer.SerializeOptions(new GoogleOptions(), typeof(GoogleOptions)) }; provider.GetRequiredService <IConfiguration>()["SignalR:HubUrl"] = null; await store.CreateAsync(extProvider).ConfigureAwait(false); await store.UpdateAsync(extProvider).ConfigureAwait(false); await store.DeleteAsync("google").ConfigureAwait(false); await Task.Delay(1000).ConfigureAwait(false); }
public static void Start() { Log.Debug("App", "App is starting"); ExternalProvider.RegisterHost(); Started = true; FirstTime = true; Waiting = false; Stopping = false; Aborting = false; InitStatus = null; LastSong = null; Task t = Task.Run(Run); }
public IHttpActionResult ExternalLogin(string provider, string error = null) { if (error != null) { return(BadRequest(Uri.EscapeDataString(error))); } if (!User.Identity.IsAuthenticated) { return(new ExternalAuthenticationChallengeResult(provider, this)); } string redirectUri; bool isValidUri = CommonValidations.TryParseRedirectUri(Request, out redirectUri); if (isValidUri == false) { if (string.IsNullOrEmpty(redirectUri)) { return(BadRequest("Invalid redirect URI(redirect_uri).")); } return(BadRequest(redirectUri)); } try { ExternalData externalLoginData = new ExternalData(User.Identity as ClaimsIdentity); if (externalLoginData == null) { return(InternalServerError()); } if (externalLoginData.LoginProvider != provider) { ExternalProvider.SignOut(Request, DefaultAuthenticationTypes.ExternalCookie); return(new ExternalAuthenticationChallengeResult(provider, this)); } externalLoginData.LocalBearerToken = GenerateLocalAccessTokenResponse(User.Identity as ClaimsIdentity); redirectUri = ExternalProvider.GetCompleteRedirectUri(redirectUri, externalLoginData); return(Redirect(redirectUri)); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
public static object Resolve(Type type, ConstructorArgument[] parameters = null) { IKernel provider = null; if ((bool)InternalProvider.CanResolve(type)) { provider = InternalProvider; } else if ((bool)ExternalProvider.CanResolve(type)) { provider = ExternalProvider; } return(Resolve(provider, type, parameters)); }
public static T Resolve <T>(ConstructorArgument[] parameters = null) { IKernel provider = null; if (InternalProvider.CanResolve <T>()) { provider = InternalProvider; } else if ((ExternalProvider != null) && (ExternalProvider.CanResolve <T>())) { provider = ExternalProvider; } return((T)(Resolve(provider, typeof(T), parameters))); }
public ExternalProviderCredentials(ExternalProvider type, string consumerKey, string consumerSecret) { if (string.IsNullOrWhiteSpace(consumerKey)) { throw new ArgumentNullException("consumerKey"); } if (string.IsNullOrWhiteSpace(consumerSecret)) { throw new ArgumentNullException("consumerSecret"); } Type = type; ConsumerKey = consumerKey; ConsumerSecret = consumerSecret; }
public static ExternalProvider GetExternalProviderFromUrl(string url, out string objectName) { objectName = null; ExternalProvider provider = ServiceFactory.GetExternalProvider(); if (provider != null) { if (provider.GetObjectNameFromURL(url, out objectName)) { var questionMarkIndex = objectName.IndexOf(QUESTION_MARK); objectName = questionMarkIndex >= 0 ? objectName.Substring(0, questionMarkIndex): objectName.Substring(0); return(provider); } } return(null); }
public async Task <IActionResult> SignIn([FromBody] ExternalProvider provider) { if (provider == null || string.IsNullOrWhiteSpace(provider.Name)) { return(BadRequest()); } if (!await HttpContext.IsProviderSupportedAsync(provider.Name)) { return(BadRequest()); } return(Challenge(new AuthenticationProperties { RedirectUri = "/" }, provider.Name)); }
public GoogleOptionsValidator(ExternalProvider _, IStringLocalizer localizer) { RuleFor(m => m.ClientId).NotEmpty().WithMessage(localizer["Client Id is required."]); RuleFor(m => m.ClientSecret).NotEmpty().WithMessage(localizer["Client Secret is required."]); }
public FacebookOptionsValidator(ExternalProvider _) { RuleFor(m => m.AppId).NotEmpty().WithMessage("Client Id is required."); RuleFor(m => m.AppSecret).NotEmpty().WithMessage("Client Secret is required."); }
public async Task <ServiceResult <ConnectionDetail> > GetConnection(Guid userId, ExternalProvider provider) { var result = new ServiceResult <ConnectionDetail>(); var connection = await context.ExternalAccount.FirstOrDefaultAsync(ea => ea.UserProfileId.Equals(userId) && ea.Provider.Equals(provider)); if (connection == null) { result.Error = Shared.ErrorKey.UserProfile.ExternalAccountNotFound; return(result); } result.Succeed(AutoMapper.Mapper.Map <ConnectionDetail>(connection)); return(result); }
public WrapProvider(ExternalProvider provider) { Id = provider.Id; DisplayName = provider.DisplayName; KindName = provider.KindName; }
public bool TryGetExternalAccount(ExternalProvider provider, out ExternalAccount account) { account = this.ExternalAccounts.FirstOrDefault(ea => ea.Provider == provider); return(account != null); }
public ExternalAccount GetExternalAccount(ExternalProvider provider) { return(this.ExternalAccounts.FirstOrDefault(ea => ea.Provider == provider)); }
public SocialProvider this[ExternalProvider type] { get { return (SocialProvider) BaseGet(type); } }