public void Authenticate(string name, string password, bool ssl = true)
{
user = reddit.LogIn(name, password, ssl);
if (user == null)
throw new BotException($"Login failed. User: {name}");
Console.WriteLine($"Logged in as {user.Name}");
}
public static AuthenticatedUser FromString(string data)
{
string[] arr = data.Split('\n');
AuthenticatedUser user = new AuthenticatedUser();
user.ID = Convert.ToInt32(arr[0]);
user.Name = arr[1];
user.Role = GetSecurityRoleById(user.ID);
return user;
}
public async Task Delete__User_Can_Delete_His_Private_Training()
{
AuthenticatedUser user = await LogInAs("*****@*****.**");
Training training = await CreatePrivateTraining(user.Id);
string deleteEndpoint = ApiRoutes.Training.Delete.Replace("{trainingId}", training.Id.ToString());
var response = await Client.DeleteAsync(deleteEndpoint);
response.StatusCode.Should().Be(HttpStatusCode.NoContent);
int trainingCount = await Context.Training.AsNoTracking().CountAsync();
trainingCount.Should().Be(0);
int userTrainingCount = await Context.UserTraining.AsNoTracking().CountAsync();
userTrainingCount.Should().Be(0);
}
public void SignIn_With_Invalid_Credentials_Returns_InvalidCredentials_View()
{
_dataAccessor.Setup(d => d.VerifyCredentials("Test User", "TestPass!")).Returns(false);
var authenticatedUser = new AuthenticatedUser {
Username = "******", Password = "******"
};
var result = _controller.SignIn(authenticatedUser);
Assert.NotNull(result);
var viewResult = result as ViewResult;
Assert.NotNull(viewResult);
Assert.AreEqual("InvalidCredentials", viewResult.ViewName);
_dataAccessor.Verify(d => d.VerifyCredentials("Test User", "TestPass!"), Times.Once);
}
private void TestIsLoginDiscontinued(string credentialType, bool isOnWhiteList, bool isOnDomainList, bool isOnExceptionList, bool isOnTransformList, bool isWrongCase, bool expectedResult)
{
// Arrange
var credential = new Credential(credentialType, "value");
var user = new User("test")
{
EmailAddress = _email, Credentials = new[] { credential }
};
var authUser = new AuthenticatedUser(user, credential);
var config = CreateConfiguration(isOnWhiteList, isOnDomainList, isOnExceptionList, isOnTransformList, isOnTenantPairList: false, isWrongCase: isWrongCase);
// Act
var result = config.IsLoginDiscontinued(authUser);
// Assert
Assert.Equal(expectedResult, result);
}
public UserComments Exec(SqlConnection db, AuthenticatedUser au, int skip, int take)
{
var retComments = new UserComments();
foreach (var item in repository.UserComments(db, au.Id, skip, take, ref retComments.total))
{
retComments.list.Add(new UserCommentInformation
{
Comment = item.Comment,
Date = item.DateAdded,
ProductName = "x",
ProductCategory = "y",
ProductId = 1
});
}
return(retComments);
}
private async Task <AuthenticatedUser> AssociateCredential(AuthenticatedUser user)
{
var result = await _authService.ReadExternalLoginCredential(OwinContext);
if (result.ExternalIdentity == null)
{
// User got here without an external login cookie (or an expired one)
// Send them to the logon action
return(null);
}
await _authService.AddCredential(user.User, result.Credential);
// Notify the user of the change
_messageService.SendCredentialAddedNotice(user.User, result.Credential);
return(new AuthenticatedUser(user.User, result.Credential));
}
public async Task Get_Friends_As_New_User()
{
// Arrange
var expected = 0;
var user = new AuthenticatedUser()
{
Name = "abc",
PreferredUsername = "******",
UserIdentifier = "u",
ProviderIdentifier = "p"
};
// Act
var actual = await _friendsHandler.GetFriendsAsync(user);
// Assert
Assert.Equal(expected, actual.Count);
}
public async Task Login()
{
try
{
ErrorMessage = string.Empty;
AuthenticatedUser result = await _apiHelper.Authenticate(Username, Password);
// Retrieve the additional information about the user
await _apiHelper.GetLoggedInUserInfo(result.AccessToken);
// Push the event for the login
_events.PublishOnUIThread(new LogOnEvent());
}
catch (Exception e)
{
ErrorMessage = e.Message;
}
}
private AuthenticatedUser getUserID(string token)
{
AuthenticatedUser user = new AuthenticatedUser();
SqlConnection con = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["MS_TableConnectionString"].ConnectionString);
con.Open();
try
{
SqlCommand cmd = new SqlCommand("SELECT Token.UserID, Expires, UserTypeID FROM Token " +
"INNER JOIN Users " +
"On Token.UserID = Users.UserID " +
"WHERE Token = @token", con);
cmd.Parameters.AddWithValue("@token", token);
SqlDataReader reader = cmd.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
user.UserID = reader.GetInt32(0);
DateTime time = reader.GetDateTime(1);
if (time < DateTime.Now)
{
deleteToken(user.UserID);
user.UserID = 0;
return(user);
}
user.UserTypeID = reader.GetInt32(2);
con.Close();
return(user);
}
return(user);
}
else
{
return(user);
}
}
catch (Exception)
{
con.Close();
return(user);
}
}
public async Task ItShouldRunTheDownloader()
{
var parameters = DownloadMonitorCommand.Parameters.Random();
this.ensureAuthenticated.ExecuteAsync().Returns(Task.FromResult(AuthenticatedUser.Random()));
var createdInputFolder = SingletonRandom.Instance.NextString();
this.getCreatedOutputFolder.Execute(parameters.InputFolder).Returns(createdInputFolder);
var createdOutputFolder = SingletonRandom.Instance.NextString();
this.getCreatedOutputFolder.Execute(parameters.OutputFolder).Returns(createdOutputFolder);
this.monitorDownloads.ExecuteAsync(
Arg.Any <ChannelWriter <QueuedDownloadToken> >(),
Arg.Any <string>(),
Arg.Any <CancellationToken>()).Returns(Task.CompletedTask);
this.processDownloads.ExecuteAsync(
Arg.Any <ChannelReader <QueuedDownloadToken> >(),
Arg.Any <string>(),
Arg.Any <bool>(),
Arg.Any <bool>(),
Arg.Any <string>(),
Arg.Any <string>(),
Arg.Any <CancellationToken>()).Returns(Task.CompletedTask);
await this.target.ExecuteAsync(parameters);
await this.monitorDownloads.Received(1).ExecuteAsync(
Arg.Any <ChannelWriter <QueuedDownloadToken> >(),
createdInputFolder,
Arg.Any <CancellationToken>());
await this.processDownloads.Received(1).ExecuteAsync(
Arg.Any <ChannelReader <QueuedDownloadToken> >(),
createdOutputFolder,
parameters.GenerateCsv,
parameters.KeepBinary,
parameters.PostProcessor,
parameters.PostProcessorArguments,
Arg.Any <CancellationToken>());
}
public async Task WillNotSendConfirmationEmailWhenConfirmEmailAddressesIsOff()
{
// Arrange
var authUser = new AuthenticatedUser(
new User("theUsername")
{
UnconfirmedEmailAddress = "*****@*****.**",
EmailConfirmationToken = "t0k3n"
},
new Credential());
var configurationService = GetConfigurationService();
configurationService.Current.ConfirmEmailAddresses = false;
GetMock <AuthenticationService>()
.Setup(x => x.Register("theUsername", "*****@*****.**", It.IsAny <Credential>()))
.CompletesWith(authUser);
var controller = GetController <AuthenticationController>();
GetMock <AuthenticationService>()
.Setup(x => x.CreateSessionAsync(controller.OwinContext, authUser))
.Returns(Task.FromResult(0))
.Verifiable();
// Act
var result = await controller.Register(
new LogOnViewModel()
{
Register = new RegisterViewModel
{
Username = "******",
Password = "******",
EmailAddress = "*****@*****.**",
}
}, "/theReturnUrl", linkingAccount : false);
// Assert
GetMock <IMessageService>()
.Verify(x => x.SendNewAccountEmail(
It.IsAny <MailAddress>(),
It.IsAny <string>()), Times.Never());
}
public async Task <IActionResult> Login([FromForm] LoginModel loginModel, string returnUrl = "/")
{
if (!ModelState.IsValid)
{
return(View(loginModel));
}
AuthenticatedUser authenticatedUser = null;
try
{
authenticatedUser = _apiFacade.LoginUser(loginModel.EmailAddress, PasswordFunctions.GetSHA256(loginModel.Password));
}
catch (Exception ex) {
if (!ex.Message.Contains("Unauthorized"))
{
ModelState.AddModelError("Authenitcation Error", "There was an error logging you in: " + ex.Message);
return(View());
}
}
if (authenticatedUser != null && !string.IsNullOrWhiteSpace(authenticatedUser.JsonToken))
{
var identity = new ClaimsIdentity(CookieAuthenticationDefaults.AuthenticationScheme);
identity.AddClaim(new Claim(ClaimTypes.Name, loginModel.EmailAddress));
identity.AddClaim(new Claim(ClaimTypes.Sid, authenticatedUser.JsonToken));
identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, authenticatedUser.Id.ToString()));
SetRoles(authenticatedUser, identity);
await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme,
new ClaimsPrincipal(identity),
new AuthenticationProperties
{
IsPersistent = loginModel.RememberMe,
ExpiresUtc = DateTime.UtcNow.AddHours(_appSettings.Value.TokenTimeOutInHours)
});
return(RedirectToLocal(returnUrl));
}
else
{
ViewBag.Message = "Password or Email address is invalid.";
return(View());
}
}
public async Task WillCreateAndLogInTheUserWhenNotLinking()
{
// Arrange
var authUser = new AuthenticatedUser(
new User("theUsername")
{
UnconfirmedEmailAddress = "*****@*****.**",
EmailConfirmationToken = "t0k3n"
},
new Credential());
GetMock <AuthenticationService>()
.Setup(x => x.Register("theUsername", "*****@*****.**", It.IsAny <Credential>()))
.CompletesWith(authUser);
var controller = GetController <AuthenticationController>();
GetMock <AuthenticationService>()
.Setup(x => x.CreateSession(controller.OwinContext, authUser.User))
.Verifiable();
// Act
var result = await controller.Register(
new LogOnViewModel()
{
Register = new RegisterViewModel
{
Username = "******",
Password = "******",
EmailAddress = "*****@*****.**",
}
}, "/theReturnUrl", linkingAccount : false);
// Assert
GetMock <AuthenticationService>().VerifyAll();
var expectedAddress = new MailAddress(authUser.User.UnconfirmedEmailAddress, authUser.User.Username);
GetMock <IMessageService>()
.Verify(x => x.SendNewAccountEmail(
expectedAddress,
"https://nuget.local/account/confirm/theUsername/t0k3n"));
ResultAssert.IsSafeRedirectTo(result, "/theReturnUrl");
}
public async Task GivenNoLinkButEmailMatchingLocalUser_ItDisplaysLogOnViewPresetForSignIn()
{
// Arrange
var fakes = Get <Fakes>();
var existingUser = new User("existingUser")
{
EmailAddress = "*****@*****.**"
};
var cred = new CredentialBuilder().CreateExternalCredential("MicrosoftAccount", "blorg", "Bloog");
var msAuther = new MicrosoftAccountAuthenticator();
var msaUI = msAuther.GetUI();
var authUser = new AuthenticatedUser(
fakes.CreateUser("test", cred),
cred);
GetMock <AuthenticationService>(); // Force a mock to be created
GetMock <IUserService>()
.Setup(u => u.FindByEmailAddress(existingUser.EmailAddress))
.Returns(existingUser);
var controller = GetController <AuthenticationController>();
GetMock <AuthenticationService>()
.Setup(x => x.AuthenticateExternalLogin(controller.OwinContext))
.CompletesWith(new AuthenticateExternalLoginResult()
{
ExternalIdentity = new ClaimsIdentity(new[] {
new Claim(ClaimTypes.Email, existingUser.EmailAddress)
}),
Authenticator = msAuther
});
// Act
var result = await controller.LinkExternalAccount("theReturnUrl");
// Assert
var model = ResultAssert.IsView <LogOnViewModel>(result, viewName: LinkExternalViewName);
Assert.Equal(msaUI.AccountNoun, model.External.ProviderAccountNoun);
Assert.Null(model.External.AccountName);
Assert.True(model.External.FoundExistingUser);
Assert.Equal(existingUser.EmailAddress, model.SignIn.UserNameOrEmail);
Assert.Equal(existingUser.EmailAddress, model.Register.EmailAddress);
}
public async Task Patch__User_Can_Assign_Public_Training_To_His_Trainings()
{
AuthenticatedUser user = await LogInAs("*****@*****.**");
Training training = await CreatePublicTraining();
AddPublicTrainingToUserRequest request = new AddPublicTrainingToUserRequest {
TrainingId = training.Id
};
HttpContent content = new StringContent(JsonSerializer.Serialize(request), Encoding.UTF8, "application/json");
var response = await Client.PatchAsync(ApiRoutes.Training.AssignPublicTrainingToUser, content);
response.StatusCode.Should().Be(HttpStatusCode.OK);
int userTrainingCount = await Context.UserTraining.AsNoTracking().CountAsync();
userTrainingCount.Should().Be(1);
}
public async Task Patch__User_Cant_Add_Exercises_To_His_Public_Training()
{
AuthenticatedUser user = await LogInAs("*****@*****.**");
Training training = await CreatePublicTraining(user.Id);
Exercise exercise1 = await CreateExercise();
string patchEndpoint = ApiRoutes.Training.AddExercisesToTraining.Replace("{trainingId}", training.Id.ToString());
UpdateTrainingExercisesRequest request = new UpdateTrainingExercisesRequest
{
Exercises = new[] { exercise1.Id }
};
HttpContent content = new StringContent(JsonSerializer.Serialize(request), Encoding.UTF8, "application/json");
var response = await Client.PatchAsync(patchEndpoint, content);
response.StatusCode.Should().Be(HttpStatusCode.Forbidden);
}
private bool ProcessLogin(string username, string password)
{
_reddit = new Reddit(WebAgent.RateLimitMode.Pace);
if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password)) return false;
try
{
OutputTextBlock.Text += $"\r\n{DateTime.Now} | Logging in as {username}.";
_redditUser = _reddit.LogIn(username, password);
}
catch (Exception ex)
{
OutputTextBlock.Text += $"\r\n{DateTime.Now} | Login failed. Exception encountered: {ex.Message}. Is Reddit down?";
}
if (_redditUser != null) return true;
return false;
}
public async Task <IActionResult> OnGetAsync(
[FromServices] AuthenticatedUser user)
{
var reg = await _registrations.GetRegistration(user);
if (reg.HasCompletedVerification)
{
return(RedirectToPage("/apprenticeships/index"));
}
if (!reg.HasViewedVerification)
{
await _registrations.FirstSeenOn(user.ApprenticeId, DateTime.UtcNow);
}
EmailAddress = reg?.Email;
return(Page());
}
public async Task <(MyChessGame?Game, HandlerError?Error)> CreateGameAsync(AuthenticatedUser authenticatedUser, MyChessGame game)
{
var opponentID = game.Players.Black.ID;
var opponent = await GetUserByUserIDAsync(opponentID);
if (opponent == null)
{
return(null, new HandlerError()
{
Instance = LoggingEvents.CreateLinkToProblemDescription(LoggingEvents.GameHandlerOpponentNotFound),
Status = (int)HttpStatusCode.NotFound,
Title = "User not found",
Detail = "For some reason your opponent could not be found"
});
}
var user = await GetOrCreateUserAsync(authenticatedUser);
game.ID = Guid.NewGuid().ToString("D");
game.Players.White.ID = user.UserID;
var data = _compactor.Compact(game);
// TODO: Validate game data
var comment = game.Moves[0].Comment;
await _context.UpsertAsync(TableNames.GamesWaitingForYou, new GameEntity
{
PartitionKey = opponentID,
RowKey = game.ID,
Data = data
});
await _context.UpsertAsync(TableNames.GamesWaitingForOpponent, new GameEntity
{
PartitionKey = user.UserID,
RowKey = game.ID,
Data = data
});
await _notificationHandler.SendNotificationAsync(opponentID, game.ID, comment);
return(game, null);
}
public SendMessageResponse SendMessage(SendMessageRequest messageRequest)
{
using (new OperationContextScope((IClientChannel)proxy))
{
AuthenticatedUser currentLoggedUser = AuthenticatedUser.Instance;
WebOperationContext.Current.OutgoingRequest.Headers.Add("Authentication", currentLoggedUser.Authentication.ToString());
try
{
SendMessageResponse response = proxy.SendMessage(messageRequest);
return(response);
}
catch (Exception ex)
{
return(new SendMessageResponse {
IsSuccess = false, Message = ex.Message
});
}
}
}
//public Repository(IEnsuranceContext context)
//{
// this.context = context;
//}
#region Authentication
public AuthenticatedUser AuthenticateUser(Authentication login)
{
AuthenticatedUser user = null;
using (var context = new EnsuranceDBEntities())
{
user = context.Users.AsNoTracking()
.Where(u => u.UserName == login.UserName && u.Password == login.Password)
.Select(u => new AuthenticatedUser
{
Id = u.Id,
Name = u.Name,
LastName = u.LastName,
Username = u.UserName,
Token = ""
}).FirstOrDefault <AuthenticatedUser>();
}
return(user);
}
public async Task <Project> UpdateAsync(Project project, AuthenticatedUser currentUser)
{
await EnsureUserHasAccessAsync(currentUser, project.Id, AccessType.Admin, nameof(UpdateAsync));
var dbProject = await projectRepository.FindByIdAsync(project.Id);
if (dbProject == null)
{
throw new EntityNotFoundException(nameof(Project), project.Id.ToString());
}
dbProject.Name = project.Name;
dbProject.GitToken = project.GitToken;
dbProject.ProjectUri = project.ProjectUri;
await projectRepository.UpdateAsync(dbProject);
return(ModelsMapper.ConvertProjectDbModelToServiceModel(dbProject));
}
public ITestApiContext ParseQueryStringToContext(
IEnumerable <KeyValuePair <string, string> > queryKeyValuePairs,
AuthenticatedUser authenticatedUser,
EntityId organizationUnitId,
EntityId repositoryId)
{
var metaData = new MetaDataEnvelope();
var warnings = new List <string>();
var querystringAsDictionary = this.QueryStringToDictionary(queryKeyValuePairs);
var filters = querystringAsDictionary.ContainsKey("filters")
? querystringAsDictionary["filters"]
: string.Empty;
var context = new TestApiContext(
querystringAsDictionary,
querystringAsDictionary.ContainsKey("count")
? ParseInt("Count", querystringAsDictionary["count"], warnings)
: DefaultCount,
querystringAsDictionary.ContainsKey("offset")
? ParseInt("Offset", querystringAsDictionary["offset"], warnings)
: DefaultOffset,
this.ParseFilters(filters, metaData),
authenticatedUser,
organizationUnitId,
repositoryId,
metaData,
Enumerable.Empty <string>(),
Enumerable.Empty <string>());
PopulateMetaData(metaData, context, filters);
querystringAsDictionary.Remove("count");
querystringAsDictionary.Remove("offset");
querystringAsDictionary.Remove("filters");
AddFiltersToDebugIfRequired(context);
warnings.ForEach(context.AddWarning);
return(context);
}
public async Task <ActionResult> CompleteAuth(string code)
{
string clientId = "YOUR_CLIENT_ID";
string clientSecret = "YOUR_CLIENT_SECRET";
string redirectUri = "YOUR_REDIRECT_URL";
var result = await InstagramOAuth.AuthenticateUser(clientId, clientSecret, "authorization_code", redirectUri, code);
if (result.IsSuccessStatusCode)
{
string responseContent = result.Content.ReadAsStringAsync().Result;
AuthenticatedUser authenticatedUser = JsonConvert.DeserializeObject <AuthenticatedUser>(responseContent);
}
else
{
throw new Exception();
}
return(View());
}
public async Task <ActionResult <RegisteredUser> > AddNewAuthenticatedUser(AuthenticatedUser authenticatedUser)
{
if (Context != null)
{
try
{
authenticatedUser.CreationDate = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
authenticatedUser.Updated = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
//var refinedObject = authenticatedUser;
//refinedObject.CreationDate = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
//refinedObject.Updated = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
Context.AuthenticatedUsers.Add(authenticatedUser);
await Context.SaveChangesAsync();
var newUser = Context.AuthenticatedUsers.Where(user => user.UserName.Equals(authenticatedUser.UserName)).First();
if (newUser != null)
{
var newUserRole = await UserRoleHandler.Get.StoreRoleAsync(newUser.ID, roleType : RoleType.USER);
if (newUserRole != null)
{
return(new RegisteredUser
{
ID = newUser.ID,
FirstName = newUser.FirstName,
LastName = newUser.LastName,
Email = newUser.Email,
UserName = newUser.UserName,
Role = RoleType.USER.ToString(),
CreationDate = newUser.CreationDate,
Updated = newUser.Updated
});
}
}
}
catch (DbUpdateException) { }
catch (Exception) { }
}
return(null);
}
public IAuthenticatedUser Authenticate(AuthenticateParameters authParams)
{
var user = _userBusiness.AuthenticateUser(authParams.Login, authParams.Password);
if (user != null)
{
var issuedAt = _clock.UtcNow;
var jwtToken = _jwtOptions.Enabled
? new JwtSecurityToken(
issuer: _jwtOptions.Issuer,
claims: user.GetJwtClaims(issuedAt),
expires: issuedAt.LocalDateTime.Add(_jwtOptions.Duration),
signingCredentials: new SigningCredentials(new SymmetricSecurityKey(_jwtOptions.Key.ToBytes()), SecurityAlgorithms.HmacSha256))
: null;
return(AuthenticatedUser.Create(user, jwtToken == null ? null : new JwtSecurityTokenHandler().WriteToken(jwtToken)));
}
return(null);
}
public void OnComplete(Android.Gms.Tasks.Task task)
{
if (task.IsSuccessful)
{
// process document
var result = task.Result;
if (result is DocumentSnapshot doc)
{
var user = new AuthenticatedUser();
user.Id = doc.Id;
user.FirstName = doc.GetString("FirstName");
user.LastName = doc.GetString("LastName");
_tcs.TrySetResult(user);
return;
}
}
// somthing went wrong
_tcs.TrySetResult(default(AuthenticatedUser));
}
/// <summary>
/// Initializes a new instance of the MainViewModel class.
/// </summary>
public PluralsightMainViewModel(ILoginService loginService, ICourseService courseService, IConfigProvider configProvider)
{
_configProvider = configProvider;
CurrentUserAgent = _configProvider.UserAgent;
_courseService = courseService;
NumberOfSelectedCourses = 0;
AuthenticatedUser authenticatedUser = Newtonsoft.Json.JsonConvert.DeserializeObject <AuthenticatedUser>(loginService.LoginResultJson);
Title = $"{authenticatedUser.CurrentUser.FirstName} {authenticatedUser.CurrentUser.LastName} ({authenticatedUser.CurrentUser.Email})";
CourseTagSelectedCommand = new RelayCommand <string>(OnCourseTagSelected);
CancelDownloadsCommand = new RelayCommand(OnCancelDownloads, CanCancelDownload);
OpenDownloadsFolderCommand = new RelayCommand(OnOpenDownloadsFolder);
OpenSettingsWindowCommand = new RelayCommand(OnOpenSettingsWindow);
ProductCheckBoxToggledCommand = new RelayCommand <bool>(OnProductCheckBoxToggledCommand);
DownloadCourseCommand = new RelayCommand(OnDownloadCourseAsync, CanExecuteDownload);
NumberOfCoursesForTag = _courseService.CoursesByToolName.ToDictionary(kvp => kvp.Key, v => v.Value.Count);
AllCourses = _courseService.CoursesByToolName.Values.SelectMany(x => x).Distinct().ToList();
}
public ITestApiContext ParseBodyToContext(
RequestBody body,
IEnumerable <KeyValuePair <string, string> > queryKeyValuePairs,
AuthenticatedUser authenticatedUser,
EntityId organizationUnitId,
EntityId repositoryId)
{
var queryString = this.QueryStringToDictionary(queryKeyValuePairs);
if (body.Pagination != null)
{
queryString["Count"] = body.Pagination.Count.ToString(CultureInfo.InvariantCulture);
queryString["Offset"] = body.Pagination.Offset.ToString(CultureInfo.InvariantCulture);
}
queryString["Filters"] = body.Filters;
return(this.ParseQueryStringToContext(queryString, authenticatedUser, organizationUnitId, repositoryId));
}
public ProductDto Exec(SqlConnection db, AuthenticatedUser au, long Id)
{
var ret = repository.ProductById(db, Id);
if (ret == null)
{
Error = new ServiceError {
Message = "Invalid Product ID"
};
return(null);
}
var retCateg = repository.CategoryById(db, ret.ProductCategoryID);
var retSubCateg = repository.SubCategoryById(db, ret.ProductSubCategoryID);
if (au != null)
{
repository.ProductAddView(db, au.Id, Id);
}
var retComments = new System.Collections.Generic.List <NewProductComment>();
foreach (var item in repository.ProductComments(db, Id))
{
retComments.Add(new NewProductComment
{
Comment = item.Comment,
Date = item.DateAdded?.ToString("dd/MM/yyyy HH:mm"),
UserName = repository.UserById(db, (long)item.UserID)?.Name
});
}
return(new ProductDto
{
Id = ret.Id,
Name = ret.Name,
Views = repository.ProductViews(db, Id),
Category = retCateg.Name,
SubCategory = retSubCateg.Name,
Comments = retComments
});
}
public async Task Get_Settings_As_Existing_User_With_Notification()
{
// Arrange
var expectedNotifications = 1;
var expectedPlayAlwaysUp = true;
var user = new AuthenticatedUser()
{
Name = "abc",
PreferredUsername = "******",
UserIdentifier = "u",
ProviderIdentifier = "p"
};
await _context.UpsertAsync(TableNames.Users, new UserEntity()
{
PartitionKey = "u",
RowKey = "p",
UserID = "user123"
});
await _context.UpsertAsync(TableNames.UserSettings, new UserSettingEntity()
{
PartitionKey = "user123",
RowKey = "user123",
PlayAlwaysUp = true
});
await _context.UpsertAsync(TableNames.UserNotifications, new UserNotificationEntity()
{
PartitionKey = "user123",
RowKey = "user123",
Name = "Browser"
});
// Act
var actual = await _settingsHandler.GetSettingsAsync(user);
// Assert
Assert.NotNull(actual);
Assert.Equal(expectedNotifications, actual.Notifications.Count);
Assert.Equal(expectedPlayAlwaysUp, actual.PlayAlwaysUp);
}
protected async Task <UserEntity> GetOrCreateUserAsync(AuthenticatedUser authenticatedUser)
{
var user = await _context.GetAsync <UserEntity>(TableNames.Users,
authenticatedUser.UserIdentifier, authenticatedUser.ProviderIdentifier);
if (user == null)
{
_log.BaseHandlerCreateNewUser();
var userID = Guid.NewGuid().ToString("D");
var userEntity = new UserEntity
{
PartitionKey = authenticatedUser.UserIdentifier,
RowKey = authenticatedUser.ProviderIdentifier,
Name = authenticatedUser.Name,
UserID = userID,
Created = DateTime.UtcNow,
Enabled = true
};
await _context.UpsertAsync(TableNames.Users, userEntity);
var userID2UserEntity = new UserID2UserEntity
{
PartitionKey = userID,
RowKey = userID,
UserPrimaryKey = userEntity.PartitionKey,
UserRowKey = userEntity.RowKey
};
await _context.UpsertAsync(TableNames.UserID2User, userID2UserEntity);
_log.BaseHandlerNewUserCreated(userID);
return(userEntity);
}
else
{
_log.BaseHandlerExistingUserFound(user.UserID);
return(user);
}
}
public bool Authenticate(string user, string pass)
{
HelperClasses.Serializer srl = new HelperClasses.Serializer();
myService.ResponseItem ex_resp = new myService.ResponseItem();
//string fileExtension = VirtualPathUtility.GetFileName(filePath);
AuthenticatedUser auth_user = new AuthenticatedUser();
try
{
auth_user = TRUserAuthentication(user, pass);
}
catch (HttpRequestValidationException ex_http)
{
string ex_res = ex_http.ToString();
}
return auth_user.IsAuthenticated;
}
private static IEnumerable<Post> GetOrCreateDailyPosts(Reddit reddit, Subreddit subreddit, AuthenticatedUser user, int year, int month)
{
var firstDateOfMonth = new DateTime(year, month, 1);
var monthName = firstDateOfMonth.ToString("MMMM");
var createdPost = false;
var dailyPostDate = firstDateOfMonth;
var userPosts = user.Posts.ToList();
while (dailyPostDate.Month == month)
{
var dailyPostTitle = string.Format(DailyPostTitleFormat, year, monthName, dailyPostDate.Day);
var dailyPosts = userPosts.Where(p => p.Title == dailyPostTitle).OrderByDescending(p => p.Created);
if (dailyPosts.Any())
{
if (dailyPosts.Count() > 1)
reddit.ComposePrivateMessage("Multiple daily posts found", "Multiple posts found for " + dailyPostDate.ToShortDateString() + " post." + Environment.NewLine + string.Join(Environment.NewLine, dailyPosts.Select(p => p.Shortlink)), SubredditName);
yield return dailyPosts.First();
}
else
{
// Create the post for the day.
var post = subreddit.SubmitTextPost(dailyPostTitle, string.Format(DailyPostDescription, dailyPostDate.ToLongDateString()));
CreateDailyEvents(post, dailyPostDate.Year, dailyPostDate.Month, dailyPostDate.Day);
yield return post;
createdPost = true;
Thread.Sleep(10000); // Wait 10 seconds before creating another post
}
dailyPostDate = dailyPostDate.AddDays(1);
}
if (createdPost)
reddit.ComposePrivateMessage("New month worth of posts created", "Daily posts were created for " + monthName + ".", SubredditName);
}
//public static PlayVerseAPI GetInstance(PlayverseEnvironment env) {
// Instance = new PlayVerseAPI(env);
// return Instance;
//}
//Stub
public AuthenticatedUser Login(string email, string password)
{
AuthenticatedUser info = new AuthenticatedUser()
{
UserInfo = new Authenticated() {
isAuthenticated = false
},
};
try
{
info.UserSessionInfo = PVConnection.Get<UserAuth>().LoginWithPlayverse(email, password);
info.UserInfo.isAuthenticated = true;
}
catch (Exception ex)
{
Logger.Instance.Exception(ex.Message, ex.StackTrace);
PVConnection.Get<Logging>().AddLog(ErrorType.Exception, "MoniVerse PlayVerseAPI", "Login", Uuid.Empty, ex.Message, ex.StackTrace, ErrorLevel.Low);
}
return info;
}
public static void SetCredentials(AuthenticatedUser user, bool rememberMe)
{
DateTime expiration = rememberMe ? DateTime.Now.AddMonths(1) : DateTime.Now.AddHours(3);
FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(
1,
user.Name,
DateTime.Now,
expiration,
rememberMe,
user.ToString(),
FormsAuthentication.FormsCookiePath
);
string encTicket = FormsAuthentication.Encrypt(ticket);
HttpCookie cookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
if (rememberMe)
{
cookie.Expires = expiration;
}
HttpContext.Current.Response.Cookies.Add(cookie);
HttpContext.Current.Session.Add("app_user", user);
}
public virtual async Task<ActionResult> Create(NewUserViewModel model)
{
if (!ModelState.IsValid)
{
return View(model);
}
var user = new AuthenticatedUser(model.UserName, model.Email);
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
return RedirectToAction("success");
}
else
{
foreach (var errorMessage in result.Errors)
{
ModelState.AddModelError(string.Empty, errorMessage);
}
return View(model);
}
}
private User ToUser(XElement author)
{
var isAuth = author.Attribute("isAuthenticated");
if (isAuth != null && isAuth.Value == "true")
{
AuthenticatedUser retval;
var id = (long)author;
if (!authUserCache.TryGetValue(id, out retval))
authUserCache[id] = retval = new AuthenticatedUser(id);
return retval;
}
return new AnonymousUser
(
(string)author,
(string)author.Parent.Element(XName.Get("email", XmlnsExport))
);
}
private void mainWindowMenuDestroyDropDownRedditButton_Click(object sender, RoutedEventArgs e)
{
// Destroy Reddit user variable
redditUser = null;
redditConnection = null;
redditUsername = null;
redditPassword = null;
mainWindowMenuSetupDropDownRedditConnectButton.IsEnabled = true;
mainWindowMenuDestroyDropDownRedditButton.IsEnabled = false;
}
private void mainWindowMenuSetupDropDownRedditConnectButton_Click(object sender, RoutedEventArgs e)
{
RedditConnectionDialog redditConnectResult = new RedditConnectionDialog();
redditConnectResult.ShowDialog();
// Handle connection info dialog
if (redditConnectResult != null)
{
redditConnectResult.Close();
}
// Check for full information entry
if (redditUsername == "" || redditPassword == "" || redditUsername == null || redditPassword == null)
{
// User did not enter all required information, do not attempt to connect
appendErrorText(botOutputBox, "Please enter all required fields (Username, password)\r");
return;
}
try
{
redditUser = redditConnection.LogIn(redditUsername, redditPassword);
}
catch (AuthenticationException)
{
appendErrorText(botOutputBox, "Reddit login information provided did not authenticate.\rCheck that the provided username and password are correct.");
return;
}
isRedditConnected = true;
mainWindowMenuSetupDropDownRedditConnectButton.IsEnabled = false;
mainWindowMenuDestroyDropDownRedditButton.IsEnabled = true;
return;
}
public static object GetInfo(AuthenticatedUser.Info prop)
{
AuthenticatedUser user = GetAuthenticatedUser();
if (user != null)
{
switch (prop)
{
case AuthenticatedUser.Info.ID:
return user.ID;
case AuthenticatedUser.Info.Name:
return user.Name;
case AuthenticatedUser.Info.Role:
return user.Role;
}
}
return null;
}
public void login(string username, string password)
{
user = reddit.LogIn(username, password);
subreddit = reddit.GetSubreddit("/r/Dota2");
}
// TR User Authentication
// Windows Authentication, Without Windows Authentication, Hack Authentication
private AuthenticatedUser TRUserAuthentication(string user, string password)
{
AuthenticatedUser auth_user;
myService.Authentication UserAuth;
//---> Authentication Needed
if (blAuthenticationNeeded == false)
{
auth_user = new AuthenticatedUser(user, true, AuthenticationMethod.NoAuthentication);
return auth_user;
}
//--->
//---> Hack Authentication
bool sUser = false;
sUser = HashGen.VerifyCode(user, password);
if (sUser)
{
auth_user = new AuthenticatedUser(user, true, AuthenticationMethod.Hack);
return auth_user;
}
//--->
//---> TR Authentication
PSIntranet.Service.ServiceBase.PSIntranetServiceBase pb = new ServiceBase.PSIntranetServiceBase();
UserAuth = pb.AuthenticateUser(user, password);
if (UserAuth.Success)
{
auth_user = new AuthenticatedUser(user, true, AuthenticationMethod.Normal);
return auth_user;
}
else if (UserAuth.TRAuth)
{
auth_user = new AuthenticatedUser(user, false, AuthenticationMethod.Normal);
return auth_user;
}
else
{
//---> Windows Authentication
auth_user = LDAPAuthentication("LDAP://10.0.0.9",user,password);
return auth_user;
//--->
}
//--->
//auth_user = new AuthenticatedUser(user, false, AuthenticationMethod.Missing);
//return auth_user;
}
public PasswordAuthenticationResult(AuthenticationResult result, AuthenticatedUser authenticatedUser = null, int lockTimeRemainingMinutes = 0)
{
Result = result;
LockTimeRemainingMinutes = lockTimeRemainingMinutes;
AuthenticatedUser = authenticatedUser;
}
AuthenticatedUser LDAPAuthentication(string path, string user, string pass)
{
AuthenticatedUser authuser;
try
{
PrincipalContext ctx = new PrincipalContext(ContextType.Domain, "10.0.0.9:389", "CN=Time Report Web Service account,CN=Users,DC=process-solutions,DC=hu", "trwebservice", "th824EpuWret5nUs");
//PrincipalContext ctx = new PrincipalContext(ContextType.Domain, "10.0.0.9:389", "CN=Users,DC=process-solutions,DC=hu", "process/trwebservice", "th824EpuWret5nUs");
if (ctx.ValidateCredentials(user, pass))
{
authuser = new AuthenticatedUser(user, true, AuthenticationMethod.LDAP);
}
else
{
authuser = new AuthenticatedUser(user, false, AuthenticationMethod.LDAP);
//HelperClasses.WriteLog.WriteToLog(PSIntranet.Common.Constants.AppPath + PSIntranet.Common.Constants.DEFAULT_LOG_FILE, "Authentication failed : " + user);
}
}
catch (Exception ex)
{
//System.Windows.Forms.MessageBox.Show(ex.ToString());
authuser = new AuthenticatedUser(user, false, AuthenticationMethod.LDAP);
//HelperClasses.WriteLog.WriteToLog(PSIntranet.Common.Constants.AppPath + PSIntranet.Common.Constants.DEFAULT_LOG_FILE, "Exception: " + ex.ToString());
}
return authuser;
}
