public ActionResult LikedPosts()
{
ApplicationUser currentUser = db.Users.FirstOrDefault(u => u.UserName == User.Identity.Name);
List <Post> likedPosts = new List <Post>();
var pairs = db.UserPostPairs.Include(p => p.user).Include(p => p.post).Distinct();
foreach (UserPostLikedPair up in pairs)
{
if (up.post != null)
{
if (up.user.Id == currentUser.Id && !likedPosts.Contains(up.post))
{
Post post = db.Posts.Find(up.post.Id);
likedPosts.Add(post);
}
}
}
UserPostViewModel model = new UserPostViewModel
{
CurrentUser = currentUser,
AllPosts = likedPosts
};
return(View(model));
}
public void AddSuggestionAsync(UserPostViewModel userPost)
{
var suggestion = _mapper.Map <Suggestion>(userPost);
_suggestionBoxRepository.InsertData(suggestion);
//SendNotificationEmail();
}
public ServiceResult AddUser(UserPostViewModel entity)
{
var userRoles = userRoleService.GetUserRolesByIds(entity.UserRoleIds);
// TODO: Send mail
var password = CreateRandomPassword();
if (userRepository.Get(w => w.Username == entity.Username) != null)
{
return(new ServiceResult(false, "Username already exist."));
}
if (userRepository.Get(w => w.Mail == entity.Mail) != null)
{
return(new ServiceResult(false, "Mail already exist."));
}
userRepository.Add(new User
{
Username = entity.Username,
Mail = entity.Mail,
UserRoles = userRoles,
Password = password,
IsActive = entity.IsActive
});
return(ServiceResult.GetAddResult(uow.Commit() > 0));
}
public async Task <IActionResult> Register(UserPostViewModel user)
{
if (ModelState.IsValid)
{
using (var httpClient = new HttpClient())
{
var requestUri = $"{Configuration.DefaultAPI}/{CurrentControllerName}/{nameof(Register)}";
using (var response = await httpClient.PostAsJsonAsync(requestUri, user))
{
var content = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
user = JsonConvert.DeserializeObject <UserPostViewModel>(content);
}
else
{
ModelState.AddModelError("Name", "This username is already taken.");
return(View(user));
}
}
}
ModelState.Clear();
HttpContext.Session.SetString("UserID", user.ID.ToString());
HttpContext.Session.SetString("Username", user.Name.ToString());
return(RedirectToAction("EnterCreateHomeOptions", "Home"));
}
return(View());
}
public void AddUser_WithDuplicateEmail_ShouldReturnsServiceResultIsSuccessfulFalse()
{
// Arrange
UserPostViewModel userModel = new UserPostViewModel()
{
Username = "******",
Mail = "*****@*****.**",
IsActive = true
};
User user = new User()
{
Id = new Guid(),
Username = "******",
Mail = "*****@*****.**",
IsActive = true
};
this.userRepository.userReadRepository.GetByUserName(Arg.Any<string>()).ReturnsNull();
this.userRepository.userReadRepository.GetByUserByEmail(Arg.Any<string>()).Returns(user);
this.userRepository.userWriteRepository.AddUser(Arg.Any<User>()).Returns(true);
// Act
var result = this.userService.AddUser(userModel);
// Assert
Assert.AreEqual(false, result.IsSuccessful);
}
public UserPostViewModel GetPost(int id)
{
UserPostViewModel userPost = Mapper.ConvertPostToViewPost(_postsRepository.GetPostById(id));
userPost.CommentsCount = _commentsRepository.CountOfComments(userPost.Id);
return(userPost);
}
public ServiceResult UpdateUser(UserPostViewModel entity)
{
var userRoles = userRoleService.GetUserRolesByIds(entity.UserRoleIds);
// TODO: Send mail
var password = CreateRandomPassword();
var user = userRepository.Get(w => w.Id == entity.Id, i => i.UserRoles);
if (user.Username != entity.Username)
{
if (userRepository.Get(w => w.Username == entity.Username) != null)
{
return(new ServiceResult(false, "Username already exist."));
}
}
if (user.Mail != entity.Mail)
{
if (userRepository.Get(w => w.Mail == entity.Mail) != null)
{
return(new ServiceResult(false, "Mail already exist."));
}
}
user.Username = entity.Username;
user.Mail = entity.Mail;
user.UserRoles = userRoles;
user.IsActive = entity.IsActive;
userRepository.Update(user);
return(ServiceResult.GetUpdateResult(uow.Commit() > 0));
}
public ActionResult CreatePost(UserPostViewModel post)
{
if (ModelState.IsValid)
{
_blogService.CreateUserPost(post);
return(RedirectToAction("RegistredIndex", "Blog"));
}
return(View(post));
}
public ActionResult AddPost(UserPostViewModel model)
{
createNewPost(model);
checkUser(new UserViewModel()
{
usermail = model.usermail, password = model.password
});
ViewBag.currentUser = currentUser;
return(RedirectToAction("OpenPost", "Home", new { postid = model.postid, currentUserMail = currentUser.usermail, password = currentUser.password }));
}
public static Post ConvertViewPostToPost(UserPostViewModel inputPost)
{
var post = new Post();
post.Id = inputPost.Id;
post.UserName = inputPost.UserName;
post.PostText = inputPost.PostText;
post.CreatedPost = inputPost.CreatedPost;
post.PostName = inputPost.PostName;
return(post);
}
public async Task <JsonResult> GetHomeStatus()
{
var result = string.Empty;
if (!string.IsNullOrEmpty(HttpContext.Session.GetString("HomeID")))
{
var status = new HomeStatusPostViewModel();
var user = new UserPostViewModel();
using (var httpClient = new HttpClient())
{
var requestUri = $"{Configuration.DefaultAPI}/{CurrentControllerName}/status";
httpClient.DefaultRequestHeaders.Add("CurrentUserID", CurrentUserID.ToString());
httpClient.DefaultRequestHeaders.Add("CurrentHomeID", CurrentHomeID.ToString());
using (var response = await httpClient.GetAsync(requestUri))
{
string content = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
status = JsonConvert.DeserializeObject <HomeStatusPostViewModel>(content);
}
}
}
if (status.ID > 0)
{
using (var httpClient = new HttpClient())
{
var requestUri = $"{Configuration.DefaultAPI}/users/{status.UserID}";
httpClient.DefaultRequestHeaders.Add("CurrentUserID", CurrentUserID.ToString());
httpClient.DefaultRequestHeaders.Add("CurrentHomeID", CurrentHomeID.ToString());
using (var response = await httpClient.GetAsync(requestUri))
{
string content = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
user = JsonConvert.DeserializeObject <UserPostViewModel>(content);
}
}
}
result = $"{status.Status};{user.Name};{status.Details}";
return(Json(result));
}
}
result = $"1;system_generated;No one has set a status yet!";
return(Json(result));
}
// GET: Profile/ProfileTemplate
public ActionResult ProfileTemplate()
{
ApplicationUser currentUser = db.Users.FirstOrDefault(u => u.UserName == User.Identity.Name);
List <Post> userPosts = PostsController.UserPosts(currentUser, db.Posts.Include(p => p.Author).ToList());
UserPostViewModel model = new UserPostViewModel
{
CurrentUser = currentUser,
AllPosts = userPosts
};
return(View(model));
}
public void createNewPost(UserPostViewModel data)
{
fillPostsListFromFireBase();
fillUsersListFromFireBase();
data.countofposts = (Int32.Parse(data.countofposts) + 1).ToString();
data.postid = (posts.Count + 1).ToString();
addNewPostToFirebase(new PostViewModel(data));
users[getUser(data.usermail)].countofposts = data.countofposts;
updateUsersToFireBase();
fillUsersListFromFireBase();
}
public static UserPostViewModel ConvertPostToViewPost(Post inputPost)
{
var post = new UserPostViewModel();
post.Id = inputPost.Id;
post.PostText = inputPost.PostText;
post.CreatedPost = inputPost.CreatedPost;
post.UserName = inputPost.UserName;
post.PostName = inputPost.PostName;
post.Image = inputPost.Image;
return(post);
}
public async Task <UserGetViewModel> Login(UserPostViewModel user)
{
try
{
UserPostViewModel usr = await _repository.GetByEmail(user.Email);
if (usr == null)
{
throw new AuthWrongUserException();
}
var key = _configuration["Crypto:Key"];
var cPassword = Crypto.CryptText(user.Password, key, Util.Validators.Crypto.SYM_Providers.Rijndael, Util.Validators.Crypto.KeySize.Bits_256);
user.Password = cPassword;
if (cPassword != usr.Password)
{
throw new AuthWrongPasswordException();
}
var now = DateTime.UtcNow;
var claims = new Claim[]
{
new Claim("UserId", usr.Id.ToString()),
new Claim("Administrator", usr.Administrator.ToString()),
new Claim(JwtRegisteredClaimNames.Sub, usr.Email),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Iat, now.ToUniversalTime().ToString(), ClaimValueTypes.Integer64)
};
var secretKey = _configuration["Audience:Secret"];
var signingKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(secretKey));
var creds = new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256);
var jwt = new JwtSecurityToken(
issuer: _configuration["Audience:Iss"],
audience: _configuration["Audience:Aud"],
claims: claims,
notBefore: now,
expires: now.Add(TimeSpan.FromMinutes(3000)),
signingCredentials: creds
);
return(await _repository.Login(usr, jwt));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IActionResult> YourPosts()
{
var claimsidentity = (ClaimsIdentity)this.User.Identity;
var claims = claimsidentity.FindFirst(ClaimTypes.NameIdentifier);
UserPostViewModel upm = new UserPostViewModel()
{
PostModel = await _db.PostsModel.Where(c => c.UserId == claims.Value).ToListAsync(),
ApplicationUser = await _db.ApplicationUser.FirstOrDefaultAsync(c => c.Id == claims.Value)
};
return(View(upm));
}
public void CreateUserPost(UserPostViewModel post)
{
string createTime = DateTime.Now.ToString("dd.MM.yyyy HH:mm");
post.CreatedPost = createTime;
Post userPost = Mapper.ConvertViewPostToPost(post);
using (var binaryReader = new BinaryReader(post.uploadPicture.InputStream))
{
userPost.Image = binaryReader.ReadBytes(post.uploadPicture.ContentLength);
}
_postsRepository.SavePost(userPost);
}
public async Task <IActionResult> Create(UserPostViewModel model)
{
if (ModelState.IsValid)
{
string method = APIURL.IdentityBaseUri + IdentityAPI.User.Create;
model.UserName = model.Email;
OperationStatus status = await ApiInvoker.PostAsync <OperationStatus>(model, method);
if (status.IsSuccess)
{
JObject obj = status.Result as JObject;
UserProfileManager _profile = new UserProfileManager();
UserProfile up = new UserProfile()
{
UserID = obj["id"].ToString(),
Username = model.UserName,
Title = string.Empty,
FirstName = string.Empty,
MiddleName = string.Empty,
LastName = string.Empty,
GenderID = Gender.NotProvided,
ProfileImage = string.Empty,
Mobile = model.PhoneNumber,
Email = model.Email,
Phone = model.PhoneNumber,
ResPhone = model.PhoneNumber,
StreetAddress = string.Empty,
City = string.Empty,
State = string.Empty,
PostalCode = string.Empty,
About = string.Empty,
};
await _profile.UpdateUserProfile(up);
ActionMessage(status.Message, MessageType.Success);
}
else
{
ActionMessage(status.Message, MessageType.Error);
}
return(RedirectToAction("Index"));
}
else
{
await BindRoleList();
ShowModelStateErorr();
return(View(new UserGetViewModel()));
}
}
public ActionResult OpenPost(int id)
{
UserPostViewModel userPost = _blogService.GetPost(id);
ViewBag.Userlike = _blogService.CheckUserLike(User.Identity.Name, id);
ViewBag.PostId = userPost.Id;
ViewBag.DislikeNames = _blogService.GetDislikesNames(id);
ViewBag.LikeNames = _blogService.GetLikesNames(id);
ViewBag.UserName = userPost.UserName;
userPost.LikesCount = _blogService.PostLikes(id);
userPost.DislikesCount = _blogService.PostDislikes(id);
userPost.CommentsCount = _blogService.GetCommentsCount(id);
return(View(userPost));
}
public async Task <IActionResult> SharePost([FromBody] UserPostViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var p = _mapper.Map <UserPost>(model);
var usPost = new UserPost {
UserId = p.UserId, PostId = p.PostId
};
_userPostService.SharePost(usPost);
return(new OkObjectResult("Post shared"));
}
public async Task <IActionResult> Login(UserPostViewModel user)
{
user.ConfirmPassword = user.Password;
ModelState.Clear();
if (string.IsNullOrEmpty(user.Name))
{
ModelState.AddModelError("Name", "Username field is required.");
}
else if (string.IsNullOrEmpty(user.Password))
{
ModelState.AddModelError("Password", "Password field is required.");
}
else
{
using (var httpClient = new HttpClient())
{
var requestUri = $"{Configuration.DefaultAPI}/{CurrentControllerName}/{nameof(Login)}";
using (var response = await httpClient.PostAsJsonAsync(requestUri, user))
{
var content = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
user = JsonConvert.DeserializeObject <UserPostViewModel>(content);
if (user != null)
{
HttpContext.Session.SetString("UserID", user.ID.ToString());
HttpContext.Session.SetString("Username", user.Name.ToString());
return(RedirectToAction("EnterCreateHomeOptions", "Home"));
}
else
{
ModelState.AddModelError("", "Username or password is wrong.");
}
}
else
{
ModelState.AddModelError("", "Username or password is wrong.");
}
}
}
}
return(View());
}
public ActionResult Posts()
{
//View Details
//View Friends
//View His Posts
var Posts = db.Posts.OfType <HomePost>().Where(t => t.TypeId == PostType.Profile).Include(p => p.Person).Include(e => e.Comments).OrderByDescending(h => h.DatePosted).ToList();
var currentuser = CurrentUser();
var viewmodel = new UserPostViewModel {
Person = currentuser,
Posts = Posts,
Post = new HomePost()
};
return(View(viewmodel));
}
public async Task <IActionResult> Post([FromBody] UserPostViewModel User)
{
try
{
var usr = await _service.Login(User);
return(Ok(usr));
}
catch (AggregateException ex)
{
throw ex.Flatten().InnerExceptions[0];
}
catch (Exception ex)
{
throw ex;
}
}
public Task <UserGetViewModel> Login(UserPostViewModel user, JwtSecurityToken jwt)
{
try
{
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
var response = _mapper.Map <UserGetViewModel>(user);
response.Access_token = encodedJwt;
response.Expires_in = (int)TimeSpan.FromMinutes(3000).TotalSeconds;
return(Task.FromResult(response));
}
catch (Exception ex)
{
throw ex;
}
}
public IHttpActionResult Post([FromBody] UserPostViewModel userPost)
{
if (!ModelState.IsValid)
{
return(Ok(new ApiResponseModel
{
Success = false,
Message = Utils.GetErrorMessages(ModelState.Values)
}));
}
_engine.AddSuggestionAsync(userPost);
return(Ok(new ApiResponseModel
{
Success = true,
Message = "Thank you! Your suggestion has been accepted and became visible, once dedicated person will reply to it within 3 business days."
}));
}
public ActionResult AddOrUpdate(UserPostViewModel entity)
{
ViewBag.UserRoles = userRoleService.GetAllUserRolesByUserId(entity.Id).ToMVCSelectListItem();
if (ModelState.IsValid)
{
if (entity.Id.HasValue)
{
TempData["result"] = userService.UpdateUser(entity);
}
else
{
TempData["result"] = userService.AddUser(entity);
}
}
return(View());
}
public ActionResult Register([FromBody] UserPostViewModel user)
{
try
{
var userAlreadyExists = new BaseCRUDService(0).Any <UserPostViewModel>(x => x.Name == user.Name);
if (userAlreadyExists)
{
return(StatusCode(StatusCodes.Status403Forbidden, "This username is already taken."));
}
user = new BaseCRUDService(0).Save(user);
return(Ok(user));
}
catch (System.Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, $"{ex.Message}"));
}
}
public ServiceResult AddUser(UserPostViewModel entity)
{
bool isUpdated = false;
userRepository.userReadRepository = new UserReadRepository();
userRepository.userWriteRepository = new UserWriteRepository();
var password = CreateRandomPassword();
if (userRepository.userReadRepository.GetByUserName(entity.Username) != null)
{
return(new ServiceResult(false, "Username already exist."));
}
if (userRepository.userReadRepository.GetByUserByEmail(entity.Mail) != null)
{
return(new ServiceResult(false, "Mail already exist."));
}
isUpdated = userRepository.userWriteRepository.AddUser(new User
{
Username = entity.Username,
Mail = entity.Mail,
Password = password,
IsActive = entity.IsActive
});
MailSender ms = new MailSender();
ms.Send("*****@*****.**", "Added" + entity.Username, "Welcome ! " + entity.Username).Wait();
ServiceResult result = new ServiceResult();
if (!isUpdated)
{
result.SetFailure("Error while adding User.");
}
else
{
result.SetSuccess("User added successfully.");
}
return(result);
}
public ActionResult Login([FromBody] UserPostViewModel user)
{
try
{
user = new BaseCRUDService(0).GetEntity <UserPostViewModel>(x => x.Name == user.Name && x.Password == user.Password);
if (user != null)
{
return(Ok(user));
}
else
{
return(NotFound());
}
}
catch (System.Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, $"{ex.Message}"));
}
}
public void AddUser_ShouldReturnsServiceResultIsSuccessfulTrue()
{
// Arrange
UserPostViewModel user = new UserPostViewModel()
{
Username = "******",
Mail = "*****@*****.**",
IsActive = true
};
this.userRepository.userReadRepository.GetByUserName(Arg.Any<string>()).ReturnsNull();
this.userRepository.userReadRepository.GetByUserByEmail(Arg.Any<string>()).ReturnsNull();
this.userRepository.userWriteRepository.AddUser(Arg.Any<User>()).Returns(true);
// Act
var result = this.userService.AddUser(user);
// Assert
this.userRepository.userWriteRepository.Received(1).AddUser(Arg.Any<User>());
Assert.AreEqual(true, result.IsSuccessful);
}
