public ActionResult Users(Guid?Id)
{
GetUserModel getUserNull = new GetUserModel();
getUserNull = null;
try
{
chatService = new WebChatService.ChatServiceClient();
var room = chatService.GetRoomList().FirstOrDefault(x => x.Id == Id);
WebChatService.User logUser = new WebChatService.User();
logUser.UserName = (Session["UserData"] as LoginUserModel).UserName;
logUser.Id = (Session["UserData"] as LoginUserModel).Id;
var users = chatService.JoinRoom(room, logUser);
return(View(new GetUserModel()
{
getUser = users,
RoomID = Id
}));
}
catch (Exception)
{
return(View(getUserNull));
}
}
public async Task <CustomResponse <UserResponse> > GetUser(GetUserModel model)
{
var infos = new List <string>();
return(await Task.Run(() => {
var user = _context.AspNetUsers.FirstOrDefault(u => u.Id == model.UserId);
#region Validate User
if (user == null)
{
infos.Add("User not exist.");
return new CustomResponse <UserResponse> {
Message = infos
};
}
;
#endregion
return new CustomResponse <UserResponse> {
Succeed = true,
Data = _mapper.Map <UserResponse>(user)
};
}));
}
public async Task <GetUserModel> GetUser(string id)
{
GetUserModel user = await _context.Users
.Include(x => x.UserRoles)
.Select(x => new GetUserModel
{
Id = x.Id,
FirstName = x.FirstName,
LastName = x.LastName,
Email = x.Email,
UserName = x.UserName,
Description = x.Description,
Roles = x.UserRoles.Select(x => x.Role.Name).ToList(),
Followers = (from follower in _context.UserFollowers
where follower.FollowingId == x.Id
select new GetUserModel
{
Id = follower.Id,
FirstName = follower.Follower.FirstName,
LastName = follower.Follower.LastName,
Description = follower.Follower.Description,
Email = follower.Follower.Email
}).ToList(),
Reviews = (from review in _context.Reviews
where review.UserId == x.Id
select new GetReviewModel
{
Id = review.Id,
MovieId = review.MovieId,
Rating = review.Rating,
Date = review.Date,
Description = review.Description,
UserId = review.UserId
}).ToList(),
Favorites = (from favorite in _context.Favorites
where favorite.UserId == x.Id
select new GetMovieModel
{
Id = favorite.MovieId,
Name = favorite.Movie.Name,
Year = favorite.Movie.Year,
OverallRating = favorite.Movie.OverallRating,
Duration = favorite.Movie.Duration,
Description = favorite.Movie.Description,
DirectorId = favorite.Movie.DirectorId,
GenreId = favorite.Movie.GenreId
}).ToList()
})
.AsNoTracking()
.FirstOrDefaultAsync(x => x.Id == Guid.Parse(id));
if (user == null)
{
throw new EntityException("User not found", this.GetType().Name, "GetUser", "404");
}
return(user);
}
public async Task AuthorizationCheck()
{
var json = await GetJsonByApi("user");
if (json != null)
{
User = JsonConvert.DeserializeObject <GetUserModel>(json);
}
}
public async Task <IActionResult> GetUsers()
{
var model = new GetUserModel {
Email = UserEmail
};
var fetchedUsers = await _user.GetUserList(model);
return(Ok(fetchedUsers));
}
public GetUserDetailModel GetUser(GetUserModel model)
{
using (var conn = GetSysDbConnection(_options.Value.DefaultConnection)) {
var getUsers = conn.Query <GetUserDetailModel>(SpGetUser, new {
model.UserId
},
commandType: CommandType.StoredProcedure).FirstOrDefault();
return(getUsers);
}
}
public async Task <ActionResult <GetUserModel> > PostUser(PostUserModel postUserModel)
{
try
{
GetUserModel user = await _userRepository.PostUser(postUserModel);
return(CreatedAtAction(nameof(GetUser), new { id = user.Id }, user));
}
catch (DatabaseException e)
{
return(BadRequest(e.MovieMindError));
}
}
public GetUsersModel GetUsers(GetUserModel model)
{
using (var conn = GetSysDbConnection(_options.Value.DefaultConnection)) {
var getUsersJson = conn.Query <GetUsersDataManagerModel>(SpGetUsers, new {
model.UserId
},
commandType: CommandType.StoredProcedure).ToList();
var mappedUsers = JsonConvert.DeserializeObject <GetUsersModel>(getUsersJson.FirstOrDefault()?.Users);
return(mappedUsers);
}
}
public async Task <CustomResponse <GetUsersModel> > GetUserList(GetUserModel model)
{
var user = await _userManager.FindByEmailAsync(model.Email);
var users = _usersDataManager.GetUsers(new GetUserModel()
{
UserId = user.Id
});
return(new CustomResponse <GetUsersModel> {
Succeed = true,
Data = users
});
}
public async Task <IActionResult> Delete(string id)
{
try
{
AuthorizeHelper.Authorize(this.HttpContext, "Administrator", this.GetType().Name, "Delete", "user");
GetUserModel getUserModel = await _moviemindAPIService.GetModel <GetUserModel>(id, "users");
return(View(getUserModel));
}
catch (MovieMindException e)
{
return(ErrorHelper.HandleError(e));
}
}
[ValidateAntiForgeryToken] // Prevents XSRF/CSRF attacks
public async Task <IActionResult> Index(PostUserModel postUserModel, string rememberMe)
{
if (postUserModel.Password != postUserModel.ConfirmPassword)
{
ModelState.AddModelError("ConfirmPassword", _localizer["Passwords are not the same"]);
}
if (ModelState.IsValid)
{
try
{
if (postUserModel.Roles == null)
{
postUserModel.Roles = new List <String>
{
"Guest"
};
}
else if (postUserModel.Roles.Count == 0)
{
postUserModel.Roles.Add("Guest");
}
// Send an API request to create the new user
GetUserModel getUserModel = await _moviemindAPIService.PostModel <PostUserModel, GetUserModel>(postUserModel, "users");
// When the user was successfully created send an API request to authenticate the new user
PostAuthenticateRequestModel postAuthenticateRequestModel = new PostAuthenticateRequestModel
{
UserName = postUserModel.UserName,
Password = postUserModel.Password,
};
PostAuthenticateResponseModel postAuthenticateResponseModel = await _moviemindAPIService.Authenticate(postAuthenticateRequestModel);
_stateManagementService.SetState(postAuthenticateResponseModel);
// Redirect to the home page
return(RedirectToRoute(new { action = "Index", controller = "Home" }));
}
catch (MovieMindException e)
{
TempData["ApiError"] = e.Message;
}
}
return(View(postUserModel));
}
public GetUserModel GetByUserName(string username)
{
var model = _userRepository.GetSingleUser(username.ToLowerInvariant());
if (model == null)
{
throw new HttpNotFoundException($"User with username: {username} was not found");
}
var userModel = new GetUserModel
{
Id = model.Id,
Username = model.UserName,
Active = model.Active,
EmailAddress = model.EmailAddress
};
return(userModel);
}
public GetUserModel GetByEmailAddress(string emailAddress)
{
var model = _userRepository.GetSingleUserEmail(emailAddress);
if (model == null)
{
throw new HttpNotFoundException($"User with emailaddress: {emailAddress} was not found");
}
var emailModel = new GetUserModel
{
Id = model.Id,
Username = model.UserName,
Active = model.Active,
EmailAddress = model.EmailAddress
};
return(emailModel);
}
public GetUserModel GetById(int id)
{
var model = _userRepository.GetSingleUser(id);
if (model == null)
{
throw new HttpNotFoundException($"User with id: {id} was not found");
}
var idModel = new GetUserModel
{
Id = model.Id,
Username = model.UserName,
Active = model.Active,
EmailAddress = model.EmailAddress
};
return(idModel);
}
public bool AuthorizeUser(GetUserModel user, string password)
{
try
{
//var isValid = PasswordManager.ValidatePassword(password, user.Password);
if (user != null)
{
_authUser = user;
return(true);
}
}
catch (Exception exc)
{
Debug.WriteLine(exc);
}
return(false);
}
private async void MakeLoginAsync()
{
using (StartOperation())
{
GetUserModel user = await GetUserOperation.ExecuteAsync(Login);
if (user == null || !SecurityManager.AuthorizeUser(user, Password))
{
Message = "Логин или пароль введены неправильно";
}
else
{
var mainViewModel = ServiceLocator.GetInstance <MainViewModel>();
mainViewModel.InitializeAsync();
mainViewModel.Show();
await Close();
}
}
}
public async Task <IActionResult> Details(string id)
{
try
{
AuthorizeHelper.Authorize(this.HttpContext, "Guest", this.GetType().Name, "Details", "user");
GetUserModel getUserModel = await _moviemindAPIService.GetModel <GetUserModel>(id, "users");
foreach (GetReviewModel getReview in getUserModel.Reviews)
{
getReview.Movie = await _moviemindAPIService.GetModel <GetMovieModel>(getReview.MovieId.ToString(), "movies");
getReview.User = await _moviemindAPIService.GetModel <GetUserModel>(getReview.UserId.ToString(), "users");
}
var userId = HttpContext.Session.GetString("_Id");
var user = await _moviemindAPIService.GetModel <GetUserModel>(userId, "users");
ViewBag.IsFollower = false;
foreach (GetUserModel follower in getUserModel.Followers)
{
if (follower.Email == user.Email)
{
ViewBag.IsFollower = true;
}
}
if (getUserModel.Id == user.Id)
{
return(View("Profile", getUserModel));
}
else
{
return(View("Details", getUserModel));
}
}
catch (MovieMindException e)
{
return(ErrorHelper.HandleError(e));
}
}
[ValidateAntiForgeryToken] // Prevents XSRF/CSRF attacks
public async Task <IActionResult> Delete(string id, GetUserModel getUserModel)
{
try
{
AuthorizeHelper.Authorize(this.HttpContext, "Administrator", this.GetType().Name, "Delete", "user");
GetUserModel user = await _moviemindAPIService.GetModel <GetUserModel>(id, "users");
foreach (GetReviewModel getReviewModel in user.Reviews)
{
await _moviemindAPIService.DeleteModel(getReviewModel.Id.ToString(), "reviews");
}
//delete user favorites
List <GetFavoriteModel> getFavoriteModels = await _moviemindAPIService.GetModels <GetFavoriteModel>("favorites");
List <GetFavoriteModel> favoritesToDelete = getFavoriteModels.Where(x => x.UserId == user.Id).ToList();
foreach (GetFavoriteModel favoriteModel in favoritesToDelete)
{
await _moviemindAPIService.DeleteModel(favoriteModel.Id.ToString(), "favorites");
}
//delete user follower and followings
List <GetUserFollowerModel> getUserFollowerModels = await _moviemindAPIService.GetModels <GetUserFollowerModel>("userfollowers");
List <GetUserFollowerModel> userFollowersToDelete = getUserFollowerModels.Where(x => x.FollowerId == user.Id || x.FollowingId == user.Id).ToList();
foreach (GetUserFollowerModel getUserFollowerModel in userFollowersToDelete)
{
await _moviemindAPIService.DeleteModel(getUserFollowerModel.Id.ToString(), "userfollowers");
}
await _moviemindAPIService.DeleteModel(id, "users");
return(RedirectToRoute(new { action = "Index", controller = "Users" }));
}
catch (MovieMindException e)
{
return(ErrorHelper.HandleError(e, this.View(getUserModel)));
}
}
public async Task <CustomResponse <UserResponse> > GetUser(GetUserModel model)
{
return(await Task.Run(() => {
var user = _usersDataManager.GetUser(new GetUserModel {
UserId = model.UserId
});
#region Validate User
if (user == null)
{
_infos.Add("User not exist.");
return new CustomResponse <UserResponse> {
Message = _infos
};
}
;
#endregion
return new CustomResponse <UserResponse> {
Succeed = true,
Data = new UserResponse {
Detail = new UserDetails {
Id = user.UserId,
UserName = user.UserName,
Email = user.Email,
Fullname = user.Fullname,
Role = user.Role,
MobileNumber = user.MobileNumber,
BackgroundSummary = user.BackgroundSummary,
Skill = user.Skill,
CreatedAt = user.CreatedAt,
UpdatedAt = user.UpdatedAt
},
ProfilePicture = GetProfilePicture(user.UserId),
Location = GetUserLocation(user.UserId)
}
};
}));
}
public async Task <ActionResult <GetUserModel> > GetUserByIdAsync(string userId)
{
var user = await usersRepository.GetByIdAsync(userId);
if (user is null)
{
return(NotFound());
}
var getUser = new GetUserModel
{
Name = user.DisplayName,
PhoneNumber = user.PhoneNumber,
EmailAddress = user.Email,
Disabled = user.Disabled,
PrimaryOrganisationId = user.PrimaryOrganisationId,
};
return(Ok(getUser));
}
public async Task <Result <bool> > DeleteUser([FromBody] GetUserModel getUserModel)
{
var user = await userService.GetAsync(getUserModel.PublicId);
if (user == null)
{
throw new AppValidationException(ErrorMessagesLibrary.Data[ErrorMessagesLibrary.Keys.CantFindUser]);
}
var context = HttpContext;
if (user.Id == Convert.ToInt32(_userManager.GetUserId(User)))
{
throw new AppValidationException(ErrorMessagesLibrary.Data[ErrorMessagesLibrary.Keys.CurrentUserRemoval]);
}
await userService.DeleteAsync(user);
return(true);
}
public async Task <IActionResult> Edit(string id)
{
try
{
AuthorizeHelper.Authorize(this.HttpContext, "Administrator", this.GetType().Name, "Edit", "user");
GetUserModel getUserModel = await _moviemindAPIService.GetModel <GetUserModel>(id, "users");
PutUserModel putUserModel = new PutUserModel
{
FirstName = getUserModel.FirstName,
LastName = getUserModel.LastName,
Email = getUserModel.Email,
Roles = getUserModel.Roles
};
return(View(putUserModel));
}
catch (MovieMindException e)
{
return(ErrorHelper.HandleError(e));
}
}
public static async Task GetUserById_WithExistingUserId_ReturnsTheUser()
{
var context = UsersControllerTestContext.Setup();
context.User = ApplicationUserBuilder.Create().Build();
var expected = new GetUserModel
{
Name = context.User.FirstName + " " + context.User.LastName,
PhoneNumber = context.User.PhoneNumber,
EmailAddress = context.User.Email,
Disabled = context.User.Disabled,
PrimaryOrganisationId = context.User.PrimaryOrganisationId,
};
var controller = context.Controller;
var result = await controller.GetUserByIdAsync(context.User.Id);
result.Result.Should().BeOfType <OkObjectResult>();
result.Result.As <OkObjectResult>().Value.Should().BeOfType <GetUserModel>();
result.Result.As <OkObjectResult>().Value.Should().BeEquivalentTo(expected);
}
public IActionResult GetById(
Guid id)
{
var getUserModel = new GetUserModel()
{
Id = id,
User = User,
};
GetUserResult result;
Exception ex;
if (!_getUserQuery.TryExecute(getUserModel, out result, out ex))
{
Logger
.WithException(ex)
.WithField(nameof(User), User.Identity.Name)
.Error("failed to get user by id");
return(NotFound());
}
return(Ok(result.User));
}
public async Task <IActionResult> GetUser(GetUserModel model)
{
var gotUser = await _user.GetUser(model);
return(Ok(gotUser));
}
