public async Task Handle_SetsDraftToFalse_WhenThereIsAParentId(bool intitialStatus)
{
//arrange
var owner = new User {
Username = "******"
};
DbContext.Users.Add(owner);
var parent = new Prompt {
Owner = owner
};
DbContext.Prompts.Add(parent);
await DbContext.SaveChangesAsync();
var user = new GetUserViewModel {
Id = owner.Id
};
_mockUserService.Setup(e => e.TryGetCurrentUser(out user)).Returns(true);
var command = new CreatePromptCommand {
OwnerId = user.Id, SaveDraft = intitialStatus, ParentId = parent.Id
};
//act
var actual = await _handler.Handle(command);
//assert
Prompt?actualPrompt = DbContext.Prompts.Find(actual);
Assert.False(actualPrompt.IsDraft);
}
public ActionResult Get(string userId)
{
if (string.IsNullOrWhiteSpace(userId))
{
return(RedirectLocal("/"));
}
IdentityUser userProfile = UserManager.FindById(userId);
if (userProfile == null)
{
return(RedirectLocal("/"));
}
GetUserViewModel viewModel = new GetUserViewModel
{
Id = userProfile.Id,
LastPost = userProfile.LastPost,
Nick = userProfile.Nick,
RecentPosts = userProfile.RecentPosts,
UserName = userProfile.UserName
};
return(View(viewModel));
}
Handle_ThrowsCreatePromptUnauthorizedParentException_WhenParentIdIsGiven_AndTheCurrentUserIsNotTheSameId()
{
//arrange
var owner = new User {
Username = "******"
};
var ownerTwo = new User {
Username = "******"
};
DbContext.Users.Add(owner);
DbContext.Users.Add(ownerTwo);
await DbContext.SaveChangesAsync();
var parent = new Prompt {
OwnerId = owner.Id
};
DbContext.Prompts.Add(parent);
await DbContext.SaveChangesAsync();
var user = new GetUserViewModel {
Id = ownerTwo.Id
};
_mockUserService.Setup(e => e.TryGetCurrentUser(out user)).Returns(true);
var command = new CreatePromptCommand {
ParentId = parent.Id
};
//act + assert
await Assert.ThrowsAsync <CreatePromptUnauthorizedParentException>(
async() => await _handler.Handle(command));
}
public async Task <IActionResult> GetAllUser([FromQuery] GetUserViewModel model)
{
PageInfoHelper <User> result = await _userService.GetAllUser(model);
Response.Headers.Add("Pagination-X", JsonSerializer.Serialize(result.TotalCount));
return(Ok(result));
}
public async Task Handle_UpdatesAPromptWithNovelAiScenarioSetToExpectedValue()
{
//arrange
const string?expectedString = null;
var owner = new User {
Username = "******"
};
var prompt = new Prompt {
Owner = owner
};
DbContext.Prompts.Add(prompt);
await DbContext.SaveChangesAsync();
var user = new GetUserViewModel {
Id = owner.Id
};
_mockUserService.Setup(e => e.TryGetCurrentUser(out user)).Returns(true);
var command = new UpdatePromptCommand {
Id = prompt.Id, OwnerId = user.Id, NovelAiScenario = expectedString
};
//act
await _handler.Handle(command);
//assert
Prompt?actualPrompt = await DbContext.Prompts.FindAsync(prompt.Id);
Assert.Equal(expectedString, actualPrompt.NovelAiScenario);
}
public async Task Handle_ThrowsDeletePromptUserUnauthorizedException_WhenTheUserIdDoesNotMatchPromptOwnerId(
int userId)
{
//arrange
var owner = new User {
Username = "******"
};
var prompt = new Prompt {
Owner = owner
};
DbContext.Add(prompt);
await DbContext.SaveChangesAsync();
var user = new GetUserViewModel {
Id = userId
};
_mockUserService.Setup(e => e.TryGetCurrentUser(out user)).Returns(true);
var command = new DeletePromptCommand(prompt.Id);
//act + assert
await Assert.ThrowsAsync <DeletePromptUserUnauthorizedException>(async() => await _handler.Handle(command));
}
public async Task Handle_RemovesPrompt_WhenUserHasDeletePermission(int expectedPromptCount)
{
//arrange
var prompt = new Prompt();
DbContext.Add(prompt);
for (var i = 0; i < expectedPromptCount; i++)
{
DbContext.Add(new Prompt());
}
await DbContext.SaveChangesAsync();
var user = new GetUserViewModel {
Role = RoleEnum.Delete
};
_mockUserService.Setup(e => e.TryGetCurrentUser(out user)).Returns(true);
var command = new DeletePromptCommand(prompt.Id);
//act
await _handler.Handle(command);
//assert
Assert.Equal(expectedPromptCount, await DbContext.Prompts.CountAsync());
}
public async Task Handle_ReturnsPrompt_IfPromptIsDraft_AndUserServiceReturnsUserWithCorrectId()
{
//arrange
var owner = new User {
Username = "******"
};
var prompt = new Prompt {
IsDraft = true, Owner = owner
};
DbContext.Prompts.Add(prompt);
await DbContext.SaveChangesAsync();
var user = new GetUserViewModel {
Id = owner.Id
};
_mockUserService.Setup(e => e.TryGetCurrentUser(out user)).Returns(true);
var query = new GetPromptQuery(prompt.Id);
//act
GetPromptViewModel?result = await _handler.Handle(query);
//assert
Assert.NotNull(result);
Assert.True(result.IsDraft);
}
public async Task Handle_SetsAPromptWithScriptZipSetToNull()
{
//arrange
var owner = new User {
Username = "******"
};
var prompt = new Prompt {
Owner = owner
};
DbContext.Prompts.Add(prompt);
await DbContext.SaveChangesAsync();
var user = new GetUserViewModel {
Id = owner.Id
};
_mockUserService.Setup(e => e.TryGetCurrentUser(out user)).Returns(true);
var command = new UpdatePromptCommand {
Id = prompt.Id, OwnerId = user.Id, ScriptZip = null
};
//act
await _handler.Handle(command);
//assert
Prompt?actualPrompt = await DbContext.Prompts.FindAsync(prompt.Id);
Assert.Null(actualPrompt.ScriptZip);
}
public async Task Handle_DoesNotChangeDraftStatus_WhenUserIsNotOwner(bool expectedDraftStatus)
{
//arrange
var owner = new User {
Username = "******"
};
var prompt = new Prompt {
IsDraft = expectedDraftStatus, Owner = owner
};
DbContext.Prompts.Add(prompt);
await DbContext.SaveChangesAsync();
var user = new GetUserViewModel {
Id = int.MaxValue, Role = RoleEnum.FieldEdit
};
_mockUserService.Setup(e => e.TryGetCurrentUser(out user)).Returns(true);
var command = new UpdatePromptCommand {
Id = prompt.Id, SaveDraft = !expectedDraftStatus
};
//act
await _handler.Handle(command);
//assert
Prompt?actual = DbContext.Prompts.Find(prompt.Id);
Assert.Equal(expectedDraftStatus, actual.IsDraft);
}
public async Task Handle_SetsIsDraftToTrue_WhenSaveDraftIsTrue(bool initialDraftStatus)
{
//arrange
var owner = new User {
Username = "******"
};
var prompt = new Prompt {
IsDraft = initialDraftStatus, Owner = owner
};
DbContext.Prompts.Add(prompt);
await DbContext.SaveChangesAsync();
var user = new GetUserViewModel {
Id = owner.Id
};
_mockUserService.Setup(e => e.TryGetCurrentUser(out user)).Returns(true);
var command = new UpdatePromptCommand {
Id = prompt.Id, SaveDraft = true
};
//act
await _handler.Handle(command);
//assert
Prompt?actual = DbContext.Prompts.Find(prompt.Id);
Assert.True(actual.IsDraft);
}
public async Task Handle_DoesNotChangePublishDate_WhenItHasValue(bool initialDraftStatus,
bool updatedDraftStatus)
{
//arrange
DateTime expectedDate = DateTime.UtcNow;
var owner = new User {
Username = "******"
};
var prompt = new Prompt {
IsDraft = initialDraftStatus, Owner = owner, PublishDate = expectedDate
};
DbContext.Prompts.Add(prompt);
await DbContext.SaveChangesAsync();
var user = new GetUserViewModel {
Id = owner.Id, Role = RoleEnum.FieldEdit
};
_mockUserService.Setup(e => e.TryGetCurrentUser(out user)).Returns(true);
var command = new UpdatePromptCommand {
Id = prompt.Id, SaveDraft = updatedDraftStatus
};
//act
await _handler.Handle(command);
//assert
Prompt?actual = DbContext.Prompts.Find(prompt.Id);
Assert.Equal(expectedDate, actual.PublishDate);
}
public async Task Handle_LeavesPublishNull_WhenSaveDraftIsTrue_AndPromptHasNoPublishDate_AndWasDraft()
{
//arrange
var owner = new User {
Username = "******"
};
var prompt = new Prompt {
IsDraft = true, Owner = owner
};
DbContext.Prompts.Add(prompt);
await DbContext.SaveChangesAsync();
var user = new GetUserViewModel {
Id = owner.Id, Role = RoleEnum.FieldEdit
};
_mockUserService.Setup(e => e.TryGetCurrentUser(out user)).Returns(true);
var command = new UpdatePromptCommand {
Id = prompt.Id, SaveDraft = true
};
//act
await _handler.Handle(command);
//assert
Prompt?actual = DbContext.Prompts.Find(prompt.Id);
Assert.Null(actual.PublishDate);
}
public async Task Authenticate_User_Success()
{
AuthenticateUserViewModel user = new AuthenticateUserViewModel
{
Email = UserWebApiTest.Email,
Password = UserWebApiTest.Password
};
GetUserViewModel registeredUser = new GetUserViewModel
{
Email = UserWebApiTest.Email,
FirstName = UserWebApiTest.FirstName,
LastName = UserWebApiTest.LastName,
Id = 1,
Token = "token",
};
Response <GetUserViewModel> response = new Response <GetUserViewModel>(success: true, errors: null, data: registeredUser);
_userServiceMock.Setup(x => x.AuthenticateAsync(It.IsAny <AuthenticateUserViewModel>()))
.Returns(Task.FromResult(response));
//Act
UserController userController = new UserController(_userServiceMock.Object, _loggerMock.Object);
OkObjectResult result = await userController.AuthenticateUserAsync(user) as OkObjectResult;
//Assert
result.StatusCode.Should()
.Be((int)System.Net.HttpStatusCode.OK);
}
public async Task Handle_RemovesPrompt_WhenUserIsOwner(int expectedPromptCount)
{
//arrange
var owner = new User {
Username = "******"
};
var prompt = new Prompt {
Owner = owner
};
DbContext.Add(prompt);
for (var i = 0; i < expectedPromptCount; i++)
{
var extraPrompt = new Prompt();
DbContext.Add(extraPrompt);
}
await DbContext.SaveChangesAsync();
var user = new GetUserViewModel {
Id = owner.Id
};
_mockUserService.Setup(e => e.TryGetCurrentUser(out user)).Returns(true);
var command = new DeletePromptCommand(prompt.Id);
//act
await _handler.Handle(command);
//assert
Assert.Equal(expectedPromptCount, await DbContext.Prompts.CountAsync());
}
public async Task Handle_CreatesAPromptWithTheParentId_WhenParentIdIsGiven_AndTheCurrentUserIsTheSameId()
{
//arrange
var owner = new User {
Username = "******"
};
DbContext.Users.Add(owner);
await DbContext.SaveChangesAsync();
var parent = new Prompt {
OwnerId = owner.Id
};
DbContext.Prompts.Add(parent);
await DbContext.SaveChangesAsync();
var user = new GetUserViewModel {
Id = owner.Id
};
_mockUserService.Setup(e => e.TryGetCurrentUser(out user)).Returns(true);
var command = new CreatePromptCommand {
ParentId = parent.Id, OwnerId = owner.Id
};
//act
var actual = await _handler.Handle(command);
//assert
Prompt?actualPrompt = await DbContext.Prompts.FindAsync(actual);
Assert.NotNull(actualPrompt);
Assert.Equal(parent.Id, actualPrompt.ParentId);
}
public async Task <Response <GetUserViewModel> > CreateAsync(CreateUserViewModel model)
{
CreateUserViewModelValidation validator = new CreateUserViewModelValidation();
ValidationResult result = validator.Validate(model);
if (!result.IsValid)
{
Response <GetUserViewModel> response = new Response <GetUserViewModel>(success: false, errors: result.Errors.Select(x => x.ErrorMessage).ToArray());
return(response);
}
User user = await _userRepository.GetByEmailAsync(model.Email);
if (user != null)
{
Response <GetUserViewModel> response = new Response <GetUserViewModel>(success: false, errors: new[] { "This user already exists." });
return(response);
}
PasswordHasher <User> passwordHasher = new PasswordHasher <User>();
string hashed = passwordHasher.HashPassword(user, model.Password);
User newUser = new User(
email: model.Email,
lastName: model.LastName,
firstName: model.FirstName,
password: hashed);
_userRepository.Create(newUser);
bool created = await _userRepository.UnitOfWork.SaveChangesAsync() > 0;
if (!created)
{
Response <GetUserViewModel> response = new Response <GetUserViewModel>(success: false, errors: new[] { "Unable to create user, try again later." });
return(response);
}
User createdUser = await _userRepository.GetByEmailAsync(newUser.Email);
string token = _tokenService.GenerateToken(createdUser);
GetUserViewModel responseViewModel = new GetUserViewModel
{
Id = createdUser.Id,
FirstName = createdUser.FirstName,
LastName = createdUser.LastName,
Token = token,
Email = createdUser.Email,
Guid = createdUser.Guid
};
return(new Response <GetUserViewModel>(success: true, errors: null, data: responseViewModel));
}
//string dbPath = Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal), "myDB.db3");
public GetAllUserPage()
{
InitializeComponent();
BindingContext = new GetUserViewModel();
//BindingContext = new GetAllUserPage();
//var db = new SQLiteConnection(dbPath);
//UsersListView.ItemsSource = db.Table<User>().OrderBy(x => x.Name).ToList();
}
public async Task <IActionResult> Create([FromForm] CreateUserViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var existUser = await _userManager.FindByNameAsync(model.UserName);
if (existUser != null)
{
return(BadRequest());
}
if (!Regex.IsMatch(model.UserName, @"^09(1[0-9]|3[1-9]|2[1-9])-?[0-9]{3}-?[0-9]{4}$"))
{
return(BadRequest());
}
var user = new ApplicationUser();
user.UserName = model.UserName;
user.PhoneNumber = model.UserName;
user.PhoneNumberConfirmed = true;
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var addToRole = await _userManager.AddToRoleAsync(user, model.Role);
if (addToRole.Succeeded)
{
//create profile
var profile = new Profile();
profile.AccountId = user.Id;
profile.Account = user;
await _context.Profiles.AddAsync(profile);
bool addedProfile = Convert.ToBoolean(await _context.SaveChangesAsync());
// send registerd sms successfully with password;
if (addedProfile)
{
var sendedMessage = await _messageService.SendRegisterSuccessfullySms(user.UserName, model.Password);
if (sendedMessage)
{
var viewModel = new GetUserViewModel();
viewModel.UserName = user.UserName;
viewModel.Role = model.Role;
return(Ok(viewModel));
}
}
}
}
return(BadRequest());
}
/// <summary>
/// 默认获取所有用户,如果有部门名将查询对应的部门人员
/// </summary>
/// <param name=""></param>
/// <returns></returns>
public async Task <PageInfoHelper <User> > GetAllUser(GetUserViewModel model)
{
IQueryable <User> result = _userRepository.GetAllByOrder().OrderBy(m => m.DepartmentId).ThenBy(m => m.EmpNo).Include(m => m.Department);
if (model.DeptId != Guid.Empty)
{
result = result.Where(m => m.DepartmentId == model.DeptId);
}
return(await PageInfoHelper <User> .CreatePageMsgAsync(result, model.PageNumber, model.PageSize));
}
public async Task <IActionResult> Get([FromBody] GetUserViewModel model)
{
try
{
var response = await _service.GetUser(User, model, ModelState);
return(response.JsonResult());
}
catch (Exception error)
{
_logger.Error(error);
return(StandardResponse.Forbidden().JsonResult());
}
}
public async Task <Response <GetUserViewModel> > AuthenticateAsync(AuthenticateUserViewModel model)
{
AuthenticateUserViewModelValidator validator = new AuthenticateUserViewModelValidator();
ValidationResult result = validator.Validate(model);
if (!result.IsValid)
{
Response <GetUserViewModel> response = new Response <GetUserViewModel>(success: false, errors: result.Errors.Select(x => x.ErrorMessage).ToArray());
return(response);
}
User user = await _userRepository.GetByEmailAsync(model.Email);
if (user == null)
{
Response <GetUserViewModel> response = new Response <GetUserViewModel>(success: false, errors: new[] { "This user doesn't exist. " });
return(response);
}
PasswordHasher <User> passwordHasher = new PasswordHasher <User>();
PasswordVerificationResult pvr = passwordHasher.VerifyHashedPassword(user, user.Password, model.Password);
if (pvr == PasswordVerificationResult.Failed)
{
Response <GetUserViewModel> response = new Response <GetUserViewModel>(success: false, errors: new[] { "Wrong user/password combination, friend. " });
return(response);
}
string token = _tokenService.GenerateToken(user);
GetUserViewModel responseUserViewModel = new GetUserViewModel
{
Id = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
Token = token,
Email = user.Email,
Guid = user.Guid
};
return(new Response <GetUserViewModel>(success: true, data: responseUserViewModel, errors: null));
}
public async Task <IActionResult> GetUserByName(string userName)
{
var user = await _userManager.FindByNameAsync(userName);
if (user == null)
{
return(NotFound());
}
var viewModel = new GetUserViewModel();
viewModel.UserName = user.UserName;
viewModel.IsValid = user.IsValid;
var roles = await _userManager.GetRolesAsync(user);
viewModel.Role = roles[0];
return(Ok(viewModel));
}
public async Task <StandardResponse> GetUser(ClaimsPrincipal identity, GetUserViewModel model, ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
return(modelState.StandardError());
}
using (var db = new ServiceDb())
{
using (var user = await _userService.Become(db, identity, null))
{
var otherUser = await _userService.Get(db, model.Id);
return(StandardResponse.For(UserViewModel.From(otherUser)));
}
}
}
public async Task Handle_ReturnsNull_WhenTopLevelParentIsDraft_AndUserServiceReturnsUserWithWrongId(int depth)
{
//arrange
var owner = new User {
Username = "******"
};
var newUser = new User {
Username = "******"
};
DbContext.Users.Add(newUser);
var parent = new Prompt {
IsDraft = true, Owner = owner
};
DbContext.Prompts.Add(parent);
await DbContext.SaveChangesAsync();
var id = parent.Id;
for (var i = 0; i < depth; i++)
{
var child = new Prompt {
IsDraft = false, Owner = owner, ParentId = id
};
DbContext.Prompts.Add(child);
await DbContext.SaveChangesAsync();
id = child.Id;
}
var user = new GetUserViewModel {
Id = newUser.Id
};
_mockUserService.Setup(e => e.TryGetCurrentUser(out user)).Returns(true);
var query = new GetPromptQuery(id);
//act
GetPromptViewModel?result = await _handler.Handle(query);
//assert
Assert.Null(result);
}
public void TestMethodApiUser_ListUsers()
{
var contrlUser = new UserController();
//var conex = ToDoList_DB.getInstance().singleton;
var user = new GetUserViewModel()
{
cd_user = "",
createdOnDate = DateTime.Now,
nm_user = "******",
pageIndex = 1,
pageTotal = 3
};
// var lstUsers = contrlUser.GetAllUsers(user);
Assert.AreEqual(HttpStatusCode.BadRequest, "404");
}
public HttpResponseMessage SaveUser([FromBody] GetUserViewModel user)
{
try
{
ToDoList_DB.getInstance().singleton.As <User_DB>().pr_user_save(iVch_cd_user: user.cd_user,
iVch_nm_user: user.cd_user);
var vTest = new
{
data = "Successfull"
};
return(Request.CreateResponse(HttpStatusCode.OK, vTest));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex.ToString()));
}
}
public async Task Handle_RemovesPrompt_AndAllItsChildren_AndAllSubChildren_WhenUserIsOwner(
int expectedPromptCount, int childDepth)
{
//arrange
var owner = new User {
Username = "******"
};
var child = new Prompt();
var prompt = new Prompt {
Children = new List <Prompt> {
child
}, Owner = owner
};
for (var i = 0; i < childDepth; i++)
{
var newChild = new Prompt();
child.Children.Add(newChild);
child = newChild;
}
DbContext.Add(prompt);
for (var i = 0; i < expectedPromptCount; i++)
{
DbContext.Add(new Prompt());
}
await DbContext.SaveChangesAsync();
var user = new GetUserViewModel {
Id = owner.Id
};
_mockUserService.Setup(e => e.TryGetCurrentUser(out user)).Returns(true);
var command = new DeletePromptCommand(prompt.Id);
//act
await _handler.Handle(command);
//assert
Assert.Equal(expectedPromptCount, await DbContext.Prompts.CountAsync());
}
public HttpResponseMessage GetAllUsers([FromBody] GetUserViewModel user)
{
try
{
var resp = ToDoList_DB.getInstance().singleton.As <User_DB>().pr_user_list(iVch_cd_user: user.cd_user,
iVch_nm_user: user.cd_user,
pageIndex: user.pageIndex,
pageTotal: user.pageTotal);
var vTest = new
{
data = resp
};
return(Request.CreateResponse(HttpStatusCode.OK, vTest));
}
catch (Exception ex) {
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex.ToString()));
}
}
public async Task Handle_ThrowsDeletePromptDoesNotExistException_WhenPromptIdDoesNotExist(int id)
{
//arrange
var owner = new User {
Username = "******"
};
DbContext.Users.Add(owner);
await DbContext.SaveChangesAsync();
var user = new GetUserViewModel {
Id = owner.Id
};
_mockUserService.Setup(e => e.TryGetCurrentUser(out user)).Returns(true);
var command = new DeletePromptCommand(id);
//act + assert
await Assert.ThrowsAsync <DeletePromptDoesNotExistException>(async() => await _handler.Handle(command));
}
