public AuthenticationManagerTest() { this.provider = Substitute.For<AuthenticationProvider>(); this.user = Substitute.For<User>("John", false); this.user.Name.Returns("John"); }
public async Task<string> AuthenticateAsync(AuthenticationProvider provider) #endif { #if ANDROID var user = await this.mobileService.LoginAsync(context, ToMobileServiceProvider(provider)); #else var user = await this.mobileService.LoginAsync(ToMobileServiceProvider(provider)); #endif return user.UserId; }
public void MakeRequest(HttpVerb method, string url, HeaderProvider header, AuthenticationProvider auth, BodyProvider body) { this.method = method; this.url = url; this.headers = header; this.auth = auth; this.body = body; this.MakeRequest(); }
public Task<string> AuthenticateAsync(AuthenticationProvider provider) { if (AuthenticateWithProviderDelegate != null) { return Task.FromResult<string>(AuthenticateWithProviderDelegate(provider)); } else { return Task.FromResult<string>(null); } }
public StackItConfiguration( AuthenticationProvider authenticationProvider, ICrowdConfiguration crowdConfiguration, IQueueingConfiguration queueingConfiguration, ICloudOptions cloudOptions, IList<IInstanceTypeConfiguration> instanceTypeConfigurations, IPuppetConfiguration puppetConfiguration ) { AuthenticationProvider = authenticationProvider; CrowdConfiguration = crowdConfiguration; QueueingConfiguration = queueingConfiguration; CloudOptions = cloudOptions; InstanceTypes = instanceTypeConfigurations; PuppetConfiguration = puppetConfiguration; }
public UserState(User user, AuthenticationProvider provider) { Id = user.Id; UserName = user.UserName; Role = user.Role; Guid = user.Guid; TimeZone = user.TimeZone; ExternalProfileUrl = user.ExternalProfileUrl; Email = user.Email; Warned = user.Warned; ProviderInfo = new ProviderInfo() { Provider = provider, AllowChangeEmail = true }; }
public void Login_UserIsLoggedIn_ShouldReturnTrue(FakeMembershipUser user, AuthenticationProvider authenticationProvider, AccountRepository repo) { authenticationProvider.Login(@"somedomain\John", Arg.Any <string>(), Arg.Any <bool>()).Returns(true); var context = new FakeSiteContext(new StringDictionary { { "domain", "somedomain" } }); using (new Switcher <Domain, Domain>(new Domain("somedomain"))) { using (new AuthenticationSwitcher(authenticationProvider)) { var loginResult = repo.Login("John", "somepassword"); loginResult.Should().BeTrue(); } } }
public void SetUp() { _bus = new InMemoryBus(string.Format("bus_{0}", _serverEndPoint.Port)); { var pipelineBus = InMemoryBus.CreateTest(); var queue = new QueuedHandlerThreadPool(pipelineBus, "Test", true, TimeSpan.FromMilliseconds(50)); _multiQueuedHandler = new MultiQueuedHandler(new IQueuedHandler[] { queue }, null); var authenticationProviders = new AuthenticationProvider[] { new AnonymousAuthenticationProvider() }; _service = new HttpService(ServiceAccessibility.Private, _bus, new NaiveUriRouter(), _multiQueuedHandler, _serverEndPoint.ToHttpUrl()); HttpService.CreateAndSubscribePipeline(pipelineBus, authenticationProviders); _client = new HttpAsyncClient(); } HttpBootstrap.Subscribe(_bus, _service); }
public void TestIsInRole_UserIdIsNull_ShouldReturnFalse(string role) { //Arrange var mockedUserStore = new Mock <IUserStore <User> >(); var mockedUserManager = new Mock <ApplicationUserManager>(mockedUserStore.Object); var mockedHttpContextProvider = new Mock <IHttpContextProvider>(); mockedHttpContextProvider.Setup(p => p.GetUserManager <ApplicationUserManager>()).Returns(mockedUserManager.Object); var provider = new AuthenticationProvider(mockedHttpContextProvider.Object); //Act var result = provider.IsInRole(null, role); //Assert Assert.IsFalse(result); }
public void TestIsInRole_ShouldCallUserManagerIsInRole(string userId, string role) { //Arrange var mockedUserStore = new Mock <IUserStore <User> >(); var mockedUserManager = new Mock <ApplicationUserManager>(mockedUserStore.Object); var mockedHttpContextProvider = new Mock <IHttpContextProvider>(); mockedHttpContextProvider.Setup(p => p.GetUserManager <ApplicationUserManager>()).Returns(mockedUserManager.Object); var provider = new AuthenticationProvider(mockedHttpContextProvider.Object); //Act provider.IsInRole(userId, role); //Assert mockedUserManager.Verify(m => m.IsInRoleAsync(userId, role), Times.Once); }
public void Should_Set_ThrowExceptionIfBuildCouldNotBeFound(bool value) { // Given var collectionUrl = new Uri("http://example.com/collection"); var projectName = "MyProject"; var buildId = 42; var credentials = AuthenticationProvider.AuthenticationNtlm(); var settings = new AzureDevOpsBuildSettings(collectionUrl, projectName, buildId, credentials) { ThrowExceptionIfBuildCouldNotBeFound = value, }; // When var result = new AzureDevOpsBuildSettings(settings); // Then result.ThrowExceptionIfBuildCouldNotBeFound.ShouldBe(value); }
public void Should_Throw_If_RepositoryUrl_Is_Null() { // Given Uri repositoryUrl = null; var sourceRefName = "foo"; var targetRefName = "master"; var title = "foo"; var description = "bar"; var credentials = AuthenticationProvider.AuthenticationNtlm(); // When var result = Record.Exception(() => new AzureDevOpsCreatePullRequestSettings(repositoryUrl, sourceRefName, targetRefName, title, description, credentials)); // Then result.IsArgumentNullException("repositoryUrl"); }
private async Task AuthenticateAndGo(AuthenticationProvider provider) { var result = await Authenticate(provider); if (result.Error != null) { if (result.Error.HResult != -2146233079) // Cancelled by user { await this.messageBox.ShowAsync("Error authenticating.", "Error"); } } else { this.appSettings.Add(SettingsKeys.ProfileId, result.UserId); await LoadIdentityAndGo(result.UserId); } }
public void Should_Throw_If_Title_Is_WhiteSpace() { // Given var repositoryUrl = new Uri("http://example.com"); var sourceRefName = "foo"; var targetRefName = "master"; var title = " "; var description = "bar"; var credentials = AuthenticationProvider.AuthenticationNtlm(); // When var result = Record.Exception(() => new TfsCreatePullRequestSettings(repositoryUrl, sourceRefName, targetRefName, title, description, credentials)); // Then result.IsArgumentOutOfRangeException("title"); }
private static MobileServiceAuthenticationProvider ToMobileServiceProvider(AuthenticationProvider provider) { switch (provider) { case AuthenticationProvider.Facebook: return(MobileServiceAuthenticationProvider.Facebook); case AuthenticationProvider.Google: return(MobileServiceAuthenticationProvider.Google); case AuthenticationProvider.Twitter: return(MobileServiceAuthenticationProvider.Twitter); case AuthenticationProvider.Microsoft: default: return(MobileServiceAuthenticationProvider.MicrosoftAccount); } }
public void Should_Throw_If_Description_Is_Null() { // Given var repositoryUrl = new Uri("http://example.com"); var sourceRefName = "foo"; var targetRefName = "master"; var title = "foo"; string description = null; var credentials = AuthenticationProvider.AuthenticationNtlm(); // When var result = Record.Exception(() => new TfsCreatePullRequestSettings(repositoryUrl, sourceRefName, targetRefName, title, description, credentials)); // Then result.IsArgumentNullException("description"); }
public void User_is_fetched_when_user_is_authenticated() { // arrange new AuthenticationInstaller().Install(); var authentication = TinyIoCContainer.Current.Resolve <IAuthentication>(); var repo = new Mock <IRepository <User> >(); repo.Setup(x => x.Get("foo")).Returns(new User()); var authenticationProvider = new AuthenticationProvider(authentication, repo.Object); // act authenticationProvider.Login("foo", "bar"); // assert repo.Verify(x => x.Get("foo"), Times.Once); }
private static MobileServiceAuthenticationProvider ToMobileServiceProvider(AuthenticationProvider provider) { switch (provider) { case AuthenticationProvider.Facebook: return MobileServiceAuthenticationProvider.Facebook; case AuthenticationProvider.Google: return MobileServiceAuthenticationProvider.Google; case AuthenticationProvider.Twitter: return MobileServiceAuthenticationProvider.Twitter; case AuthenticationProvider.Microsoft: default: return MobileServiceAuthenticationProvider.MicrosoftAccount; } }
/// <summary> /// Decrypts the specified data. /// </summary> /// <param name="data">The data.</param> /// <param name="parameters">The parameters.</param> /// <returns></returns> public ISnmpData Decrypt(ISnmpData data, SecurityParameters parameters) { if (data == null) { throw new ArgumentNullException(nameof(data)); } if (parameters == null) { throw new ArgumentNullException(nameof(parameters)); } var code = data.TypeCode; if (code != SnmpType.OctetString) { throw new ArgumentException($"Cannot decrypt the scope data: {code}.", nameof(data)); } var octets = (OctetString)data; var bytes = octets.GetRaw(); var pkey = AuthenticationProvider.PasswordToKey(_phrase.GetRaw(), parameters.EngineId.GetRaw()); try { // decode encrypted packet var decrypted = Decrypt(bytes, pkey, parameters.PrivacyParameters.GetRaw()); var result = DataFactory.CreateSnmpData(decrypted); if (result.TypeCode != SnmpType.Sequence) { var newException = new DecryptionException("DES decryption failed"); newException.SetBytes(bytes); throw newException; } return(result); } catch (Exception ex) { var newException = new DecryptionException("DES decryption failed", ex); newException.SetBytes(bytes); throw newException; } }
public void InitView(Int32 idPerson, dtoExpiredAccessUrl expiredInfo) { Person person = null; if (idPerson > 0) { person = CurrentManager.GetPerson(idPerson); } View.WriteLogonCookies(expiredInfo); if (person == null) { View.GoToDefaultPage(); } else { List <AuthenticationProvider> providers = ProfileService.GetUserAuthenticationProviders(person); if (providers.Count == 0 || person.IdDefaultProvider == 0 || !providers.Where(p => p.Id == person.IdDefaultProvider).Any()) { //if (person.AuthenticationTypeID != 1) // View.LoadOldAuthenticationPage(person.AuthenticationTypeID); //else View.GoToDefaultPage(); } else { AuthenticationProvider provider = providers.Where(p => p.Id == person.IdDefaultProvider).FirstOrDefault(); switch (provider.ProviderType) { case AuthenticationProviderType.Internal: View.LoadInternalLoginPage(); break; case AuthenticationProviderType.Url: UrlAuthenticationProvider urlProvider = (UrlAuthenticationProvider)provider; View.LoadExternalProviderPage(urlProvider.RemoteLoginUrl); break; default: View.GoToDefaultPage(); break; } } } }
public User Authenticate(AuthenticationProvider provider, string id, string name, string lastName, string image) { User user; bool isNewUser = false; switch (provider) { case AuthenticationProvider.Facebook: user = Data.Users.FirstOrDefault(x => x.FacebookLogin == id); if (user == null) { isNewUser = true; user = new User(); } user.FacebookLogin = id; break; case AuthenticationProvider.Google: user = Data.Users.FirstOrDefault(x => x.GoogleLogin == id); if (user == null) { isNewUser = true; user = new User(); } user.GoogleLogin = id; break; case AuthenticationProvider.Vk: user = Data.Users.FirstOrDefault(x => x.VkLogin == id); if (user == null) { isNewUser = true; user = new User(); } user.VkLogin = id; break; default: return null; } user.Name = name; user.LastName = lastName; user.Image = image; if (isNewUser) Data.Users.Add(user); Data.SaveChanges(); return user; }
public virtual ProfilerError VerifyDuplicateExternalLoginInfo(Person person, AuthenticationProvider provider, dtoExternalCredentials credentials) { var query = (from ei in Manager.GetIQ <ExternalLoginInfo>() where ei.Deleted == BaseStatusDeleted.None && ei.Provider == provider && ei.Person != null && ei.Person != person select ei); if ((provider.IdentifierFields & IdentifierField.longField) > 0 && query.Where(ei => ei.IdExternalLong == credentials.IdentifierLong).Any()) { return(ProfilerError.externalUniqueIDduplicate); } else if ((provider.IdentifierFields & IdentifierField.stringField) > 0) { List <String> multipleIdentifiers = null; if (provider.MultipleItemsForRecord && !string.IsNullOrEmpty(provider.MultipleItemsSeparator)) { multipleIdentifiers = credentials.IdentifierString.Split(provider.MultipleItemsSeparator.ToArray(), StringSplitOptions.RemoveEmptyEntries).ToList(); List <ExternalLoginInfo> items = new List <ExternalLoginInfo>(); foreach (String idn in multipleIdentifiers) { items.AddRange(query.Where(q => q.IdExternalString.Contains(idn)).ToList()); } if ((provider.IdentifierFields & IdentifierField.longField) > 0) { items = items.Where(i => i.IdExternalLong == credentials.IdentifierLong).ToList(); } Boolean found = false; foreach (ExternalLoginInfo item in items) { found = item.IdExternalString.Split(provider.MultipleItemsSeparator.ToArray(), StringSplitOptions.RemoveEmptyEntries).ToList().Where(v => multipleIdentifiers.Contains(v)).Any(); if (found) { break; } } return((found) ? ProfilerError.externalUniqueIDduplicate : ProfilerError.none); } else { return((query.Where(ei => ei.IdExternalString == credentials.IdentifierString).Any()) ? ProfilerError.externalUniqueIDduplicate : ProfilerError.none); } } else { return(ProfilerError.none); } }
/// <summary> /// Decrypts the specified data. /// </summary> /// <param name="data">The data.</param> /// <param name="parameters">The parameters.</param> /// <returns></returns> public ISnmpData Decrypt(EndPoint sourceEndPoint, ISnmpData data, SecurityParameters parameters) { if (data == null) { throw new ArgumentNullException("data"); } if (parameters == null) { throw new ArgumentNullException("parameters"); } var code = data.TypeCode; if (code != SnmpType.OctetString) { throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "cannot decrypt the scope data: {0}", code), "data"); } var octets = (OctetString)data; var bytes = octets.GetRaw(); var pkey = AuthenticationProvider.PasswordToKey(_phrase.GetRaw(), parameters.EngineId.GetRaw()); try { // decode encrypted packet var decrypted = Decrypt(bytes, pkey, parameters.PrivacyParameters.GetRaw()); var result = DataFactory.CreateSnmpData(sourceEndPoint, decrypted); if (result.TypeCode != SnmpType.Sequence) { var newException = new DecryptionException("DES decryption failed"); newException.SetBytes(bytes); throw newException; } return(result); } catch (Exception ex) { var newException = new DecryptionException("DES decryption failed", ex); newException.SetBytes(bytes); throw newException; } }
public void TestIsAuthenticated_ShouldReturnCorrectly(bool isAuthenticated) { //Arrange var mockedIdentity = new Mock <IIdentity>(); mockedIdentity.Setup(i => i.IsAuthenticated).Returns(isAuthenticated); var mockedHttpContextProvider = new Mock <IHttpContextProvider>(); mockedHttpContextProvider.Setup(p => p.CurrentIdentity).Returns(mockedIdentity.Object); var provider = new AuthenticationProvider(mockedHttpContextProvider.Object); //Act var result = provider.IsAuthenticated; //Assert Assert.AreEqual(isAuthenticated, result); }
public SettingsView() { this.InitializeComponent(); if (App.CurrentUser != null) { txtResults.Text = "Welcome " + App.CurrentUser.GivenName; } else { txtResults.Text = "Welcome, please select an option below and sign in when prompted"; btnSignOutTip.IsEnabled = false; } DataContext = ViewModel; // Get the Authentication Provider authProvider = App.GetAuthenticationProvider(); }
public ChangePinResponse ChangePin(ChangePinRequest externalRequest) { Log(Logger.LogMessageType.Info, "-> -------------------- Comienza la ejecución del método Registration.ChangePin", Logger.LoggingLevelType.Medium); ChangePinResponse response = null; try { Log(Logger.LogMessageType.Info, String.Format("Llamando a AgentRegistration.ChangePin con los parametros: SessionID={0}, DeviceType={1}, Initiator={2}", externalRequest.Request.SessionID, externalRequest.Request.DeviceType, externalRequest.Request.Initiator), Logger.LoggingLevelType.Low); response = AuthenticationProvider.ChangePin(externalRequest); Log(Logger.LogMessageType.Info, String.Format("Parametros de respuesta de AgentRegistration.ChangePin: ResponseCode={0}, ResponseMessage={1}, TransactionID={2}", response.Response.ResponseCode, response.Response.ResponseMessage, response.Response.TransactionID), Logger.LoggingLevelType.Low); } catch (Exception e) { Log(Logger.LogMessageType.Error, "Excepcion en el metodo AgentRegistration.ChangePin: " + e.ToString(), Logger.LoggingLevelType.Low); } Log(Logger.LogMessageType.Info, "-> -------------------- Termina la ejecución del método Registration.ChangePin", Logger.LoggingLevelType.Medium); return(response); }
public static IAuthenticationClient CreateClient(AuthenticationProvider provider) { switch (provider) { case AuthenticationProvider.Twitter: return(new TwitterClient(AppConfig.TwitterConsumerKey, AppConfig.TwitterConsumerSecret)); case AuthenticationProvider.Google: return(new GoogleOpenIdClient()); case AuthenticationProvider.Facebook: return(new FacebookClient(AppConfig.FacebookAppId, AppConfig.FacebookAppSecret)); case AuthenticationProvider.Yahoo: return(new YahooOpenIdClient()); } return(null); }
public async Task <LogOnInfo> Connect(string name, string password) { _connection = await AuthenticationProvider.Connect(name, password); if (TraceWriter != null) { _connection.TraceWriter = TraceWriter; } _connection.TraceLevel = TraceLevel; _chat = _connection.CreateHubProxy("chat"); SubscribeToEvents(); await _connection.Start(_transportFactory()); return(await LogOn()); }
public void TestIsAuthenticated_ShouldCallHttpContextProviderCurrentIdentity() { // Arrange var mockedDateTimeProvider = new Mock <IDateTimeProvider>(); var mockedIdentity = new Mock <IIdentity>(); var mockedHttpContextProvider = new Mock <IHttpContextProvider>(); mockedHttpContextProvider.Setup(p => p.CurrentIdentity).Returns(mockedIdentity.Object); var provider = new AuthenticationProvider(mockedDateTimeProvider.Object, mockedHttpContextProvider.Object); // Act var result = provider.IsAuthenticated; // Assert mockedHttpContextProvider.Verify(p => p.CurrentIdentity, Times.Once); }
public void Login(AuthenticationProvider provider, string ServerAddress, string token, Action <string, WWW> callback_success, Action <string, WWW> callback_error) { var path = ".auth/login/" + provider.ToString().ToLower(); AuthenticationToken authToken = CreateToken(provider, token); var json = JsonParser.Write(authToken); print(json); Callback_Success = callback_success; Callback_Error = callback_error; WWWHelper helper = WWWHelper.Instance; helper.OnHttpRequest += OnHttpRequest; helper.POST("Login", ServerAddress + path, json); }
public void Login(AuthenticationProvider provider, string ServerAddress, string token, Action <string, WWW> callback_success, Action <string, WWW> callback_error) { var path = ".auth/login/" + provider.ToString().ToLower(); AuthenticationToken authToken = CreateToken(provider, token); string json = JsonUtility.ToJson(authToken); print(json); Callback_Success = callback_success; Callback_Error = callback_error; var HeaderDic = AzureMobileAppRequestHelper.getHeader(); WWW www = new WWW(ServerAddress + path, Encoding.UTF8.GetBytes(json), HeaderDic); StartCoroutine(WaitForRequest("aa", www)); }
public void ChangeIdentityProvider(Dropdown dropdown) { if (dropdown == null) { Debug.LogWarning("Unity missing connection to dropdown element"); return; } identityProvider = (AuthenticationProvider)dropdown.value; if (identityProvider.Equals(AuthenticationProvider.Twitter) || identityProvider.Equals(AuthenticationProvider.Google)) { inputUserSecret.placeholder.GetComponent <Text>().text = identityProvider.Equals(AuthenticationProvider.Twitter) ? "Enter access token secret..." : "Enter id token..."; inputUserSecret.gameObject.SetActive(true); } else { inputUserSecret.gameObject.SetActive(false); } }
private async Task AuthenticateAndGo(AuthenticationProvider provider) { var result = await Authenticate(provider); if (result.Error != null) { #if WINDOWS_PHONE this.messageBox.Show("There was an error authenticating.", "Error"); #else //await this.messageBox.ShowAsync("Error authenticating.", "Error"); #endif // WINDOWS_PHONE } else { //this.appSettings.Add(SettingsKeys.ProfileId, result.UserId); await LoadIdentityAndGo(result.UserId); } }
public bool ValidateToken(int userId, string token) { var user = Users[userId]; if (user == null) { return(false); } var now = SystemDateTime.Now; var tokenApiSession = TokenApiSessions.Where(x => x.ExpiredDateTime >= now && x.Token == token && x.UserId == userId) .FirstOrDefault(); if (tokenApiSession != null) { AuthenticationProvider.RegenerateApiTokenUser(tokenApiSession); return(true); } return(false); }
/// <summary> /// Initialize the instance. /// </summary> /// <param name="service">Service instance.</param> /// <param name="logger">Graph logger.</param> internal void Initialize(IGraphLogger logger) { Validator.IsNull(this.Logger, "Multiple initializations are not allowed."); this.Logger = logger; //this.Observer = new SampleObserver(logger); var name = "xyz"; //this.GetType().Assembly.GetName().Name; var builder = new CommunicationsClientBuilder( name, "90f613f2-ccda-4594-b0b6-e456aad1e070", this.Logger); var authProvider = new AuthenticationProvider( name, "90f613f2-ccda-4594-b0b6-e456aad1e070", "3PP0i2dfUCr8Qz4Nu.1tIS_o~iFD7~47ko", this.Logger); X509Certificate2 defaultCertificate = this.GetCertificateFromStore(); builder.SetAuthenticationProvider(authProvider); builder.SetNotificationUrl(new Uri("https://1106ba09f44b.ngrok.io/api/JoinCall")); builder.SetMediaPlatformSettings(new MediaPlatformSettings() { MediaPlatformInstanceSettings = new MediaPlatformInstanceSettings() { CertificateThumbprint = defaultCertificate.Thumbprint, InstanceInternalPort = 8445, InstancePublicIPAddress = IPAddress.Any, InstancePublicPort = 18003, ServiceFqdn = "0.bot.contoso.com", }, ApplicationId = Guid.NewGuid().ToString() }); builder.SetServiceBaseUrl(new System.Uri("https://graph.microsoft.com/beta")); this.Client = builder.Build(); //this.Client.Calls().OnIncoming += this.CallsOnIncoming; //this.Client.Calls().OnUpdated += this.CallsOnUpdated; this.OnlineMeetings = new OnlineMeetingHelper(authProvider, new System.Uri("https://graph.microsoft.com/v1.0")); }
/// <summary> /// Initialize the instance. /// </summary> /// <param name="service">Service instance.</param> /// <param name="logger">Graph logger.</param> internal void Initialize(IGraphLogger logger) { Validator.IsNull(this.Logger, "Multiple initializations are not allowed."); this.Logger = logger; //this.Observer = new SampleObserver(logger); var name = this.GetType().Assembly.GetName().Name; var builder = new CommunicationsClientBuilder( "tryoutbot", "fc6d5524-ee41-42fd-95d3-e7e448ff4732", this.Logger); var authProvider = new AuthenticationProvider( name, "fc6d5524-ee41-42fd-95d3-e7e448ff4732", "~Om8rorxCVxw~a2_r.iG30t30OWHqdA~VC", this.Logger); X509Certificate2 defaultCertificate = this.GetCertificateFromStore(); builder.SetAuthenticationProvider(authProvider); builder.SetNotificationUrl(new Uri("https://1106ba09f44b.ngrok.io/api/calling")); builder.SetMediaPlatformSettings(new MediaPlatformSettings() { MediaPlatformInstanceSettings = new MediaPlatformInstanceSettings() { CertificateThumbprint = defaultCertificate.Thumbprint, InstanceInternalPort = 8445, InstancePublicIPAddress = new IPAddress(0x0), InstancePublicPort = 12634, ServiceFqdn = "0.tcp.ngrok.io", //"0.bot.contoso.com", }, ApplicationId = "fc6d5524-ee41-42fd-95d3-e7e448ff4732" }); builder.SetServiceBaseUrl(new System.Uri("https://graph.microsoft.com/v1.0")); this.Client = builder.Build(); this.Client.Calls().OnIncoming += this.CallsOnIncoming; this.Client.Calls().OnUpdated += this.CallsOnUpdated; this.OnlineMeetings = new OnlineMeetingHelper(authProvider, new System.Uri("https://graph.microsoft.com")); }
/// <summary> /// Creates the user in the database. avoid conflicts we append the name of the provider /// Ex: Twitter-UserName /// </summary> /// <param name="screenName">screen name returned by provider</param> /// <param name="authprovider"></param> public UserDetails CreateUserIfNew(string screenName, AuthenticationProvider authprovider) { string username = authprovider.ToString() + "-" + screenName; using (var db = new AppContext()) { var details = db.Users.Where(u => u.UserName == username).FirstOrDefault(); if (details == null) { details = new UserDetails() { Id = Guid.NewGuid(), UserName = username }; db.Users.Add(details); db.SaveChanges(); } return details; } }
/// <summary> /// Autentica la identidad del usuario y obtiene sus datos. /// </summary> /// <param name="loginClaims">Diccionario con los elementos probatorios de la identidad del usuario</param> /// <param name="setContext">Especifica si se debe crear el contexto de seguridad (Principal)</param> /// <returns>Identidad del usuario</returns> public static NucleoIdentity LogIn(Dictionary <string, object> loginClaims, bool setContext) { try { var userClaims = AuthenticationProvider.Authenticate(new ClaimDictionary(loginClaims)); var identity = new NucleoIdentity(userClaims); if (setContext) { SetPrincipalToContext(new NucleoPrincipal(identity)); } return(identity); } catch (Exception ex) { ExceptionPolicy.HandleException(ex, Defaults.DefaultExceptionPolicy); throw ex; } }
/// <summary> /// Tworzy dostawcę autentykacji /// </summary> /// <param name="authProvider">Typ dostawcy autentykacji</param> /// <returns>Dostawca autentykacji</returns> public virtual IOAuthProvider CreateProvider(AuthenticationProvider authProvider) { IOAuthProvider provider = null; switch (authProvider) { case AuthenticationProvider.Google: provider = new GoogleAuthentication(); break; case AuthenticationProvider.Microsoft: provider = new MicrosoftAuthentication(); break; default: break; } return(provider); }
public RegistryClient(RegistryClientConfiguration configuration, AuthenticationProvider authenticationProvider) { if (configuration == null) { throw new ArgumentNullException(nameof(configuration)); } if (authenticationProvider == null) { throw new ArgumentNullException(nameof(authenticationProvider)); } _client = new NetworkClient(configuration, authenticationProvider); Manifest = new ManifestOperations(_client); Catalog = new CatalogOperations(_client); Blobs = new BlobOperations(_client); BlobUploads = new BlobUploadOperations(_client); System = new SystemOperations(_client); Tags = new TagOperations(_client); }
public User AddUser(User user, AuthenticationProvider provider, string providerId) { DbCommand comm = GetCommand("SPUsersInsertFromProvider"); comm.AddParameter<string>(this.Factory, "UserName", user.UserName); comm.AddParameter<string>(this.Factory, "UserProfile", user.Profile); comm.AddParameter<string>(this.Factory, "UserSignature", user.Signature); comm.AddParameter<short>(this.Factory, "UserGroupId", (short)user.Role); comm.AddParameter(this.Factory, "UserBirthDate", DbType.DateTime, user.BirthDate); comm.AddParameter<string>(this.Factory, "UserWebsite", user.Website); comm.AddParameter<Guid>(this.Factory, "UserGuid", Guid.NewGuid()); comm.AddParameter<decimal>(this.Factory, "UserTimezone", (decimal)user.TimeZone.TotalHours); comm.AddParameter(this.Factory, "UserEmail", DbType.String, string.IsNullOrWhiteSpace(user.Email) ? null : user.Email); comm.AddParameter(this.Factory, "UserEmailPolicy", DbType.Int32, null); comm.AddParameter<string>(this.Factory, "UserPhoto", user.Photo); comm.AddParameter<string>(this.Factory, "UserExternalProfileUrl", user.ExternalProfileUrl); comm.AddParameter<string>(this.Factory, "UserProvider", provider.ToString().ToUpper()); comm.AddParameter<string>(this.Factory, "UserProviderId", providerId.ToUpper()); DataRow dr = GetFirstRow(comm); user = ParseUserLoginInfo(dr); return user; }
public User GetByProviderId(AuthenticationProvider provider, string providerId) { User user = null; DbCommand command = GetCommand("SPUsersGetByProvider"); command.AddParameter<string>(this.Factory, "Provider", provider.ToString().ToUpper()); command.AddParameter<string>(this.Factory, "ProviderId", providerId); DataRow dr = GetFirstRow(command); if (dr != null) { user = ParseUserLoginInfo(dr); } return user; }
public User GetByPasswordResetGuid(AuthenticationProvider provider, string PasswordResetGuid) { User user = null; DbCommand command = GetCommand("SPUsersGetByPasswordResetGuid"); command.AddParameter<string>(this.Factory, "Provider", provider.ToString().ToUpper()); command.AddParameter<string>(this.Factory, "PasswordResetGuid", PasswordResetGuid); DataRow dr = GetFirstRow(command); if (dr != null) { user = ParseUserLoginInfo(dr); user.PasswordResetGuid = dr.GetString("PasswordResetGuid"); user.PasswordResetGuidExpireDate = dr.GetDate("PasswordResetGuidExpireDate"); } return user; }
/// <summary> /// Initializes a new instance of the <see cref="AuthenticationHelper"/> class. /// </summary> /// <param name="provider">The provider.</param> public AuthenticationHelper(AuthenticationProvider provider) : base(provider) { }
private async Task<AuthenticationResult> Authenticate(AuthenticationProvider provider) { var result = new AuthenticationResult(); try { result.UserId = await this.MobileServices.AuthenticateAsync(this, provider); } catch (InvalidOperationException ex) { result.Error = ex; } return result; }
private async Task AuthenticateAndGo(AuthenticationProvider provider) { var result = await Authenticate(provider); if (result.Error != null) { this.MessageBox.Show(this, "There was an error authenticating.", "Error"); } else { this.SetLastUserId(result.UserId); await LoadIdentityAndGo(result.UserId); } }
public async Task<string> AuthenticateAsync(Context context, AuthenticationProvider provider)
/// <exception cref="ValidationException"> /// Throws ValidationException when user fields are invalid /// </exception> public User Add(User user, AuthenticationProvider provider, string providerId) { user.ValidateFields(); return _dataAccess.AddUser(user, provider, providerId); }
public User GetByPasswordResetGuid(AuthenticationProvider provider, string PasswordResetGuid) { return _dataAccess.GetByPasswordResetGuid(provider, PasswordResetGuid); }
public void RegisterShouldCreateLoginUser(FakeMembershipUser user, MembershipProvider membershipProvider, AuthenticationProvider authenticationProvider, RegistrationInfo registrationInfo, AccountRepository repository) { user.ProviderName.Returns("fake"); user.UserName.Returns("name"); MembershipCreateStatus status; membershipProvider.CreateUser(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>(), Arg.Any<bool>(), Arg.Any<object>(), out status).Returns(user); membershipProvider.GetUser(Arg.Any<string>(), Arg.Any<bool>()).Returns(user); using (new Switcher<Domain, Domain>(new Domain("somedomain"))) { using (new MembershipSwitcher(membershipProvider)) { using (new AuthenticationSwitcher(authenticationProvider)) { repository.RegisterUser(registrationInfo); authenticationProvider.Received(1).Login(Arg.Is<User>(u => u.Name == $@"somedomain\{registrationInfo.Email}")); } } } }
public void LoginShouldTriggerLoginEventIfUserIsLoggedIn(FakeMembershipUser user, [Frozen]IAccountTrackerService accountTrackerService, AuthenticationProvider authenticationProvider, AccountRepository repo) { authenticationProvider.Login(@"somedomain\John", Arg.Any<string>(), Arg.Any<bool>()).Returns(true); var context = new FakeSiteContext(new StringDictionary { { "domain", "somedomain" } }); using (new Switcher<Domain, Domain>(new Domain("somedomain"))) { using (new AuthenticationSwitcher(authenticationProvider)) { var loginResult = repo.Login("John", "somepassword"); accountTrackerService.Received(1).TrackLogin(); } } }
public void LoginShouldReturnTrueIfUserIsLoggedIn(FakeMembershipUser user, AuthenticationProvider authenticationProvider, AccountRepository repo) { authenticationProvider.Login(@"somedomain\John", Arg.Any<string>(), Arg.Any<bool>()).Returns(true); var context = new FakeSiteContext(new StringDictionary { { "domain", "somedomain" } }); using (new Switcher<Domain, Domain>(new Domain("somedomain"))) { using (new AuthenticationSwitcher(authenticationProvider)) { var loginResult = repo.Login("John", "somepassword"); loginResult.Should().BeTrue(); } } }
public User GetByProviderId(AuthenticationProvider provider, string providerId) { return _dataAccess.GetByProviderId(provider, providerId); }
private void AwaitAuthenticateAndGo(AuthenticationProvider provider) { var t = this.AuthenticateAndGo (provider); if (t.Exception != null) throw t.Exception; }
public FakeAuthenticationProviderTest() { this.provider = new FakeAuthenticationProvider(); this.localProvider = Substitute.For<AuthenticationProvider>(); this.user = User.FromName(UserName, false); }
public ActionResult Authenticate(AuthenticationProvider provider, string id, string name, string lastName, string image) { User user = DataManager.Users.Authenticate(provider, id, name, lastName, image); SetUser(user, SecurityManager.GetHashString(id)); return RedirectToAction("Index", "Home"); }
public override void Initialize(IBrokerHost brokerHost, AuthenticationProvider authProvider) { l.Debug("Initialize " + brokerHost.GetType().FullName + " " + authProvider.GetType().FullName); base.Initialize(brokerHost, authProvider); this.brokerHost = brokerHost; }
public AuthenticationManagerTest() { this.provider = Substitute.For<AuthenticationProvider>(); }
internal static InMemoryTokenManager GetTokenManager(CacheWrapper cache, AuthenticationProvider provider, KeySecretElement providerConfiguration) { var tokenManager = (InMemoryTokenManager)cache.Cache[provider.ToString() + "TokenManager"]; if (tokenManager == null) { tokenManager = new InMemoryTokenManager(providerConfiguration.ApiKey, providerConfiguration.SecretKey); cache.Cache[provider.ToString() + "TokenManager"] = tokenManager; } return tokenManager; }
/// <summary> /// Default constructor. /// </summary> /// <param name="name">Authentication provider name.</param> /// <param name="provider">Authentication provider instance.</param> /// <param name="configuration">Authentication provider configuration.</param> internal AuthenticationProviderInfo(string name, AuthenticationProvider provider, AuthenticationProviderConfiguration configuration) { Name = name; Provider = provider; Configuration = configuration; }