// Handle the connection to the server protected void btnConnect_Click(object sender, EventArgs e) { string Port = Request.ServerVariables["SERVER_PORT"]; string Protocol = Request.ServerVariables["SERVER_PORT_SECURE"]; string basePath = string.Empty; if (Port == null || Port == "80" || Port == "443") Port = ""; else Port = String.Format(":{0}", Port); if (Protocol == null || Protocol == "0") Protocol = "http://"; else Protocol = "https://"; basePath = String.Format("{0}{1}{2}{3}/Default.aspx", Protocol, Request.ServerVariables["SERVER_NAME"], Port, Request.ApplicationPath); IntellisyncServer server = new IntellisyncServer(basePath); UserCredentials credentials = new UserCredentials(userId.Text, password.Text, ""); if (server.TestAuthenticate(userId.Text, credentials.Password, string.Empty)) { testMessage.Text = GetResource("SuccessMessage"); } else { testMessage.Text = GetResource("FailMessage"); } }
private static UserCredentials PromptForUserCredentials(List<User> users) { var userCredentials = new UserCredentials(); string name = PromptForUserName(); while (!userCredentials.AreValid && !string.IsNullOrEmpty(name)) { if (!UserNameIsValid(users, name)) { DisplayInvalidUserNameMessage(); name = PromptForUserName(); } else { string password = PromptForUserPassword(); userCredentials = new UserCredentials(name, password); if (!PasswordIsValid(users, userCredentials)) { DisplayInvalidPasswordMessage(); name = PromptForUserName(); } else { userCredentials.AreValid = true; } } } return userCredentials; }
public TestResponder() { Credentials = new UserCredentials { Username = "******" }; }
/// <summary> /// Create a new Aneka cloud/master user for a specific cloud /// </summary> /// <param name="cloudUserAccount">The new account information to add</param> /// <param name="cloudID">The cloud ID to add this user to</param> public void createNewUser(CloudUserAccount cloudUserAccount, int cloudID) { // Check to see if a non-empty username was specified if (string.IsNullOrEmpty(cloudUserAccount.Username) == true) { throw new Exception("Invalid User Name: The user name cannot be empty or contain only white-spaces"); } // Validate password if (cloudUserAccount.Password.Length < 6) { throw new Exception("Invalid Password: The password must be at least six characters long"); } List<string> groups = new List<string>(); // [DK] NOTE: Do we need to have a selection list of // groups in this form? UserCredentials credentials = new UserCredentials(cloudUserAccount.Username, cloudUserAccount.Password, cloudUserAccount.Username, cloudUserAccount.useThisAccountForReporting ? "This account will be used for reporting" : "Normal account", groups); securityManager.CreateUser(credentials); CloudUserAccount CloudUserAccountfromDB = db.CloudUserAccounts.Find(cloudUserAccount.CloudUserAccountId); Cloud cloudFromDB = db.Clouds.Find(cloudID); CloudUserAccountfromDB.Clouds.Add(cloudFromDB); db.SaveChanges(); }
public void Setup() { var creds = new UserCredentials("foo", "auth", "http://foo.com"); _client = new FakeClient(); _conn = new CF_Connection(creds, _client); _conn.Authenticate(); }
protected static UserCredentials getCredentails() { UserCredentials userCredentials = new UserCredentials(); userCredentials.userid = Settings.IndoorTriathlonServiceUsername; // "VARegistration"; userCredentials.password = Settings.IndoorTriathlonServicePassword; // "cr34m t34"; return userCredentials; }
/// <summary> /// Creates SJMPClient /// </summary> /// <param name="url">URL to connect to.</param> /// <param name="auth">Auth credentials. Null if not needed.</param> public SjmpClient(string url, IClientCredentials auth = null) { this.m_url = url; if (auth != null) { this.m_auth = new UserCredentials(auth); }; }
/// <summary> /// Initializes a new instance of the <see cref="GetAuthentication"/> class. /// </summary> /// <param name="userCreds">the UserCredentials instace to use when attempting authentication</param> /// <exception cref="System.ArgumentNullException">Thrown when any of the reference arguments are null</exception> public GetAuthentication(UserCredentials userCreds) { if (userCreds == null) { throw new ArgumentNullException(); } _userCredentials = userCreds; }
public void SetDefaultUserCredentials_ShouldStoreSpecifiedCredentials() { var expectedCredentials = new UserCredentials("a", "b"); var builder = new ConnectionSettingsBuilder(); builder.SetDefaultUserCredentials(expectedCredentials); ((ConnectionSettings)builder).DefaultUserCredentials.Should().Be(expectedCredentials); }
/*[HttpPost] [Route("user/token")] public string CreateToken(UserCredentials credentials) { if (credentials?.Email?.IsEmpty() != true || credentials.Password?.IsEmpty() != true) { throw new HttpResponseException(HttpStatusCode.BadRequest); } if (context.Users.Any(u => u.Email == credentials.Email && u.Hash == CreateHash(credentials.Password, u.Salt))) { return CreateHash(credentials.Email); } throw new HttpResponseException(HttpStatusCode.Unauthorized); }*/ public void CreateAccount(UserCredentials credentials) { if (credentials?.Email?.IsEmpty() != true || credentials.Password?.IsEmpty() != true) { throw new HttpResponseException(HttpStatusCode.BadRequest); } throw new HttpResponseException(HttpStatusCode.Created); }
public static CollectionAgent GetAgent(this Specimen s, UserCredentials profile) { return new CollectionAgent() { CollectionSpecimenID = s.CollectionSpecimenID, CollectorsAgentURI = profile.AgentURI, CollectorsName = profile.AgentName }; }
public static UserCredentials Credentialize(ResponseChannel channel) { UserCredentials creds = new UserCredentials(); creds.Username = channel.ToName; creds.ServiceName = channel.Connection.Alias; return creds; }
public static UserCredentials Credentialize(string strUser, string strServ) { UserCredentials creds = new UserCredentials(); creds.Username = strUser; creds.ServiceName = strServ; return creds; }
public void TestAuthenticateFail() { var creds = new UserCredentials("foo", "fail", "http://foo.com"); Client client = new FakeClient(); Connection conn = new CF_Connection(creds, client); Assert.AreEqual(conn.UserCreds.UserName, "foo"); Assert.AreEqual(conn.UserCreds.AuthUrl, "http://foo.com/"); Assert.AreEqual(conn.UserCreds.ApiKey, "fail"); Assert.Throws<AuthenticationFailedException>(conn.Authenticate); }
private void btnSignIn_Click(object sender, RoutedEventArgs e) { UserCredentials credentials = new UserCredentials(); credentials.Username = txtAccountUsername.Text; credentials.Password = txtAccountPassword.Password; Thread thrd = new Thread(new ParameterizedThreadStart(SignInThread)); thrd.SetApartmentState(ApartmentState.STA); thrd.Start(credentials); }
/// <summary> /// Returns an encrypted token for use with UserCredentials /// </summary> /// <param name="theUserCredentials">UserCredentials object</param> /// <param name="theLifetimeInMinutes">Lifetime that token is valid</param> /// <returns>Encrypted token</returns> public string GetToken(UserCredentials theUserCredentials, int theLifetimeInMinutes) { var aTemporaryUserCredentials = new TemporaryUserCredentials(theUserCredentials, theLifetimeInMinutes); var aJsonObject = JsonConvert.SerializeObject(aTemporaryUserCredentials); var aEncryptedJsonObject = StringCipher.Encrypt(aJsonObject, _phrase); return CreateBearerToken(aEncryptedJsonObject); }
public ActionResult LogOn(UserCredentials credentials, String returnUrl) { Boolean b = FormsAuthentication.Authenticate(credentials.UserName, credentials.Password); if (!b) { ModelState.AddModelError("AuthenticationFailure", "Invalid username and password"); return View(credentials); } FormsAuthentication.SetAuthCookie(credentials.UserName, false); return Redirect(returnUrl ?? "/Admin"); }
public static IdentificationUnitGeoAnalysis GetGeoAnalysis(this IdentificationUnit iu, UserCredentials profile) { return new IdentificationUnitGeoAnalysis() { AnalysisDate = iu.AnalysisDate, IdentificationUnitID = iu.CollectionUnitID, CollectionSpecimenID = iu.CollectionSpecimenID, ResponsibleName = profile.AgentName, ResponsibleAgentURI = profile.AgentURI, }; }
/// <summary> /// GetAuthentication constructor /// </summary> /// <param name="userCredentials">the UserCredentials instace to use when attempting authentication</param> /// <exception cref="System.ArgumentNullException">Thrown when any of the reference arguments are null</exception> public GetAuthentication(UserCredentials userCredentials) { if (userCredentials == null) throw new ArgumentNullException(); Uri = string.IsNullOrEmpty(userCredentials.AccountName) ? userCredentials.AuthUrl : new Uri(userCredentials.AuthUrl + "/" + userCredentials.Cloudversion.Encode() + "/" + userCredentials.AccountName.Encode() + "/auth"); Method = "GET"; Headers.Add(Constants.X_AUTH_USER, userCredentials.Username.Encode()); Headers.Add(Constants.X_AUTH_KEY, userCredentials.Api_access_key.Encode()); }
public Person(string firstName, string middleName, string lastName, string address, string phoneNumber, string email, int postalCode, UserCredentials userCredentials) { id = 0; this.firstName = firstName; this.middleName = middleName; this.lastName = lastName; this.address = address; this.phoneNumber = phoneNumber; this.email = email; this.postalCode = postalCode; this.userCredentials = userCredentials; }
public void TestAuthenticate() { var creds = new UserCredentials("foo", "auth", "http://foo.com"); Client client = new FakeClient(); Connection conn = new CF_Connection(creds, client); Assert.AreEqual(conn.UserCreds.UserName, "foo"); Assert.AreEqual(conn.UserCreds.AuthUrl, "http://foo.com"); Assert.AreEqual(conn.UserCreds.ApiKey, "auth"); conn.Authenticate(); Assert.AreEqual(conn.UserCreds.CdnMangementUrl.ToString(), "https://foo.com/"); Assert.AreEqual(conn.UserCreds.StorageUrl.ToString(), "https://foo.com/"); Assert.AreEqual(conn.UserCreds.AuthToken, "foo"); }
public void TestHasMatchingPassword() { string properLengthInput = new string('a', UserCredentials.MINIMAL_PASSWORD_LENGTH); string matchingPassword = new string('a', UserCredentials.MINIMAL_PASSWORD_LENGTH); string notMatchingPassword = new string('b', UserCredentials.MINIMAL_PASSWORD_LENGTH); UserCredentials userCredentials = new UserCredentials(properLengthInput, properLengthInput); bool matchingPasswordResult; bool notMatchingPasswordResult; matchingPasswordResult = userCredentials.HasMatchingPassword(matchingPassword); notMatchingPasswordResult = userCredentials.HasMatchingPassword(notMatchingPassword); Assert.IsTrue(matchingPasswordResult, "Should be a match."); Assert.IsFalse(notMatchingPasswordResult, "Should not be a match."); }
/// <summary> /// Extracts the geo location information stored in the client-side <see cref="Event"/> Object /// And converts it to its <see cref="CollectionEventLocalisation"/> representation. /// </summary> /// <param name="ev">The client-side Event object possibly containing location information.</param> /// <param name="profile">The Profile of the User responsible for creating this object.</param> /// <returns>Between 0 and 2 <see cref="CollectionEventLocalisation"/> objects depending on the amount of information in the Input object.</returns> public static IEnumerable<CollectionEventLocalisation> GetLocalisations(this Event ev, UserCredentials profile) { IList<CollectionEventLocalisation> localisations = new List<CollectionEventLocalisation>(); if (ev.Altitude.HasValue && !double.IsNaN(ev.Altitude.Value)) { CollectionEventLocalisation altitude = new CollectionEventLocalisation(); altitude.AverageAltitudeCache = ev.Altitude; altitude.AverageLatitudeCache = ev.Latitude; altitude.AverageLongitudeCache = ev.Longitude; altitude.CollectionEventID = ev.CollectionEventID; altitude.DeterminationDate = ev.CollectionDate; altitude.LocalisationSystemID = ALTITUDE_LOC_SYS_ID; altitude.Location1 = ev.Altitude.ToString(); altitude.ResponsibleAgentURI = profile.AgentURI; altitude.ResponsibleName = profile.AgentName; altitude.RecordingMethod = "Generated via DiversityMobile"; localisations.Add(altitude); } if (ev.Latitude.HasValue && !double.IsNaN(ev.Latitude.Value) && ev.Longitude.HasValue && !double.IsNaN(ev.Longitude.Value)) { CollectionEventLocalisation wgs84 = new CollectionEventLocalisation(); if (ev.Altitude != null && double.IsNaN((double)ev.Altitude) == false) { wgs84.AverageAltitudeCache = ev.Altitude; } else { wgs84.AverageAltitudeCache = null; } wgs84.AverageLatitudeCache = ev.Latitude; wgs84.AverageLongitudeCache = ev.Longitude; wgs84.CollectionEventID = ev.CollectionEventID; wgs84.DeterminationDate = ev.CollectionDate; wgs84.LocalisationSystemID = WGS84_LOC_SYS_ID; wgs84.Location1 = ev.Longitude.ToString(); wgs84.Location2 = ev.Latitude.ToString(); wgs84.ResponsibleAgentURI = profile.AgentURI; wgs84.ResponsibleName = profile.AgentName; wgs84.RecordingMethod = "Generated via DiversityMobile"; localisations.Add(wgs84); } return localisations; }
public static Identification GetIdentification(this IdentificationUnit iu, UserCredentials profile) { return new Identification() { CollectionSpecimenID = iu.CollectionSpecimenID, IdentificationUnitID = iu.CollectionUnitID, IdentificationSequence = 1, IdentificationDay = (byte?)iu.AnalysisDate.Day, IdentificationMonth = (byte?)iu.AnalysisDate.Month, IdentificationYear = (short?)iu.AnalysisDate.Year, IdentificationDateCategory = "actual", TaxonomicName = iu.LastIdentificationCache, NameURI = iu.IdentificationUri, IdentificationCategory = "determination", ResponsibleName = profile.AgentName, ResponsibleAgentURI = profile.AgentURI, IdentificationQualifier = iu.Qualification }; }
public void TestConnectionCheckMembers() { var creds = new UserCredentials("foo", "auth", "http://foo.com"); Client client = new FakeClient(); Connection conn = new CF_Connection(creds, client); Assert.AreEqual(conn.UserCreds.UserName, "foo"); Assert.AreEqual(conn.UserCreds.AuthUrl, "http://foo.com/"); Assert.AreEqual(conn.UserCreds.ApiKey, "auth"); conn.Authenticate(); Assert.AreEqual(conn.UserCreds.CdnMangementUrl.ToString(), "https://foo.com/"); Assert.AreEqual(conn.UserCreds.StorageUrl.ToString(), "https://foo.com/"); Assert.AreEqual(conn.UserCreds.AuthToken, "foo"); Assert.True(conn.HasCDN); conn.UserCreds.CdnMangementUrl = null; Assert.IsFalse(conn.HasCDN); conn.UserAgent = "foo"; Assert.AreEqual(conn.UserAgent, "foo"); conn.Timeout = 1; Assert.AreEqual(conn.Timeout, 1); conn.Retries = 1; Assert.AreEqual(conn.Retries, 1); }
public void TestUserCredentialsConstructor() { string properLengthInput = new string('a', UserCredentials.MINIMAL_PASSWORD_LENGTH); string improperLenghtInput = "a"; int expectedMessageCount = 4; UserCredentials.MessengerSent += HelperOnMessangerSent; UserCredentials userCredentialsImpImp = new UserCredentials(improperLenghtInput, improperLenghtInput); UserCredentials userCredentialsImpProp = new UserCredentials(improperLenghtInput, properLengthInput); UserCredentials userCredentialsPropImp = new UserCredentials(properLengthInput, improperLenghtInput); UserCredentials userCredentialsPropProp = new UserCredentials(properLengthInput, properLengthInput); UserCredentials.MessengerSent -= HelperOnMessangerSent; Assert.AreEqual(userCredentialsImpImp.GetUsername(), String.Empty); Assert.AreEqual(userCredentialsImpImp.GetPassword(), String.Empty); Assert.AreEqual(userCredentialsImpProp.GetUsername(), String.Empty); Assert.AreEqual(userCredentialsImpProp.GetPassword(), properLengthInput); Assert.AreEqual(userCredentialsPropImp.GetUsername(), properLengthInput); Assert.AreEqual(userCredentialsPropImp.GetPassword(), String.Empty); Assert.AreEqual(userCredentialsPropProp.GetUsername(), properLengthInput); Assert.AreEqual(userCredentialsPropProp.GetPassword(), properLengthInput); Assert.AreEqual(expectedMessageCount, messageCount, "Message count is not expected."); }
public void SetUp() { _credentials = new UserCredentials("admin", "changeit"); _sut = new FixedStreamUserCredentialsResolver(_credentials); }
public static void Main(string[] args) { try { string fileName = null; string tsa = null; string hash = null; string policy = null; string nonce = null; bool cert = false; string outFile = null; string sslClientCertFile = null; string sslClientCertPass = null; string httpAuthLogin = null; string httpAuthPass = null; bool isAsics = false; if (args == null) { return; } int i = 0; if (0 >= args.Length) { ExitWithHelp(string.Empty); } while (i < args.Length) { switch (args[i]) { case "--file": fileName = args[++i]; break; case "--tsa": tsa = args[++i]; break; case "--out": outFile = args[++i]; break; case "--hash": hash = args[++i]; break; case "--policy": policy = args[++i]; break; case "--nonce": nonce = args[++i]; break; case "--cert-req": cert = true; break; case "--ssl-client-cert-file": sslClientCertFile = args[++i]; break; case "--ssl-client-cert-pass": sslClientCertPass = args[++i]; break; case "--http-auth-login": httpAuthLogin = args[++i]; break; case "--http-auth-pass": httpAuthPass = args[++i]; break; case "--asics": isAsics = true; break; default: ExitWithHelp("Invalid argument: " + args[i]); break; } i++; } X509Certificate2 sslCert = null; if (!string.IsNullOrEmpty(sslClientCertFile)) { sslCert = new X509Certificate2(sslClientCertFile, sslClientCertPass); } NetworkCredential networkCredential = null; if (!string.IsNullOrEmpty(httpAuthLogin) && !string.IsNullOrEmpty(httpAuthPass)) { networkCredential = new NetworkCredential(httpAuthLogin, httpAuthPass); } UserCredentials credentials = null; if (networkCredential != null || sslCert != null) { credentials = new UserCredentials(sslCert, networkCredential); } TimeStampToken token = SharedUtils.RequestTimeStamp(tsa, fileName, hash, policy, nonce, cert, credentials, new LogDelegate(LogMessage), true); if (isAsics) { SharedUtils.SaveToAsicSimple(fileName, token, outFile); } else { SharedUtils.SaveResponse(outFile, token); } } catch (Exception e) { Console.WriteLine(e.Message); ExitWithHelp(null); } Console.WriteLine("Success"); }
Task <WriteResult> IEventStoreConnection.SetStreamMetadataAsync(string stream, int expectedMetastreamVersion, byte[] metadata, UserCredentials userCredentials) { return(_connection.SetStreamMetadataAsync(stream, expectedMetastreamVersion, metadata, userCredentials)); }
static UserCredentials GetUser(string name) { lock (Sync) { try { if (_users == null) { var text = File.ReadAllText(CredentialsFileName); _users = new Dictionary<string, UserCredentials>(); var lines = text.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries); foreach (var line in lines) { var parts = line.Split('\t'); if (parts.Length == 3) { var user = new UserCredentials { Name = parts[0], Salt = Encoding.Unicode.GetString(Convert.FromBase64String(parts[1])), PasswordHash = parts[2], }; _users.Add(user.Name, user); } } } } catch (Exception exc) { WebLogger.Report(exc); } if (_users == null) return null; UserCredentials res; _users.TryGetValue(name, out res); return res; } }
Task IEventStoreConnection.SetSystemSettingsAsync(SystemSettings settings, UserCredentials userCredentials) { return(_connection.SetSystemSettingsAsync(settings, userCredentials)); }
Task <DeleteResult> IEventStoreConnection.DeleteStreamAsync(string stream, int expectedVersion, bool hardDelete, UserCredentials userCredentials) { return(_connection.DeleteStreamAsync(stream, expectedVersion, hardDelete, userCredentials)); }
Task <WriteResult> IEventStoreConnection.AppendToStreamAsync(string stream, int expectedVersion, IEnumerable <EventData> events, UserCredentials userCredentials) { return(_connection.AppendToStreamAsync(stream, expectedVersion, events, userCredentials)); }
public Task <StreamMetadataResult> ReadMeta(string streamId, UserCredentials userCredentials = default) => Client.GetStreamMetadataAsync(streamId, userCredentials: userCredentials);
public Task ReadAllBackward(UserCredentials userCredentials = default) => Client.ReadAllAsync(Direction.Backwards, Position.End, 1, resolveLinkTos: false, userCredentials: userCredentials) .ToArrayAsync() .AsTask();
public Task <DeleteResult> DeleteStream(string streamId, UserCredentials userCredentials = default) => Client.TombstoneAsync(streamId, AnyStreamRevision.Any, userCredentials: userCredentials);
public RefreshTokenDelegatingHandler(UserCredentials credentials) { _credentials = credentials; }
public MockConnection(UserCredentials userCreds) : base(userCreds) { }
EventStoreTransaction IEventStoreConnection.ContinueTransaction(long transactionId, UserCredentials userCredentials) { return(_connection.ContinueTransaction(transactionId, userCredentials)); }
public Task <WriteResult> AppendStream(string streamId, UserCredentials userCredentials = default) => Client.AppendToStreamAsync(streamId, AnyStreamRevision.Any, CreateTestEvents(3), userCredentials: userCredentials);
Task <EventStoreTransaction> IEventStoreConnection.StartTransactionAsync(string stream, int expectedVersion, UserCredentials userCredentials) { return(_connection.StartTransactionAsync(stream, expectedVersion, userCredentials)); }
public Task ReadStreamBackward(string streamId, UserCredentials userCredentials = default) => Client.ReadStreamAsync(Direction.Backwards, streamId, StreamRevision.Start, 1, resolveLinkTos: false, userCredentials: userCredentials) .ToArrayAsync() .AsTask();
Task <WriteResult> IEventStoreConnection.AppendToStreamAsync(string stream, int expectedVersion, UserCredentials userCredentials, params EventData[] events) { return(_connection.AppendToStreamAsync(stream, expectedVersion, userCredentials, events)); }
/// <summary> /// Action bound to <see cref="UpdatePasswordButtonViewModel"/> button. /// </summary> private async void OnUpdatePasswordButtonPressed() { var updatedCredentials = new UserCredentials(accountService.CurrentUser.Username, PasswordEntryViewModel.Text); await accountService.UpdatePasswordAsync(updatedCredentials); }
public LoginServiceTest() { _service = new LoginService(); _userCredentials = new UserCredentials {UserName = "******", Password = "******"}; }
Task <AllEventsSlice> IEventStoreConnection.ReadAllEventsBackwardAsync(Position position, int maxCount, bool resolveLinkTos, UserCredentials userCredentials) { return(_connection.ReadAllEventsBackwardAsync(position, maxCount, resolveLinkTos, userCredentials)); }
static bool CheckPassword(UserCredentials user, string password) { var hash = GetPasswordHash(user.Salt, password); var res = (user.PasswordHash == hash); return res; }
public LoginRequestMessage(UserCredentials[] credentials) { if (credentials == null) throw new ArgumentNullException ("credentials"); this.credentials = credentials; }
Task <RawStreamMetadataResult> IEventStoreConnection.GetStreamMetadataAsRawBytesAsync(string stream, UserCredentials userCredentials) { return(_connection.GetStreamMetadataAsRawBytesAsync(stream, userCredentials)); }
Task <StreamEventsSlice> IEventStoreConnection.ReadStreamEventsBackwardAsync(string stream, int start, int count, bool resolveLinkTos, UserCredentials userCredentials) { return(_connection.ReadStreamEventsBackwardAsync(stream, start, count, resolveLinkTos, userCredentials)); }
EventStoreStreamCatchUpSubscription IEventStoreConnection.SubscribeToStreamFrom(string stream, int?lastCheckpoint, bool resolveLinkTos, Action <EventStoreCatchUpSubscription, ResolvedEvent> eventAppeared, Action <EventStoreCatchUpSubscription> liveProcessingStarted, Action <EventStoreCatchUpSubscription, SubscriptionDropReason, Exception> subscriptionDropped, UserCredentials userCredentials, int readBatchSize) { if (userCredentials == null) { throw new ArgumentNullException("userCredentials"); } return(_connection.SubscribeToStreamFrom(stream, lastCheckpoint, resolveLinkTos, eventAppeared, liveProcessingStarted, subscriptionDropped, userCredentials, readBatchSize)); }
Task <EventReadResult> IEventStoreConnection.ReadEventAsync(string stream, int eventNumber, bool resolveLinkTos, UserCredentials userCredentials) { return(_connection.ReadEventAsync(stream, eventNumber, resolveLinkTos, userCredentials)); }
protected AuthenticationTestBase(UserCredentials userCredentials = null) { _userCredentials = userCredentials; }
/// <summary> /// Read events until the given position async. /// </summary> /// <param name="connection">The connection.</param> /// <param name="resolveLinkTos">Whether to resolve Link events.</param> /// <param name="userCredentials">User credentials for the operation.</param> /// <param name="lastCommitPosition">The commit position to read until.</param> /// <param name="lastEventNumber">The event number to read until.</param> /// <returns></returns> protected override Task ReadEventsTillAsync(IEventStoreConnection connection, bool resolveLinkTos, UserCredentials userCredentials, long?lastCommitPosition, long?lastEventNumber) => ReadEventsInternalAsync(connection, resolveLinkTos, userCredentials, lastCommitPosition);