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;
}
