/// <summary>
/// 修改头像
/// </summary>
/// <param name="model"></param>
/// <returns>成功 or 失败，错误信息</returns>
public static RequestResult ChangeAvatar(ChangeAvatarViewModel model)
{
//using (MR_DataClassesDataContext _db = new MR_DataClassesDataContext())
using (MRDataEntities _db = new MRDataEntities())
{
bool hasModified = false;
var account = _db.tbl_UserAccount.SingleOrDefault(p => p.user_Id == model.Id);
if (model.Avatar != account.user_Avatar && !string.IsNullOrEmpty(model.Avatar) && !string.IsNullOrWhiteSpace(model.Avatar))
{
account.user_Avatar = model.Avatar;
hasModified = true;
}
if (hasModified)
{
//_db.SubmitChanges();
//_db.AlterUserAlterTime(account.user_Id);
_db.SaveChanges();
return(new RequestResult()
{
Succeeded = true
});
}
else
{
return(new RequestResult()
{
Error = "没有改变。。。"
});
}
}
}
public ActionResult ChangeAvatar(ChangeAvatarViewModel model, HttpPostedFileBase file)
{
if (!ModelState.IsValid)
{
return(View(model));
}
model.Id = _db.tbl_UserAccount.Single(m => m.user_Account == User.Identity.Name).user_Id;
if (file != null && file.ContentLength > 0)
{
var fileName = System.IO.Path.Combine(Request.MapPath("~/Content/User/Avatar/"), model.Id + System.IO.Path.GetFileName(file.FileName));
file.SaveAs(fileName);
model.Avatar = model.Id + System.IO.Path.GetFileName(file.FileName);
string oldAvatar = _db.tbl_UserAccount.Single(m => m.user_Account == User.Identity.Name).user_Avatar;
if (model.Avatar != oldAvatar && oldAvatar != "User_1.jpg")
{
ImageManager.Delete(Server.MapPath("~/Content/User/Avatar/" + oldAvatar));
}
}
else
{
ModelState.AddModelError("", "请选择一张图片");
model.Avatar = _db.tbl_UserAccount.Single(m => m.user_Account == User.Identity.Name).user_Avatar;
return(View(model));
}
var result = AccountManager.ChangeAvatar(model);
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Error);
}
return(View(model));
}
//
// GET: /Manage/ChangeAvatar
public ActionResult ChangeAvatar(ManageMessageId?message)
{
ViewBag.StatusMessage =
message == ManageMessageId.ChangeAvatarSuccess ? "Your avatar has been changed."
: message == ManageMessageId.Error ? "An error has occurred."
: "";
DirectoryInfo d = new DirectoryInfo(Server.MapPath("/Assets/Images/Avatars"));
FileInfo[] files = d.GetFiles("*.png");
var model = new ChangeAvatarViewModel()
{
HasPassword = false,
Avatars = files.Select(f => new Avatar {
ImageUrl = f.Name
}),
UserAvatarImage = new byte[0],
UserAvatarMimeType = ""
};
var user = UserManager.FindById(User.Identity.GetUserId());
if (user != null)
{
model.HasPassword = user.PasswordHash != null;
model.UserAvatarImage = user.AvatarImage;
model.UserAvatarMimeType = user.AvatarMimeType;
}
return(View(model));
}
public async Task <IActionResult> ChangeAvatar(ChangeAvatarViewModel model)
{
User currentUser = await _userService.GetCurrentUserAsync(HttpContext);
if (ModelState.IsValid && (model.ProfileId == currentUser.ProfileId || User.IsInRole("Admin")))
{
try
{
var newAvatar = await _photoService.AddPhoto(model.Image);
var result = await _profileService.ChangeAvatar(model.ProfileId, newAvatar);
if (result.Succedeed)
{
await _photoService.Delete(Int32.Parse(result.Message));
return(Ok(newAvatar.Url));
}
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
return(BadRequest());
}
public async Task <ActionResult> ChangeAvatar(ChangeAvatarViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
if (model.Avatar.ContentLength > 0)
{
ApplicationUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
byte[] bytes = new byte[model.Avatar.ContentLength];
using (BinaryReader theReader = new BinaryReader(model.Avatar.InputStream))
{
bytes = theReader.ReadBytes(model.Avatar.ContentLength);
}
user.Avatar = Convert.ToBase64String(bytes);
await UserManager.UpdateAsync(user);
SignInManager.SignIn(user, false, false);
}
ViewBag.Message = "File Uploaded Successfully!!";
return(RedirectToAction("Index"));
}
catch
{
ViewBag.Message = "File upload failed!!";
return(View(model));
}
}
public async Task ChangeAvatar(ChangeAvatarViewModel viewModel)
{
var currentUserId = GetCurrentUserId();
var user = await _users.FirstAsync(a => a.Id == currentUserId);
user.Avatar = "";
await _unitOfWork.SaveChangesAsync();
}
public ActionResult ChangeAvatar()
{
ChangeAvatarViewModel model = new ChangeAvatarViewModel();
model.Account = User.Identity.Name;
model.Avatar = _db.tbl_UserAccount.Single(m => m.user_Account == model.Account).user_Avatar;
return(View(model));
}
public async Task <IActionResult> ChangeAvatar([FromForm] ChangeAvatarViewModel model)
{
var picture = FormFileHelper.ConvertFileToBytes(model.Picture);
var contentType = model.Picture.ContentType;
await _employeeService.UpdatePicture(CurrentUser.UserId, picture, contentType);
return(NoContent());
}
public ActionResult ChangeAvatar()
{
ChangeAvatarViewModel model = new ChangeAvatarViewModel();
model.Account = CookieHepler.GetCookie("user");//CookieHepler.GetCookie("user")
model.Avatar = _db.tbl_UserAccount.Single(m => m.user_Account == model.Account).user_Avatar;
return(View(model));
}
public async Task <IActionResult> ChangeAvatar(ChangeAvatarViewModel model)
{
var user = await _userManager.GetUserAsync(User);
string uploadsFolder = Path.Combine(_webhostEnvironment.WebRootPath, "images/avatars");
if (model.Photo != null)
{
List <string> allowExt = new List <string>
{
".png", ".jpg"
};
string fileExt = Path.GetExtension(model.Photo.FileName);
if (!allowExt.Any(x => x.Contains(fileExt)))
{
ModelState.AddModelError(string.Empty, "Niedozwolony format pliku.");
return(View(model));
}
string uniqueFileName = "u_" + user.Id + fileExt;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
if (user.Avatar != string.Empty)
{
string existFilePath = Path.Combine(uploadsFolder, user.Avatar);
if (filePath != existFilePath)
{
if (System.IO.File.Exists(existFilePath))
{
System.IO.File.Delete(existFilePath);
}
}
}
model.Photo.CopyTo(new FileStream(filePath, FileMode.Create));
user.Avatar = uniqueFileName;
await _userManager.UpdateAsync(user);
}
else
{
string existFilePath = Path.Combine(uploadsFolder, user.Avatar);
if (System.IO.File.Exists(existFilePath))
{
System.IO.File.Delete(existFilePath);
}
user.Avatar = string.Empty;
await _userManager.UpdateAsync(user);
}
return(View());
}
public ActionResult Index(ChangeAvatarViewModel viewModel)
{
var userID = _authService.GetCurrentUser().ID;
switch (viewModel.Type)
{
case AvatarType.Default:
{
_avatarService.SetUserAvatarToDefault(userID);
break;
}
case AvatarType.Gravatar:
{
var userEMail = _profileService.GetProfileByUserID(userID).EMail;
var gravatarLink = _gravatarService.GetGravatarLink(userEMail);
var changeAvatarDTO = new ChangedAvatarDTO
{
Type = AvatarTypeDTO.Gravatar,
Source = gravatarLink
};
_avatarService.SetUserAvatar(userID, changeAvatarDTO);
break;
}
case AvatarType.Internal:
{
var stream = viewModel.AvatarFile.InputStream;
var mimeType = viewModel.AvatarFile.ContentType;
var serverPath = HttpContext.Server.MapPath("/");
if (viewModel.AvatarFile == null)
{
ModelState.AddModelError("AvatarFile", "You have to upload file.");
return(View(viewModel));
}
if (!_avatarService.CheckIfMimeTypeIsValid(mimeType))
{
ModelState.AddModelError("AvatarFile", $"{mimeType} is not allowed.");
return(View(viewModel));
}
var pathToAvatarFile = _avatarFilesService.SaveAvatar(stream, mimeType, serverPath);
var avatar = Mapper.Map <ChangedAvatarDTO>(viewModel);
avatar.Source = pathToAvatarFile;
_avatarService.SetUserAvatar(userID, avatar);
break;
}
}
return(RedirectToAction("Index"));
}
public virtual async Task <ActionResult> UploadAvatar(ChangeAvatarViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
await _userService.ChangeAvatar(viewModel);
return(RedirectToAction(MVC.Account.UploadAvatar()));
}
// GET: profile/changeava
public async Task <IActionResult> ChangeAva()
{
User currentUser = await _userService.GetCurrentUserAsync(HttpContext);
ChangeAvatarViewModel model = new ChangeAvatarViewModel {
ProfileId = currentUser.ProfileId
};
return(View(model));
}
public ActionResult ChangeAvatar()
{
var loggedUser = this.GetLoggedUserId();
var userAvatarUrl = this.accountManagementService.GetUserAvatarUrl(loggedUser);
var model = new ChangeAvatarViewModel();
model.CurrentAvatarUrl = userAvatarUrl;
return(this.View(model));
}
public async Task <IActionResult> ChangeAvatar(string id)
{
ApplicationUser user = await userManager.GetUserAsync(User);
ChangeAvatarViewModel model = new ChangeAvatarViewModel
{
UserId = id,
ExistingAvatarPhotoPath = user.AvatarPhotoPatch
};
return(View(model));
}
public async Task <IActionResult> Upload(ChangeAvatarViewModel file)
{
var userId = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
var result = await this.profilePicturesService.AddPictureAsync(file.Avatar, userId);
if (!result)
{
this.ModelState.AddModelError("File", "The file is too large.");
}
return(this.Redirect("/Profiles/UserProfile"));
}
public IActionResult ChangeAvatar(ChangeAvatarViewModel vm)
{
if (ModelState.IsValid)
{
var user = _userService.GetUserByUserName(User.Identity.Name);
//Image img = Image.FromFile(Path.GetFullPath(vm.AvatarImage.FileName));
user.AvatarImage = Utility.ImageConverter.ImageToByteArray(vm.AvatarImage);
_userService.EditUser(user);
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("AvatarImage", "Please Insert Image!");
return(View());
}
public async Task <IActionResult> ChangeAvatar(ChangeAvatarViewModel model)
{
if (ModelState.IsValid)
{
var user = await userService.GetUserByIdentityName(User.Identity.Name);
user.Avatar = model.Avatar;
await userService.EditSave(user);
return(RedirectToAction("Profile"));
}
return(RedirectToAction("ChangeAvatar", model));
}
public async Task <bool> ChangeAvatar(int id, ChangeAvatarViewModel model)
{
var entity = await _accountRepository.GetByIdAsync(id, false);
if (entity != null)
{
entity.Avatar = model.Image;
entity.DateModified = DateTime.Now;
await _accountRepository.UpdateAsync(entity);
return(true);
}
return(false);
}
public async Task<IActionResult> ChangeAvatar()
{
var user = await _userManager.GetUserAsync(User);
var profile = await _dbContext.Profiles.Include(p => p.Avatar).FirstOrDefaultAsync(p => p.Id == user.Id);
if (user == null)
throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
var model = new ChangeAvatarViewModel
{
AvatarId = profile.Avatar?.Id.ToString(),
StatusMessage = StatusMessage
};
return View(model);
}
public async Task <IActionResult> ChangeAvatar([FromRoute] string id)
{
if (id != null)
{
var user = await userService.GetUserById(id);
var model = new ChangeAvatarViewModel
{
UserName = user.UserName,
Avatar = user.Avatar
};
return(PartialView("_ChangeAvatar", model));
}
return(RedirectToAction("Profile"));
}
public ActionResult ChangeAvatar(ChangeAvatarViewModel model)
{
if (ModelState.IsValid)
{
var userId = _identityFacade.GetUserId();
if (!_fileValidator.IsValidFiletype(model.file))
{
ModelState.AddModelError("", "Invalid file format!");
return(View(model));
}
_imageRepository.AddImageToDb(userId, model.file);
return(RedirectToAction("Index", "Manage"));
}
return(View());
}
private string ProcessUploadedFile(ChangeAvatarViewModel model, string folderDirection)
{
string uniqueFileName = null;
if (model.Photo != null)
{
string uploadsFolder = Path.Combine(_hostingEnvironment.WebRootPath, folderDirection);
uniqueFileName = Guid.NewGuid().ToString() + "_" + model.Photo.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
model.Photo.CopyTo(fileStream);
}
}
return(uniqueFileName);
}
public async Task <IActionResult> ChangeAvatar()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
}
var viewModel = new ChangeAvatarViewModel
{
AvatarName = user.AvatarImageName,
StatusMessage = StatusMessage
};
return(View(viewModel));
}
public void Given_inValid_ChangeAvatarViewModel_When_ChangeAvatar_Returns_IndexView()
{
//Given
var model = new ChangeAvatarViewModel();
model.file = new Mock <HttpPostedFileBase>().Object;
_fileValidator.Setup(x => x.IsValidFiletype(It.IsAny <HttpPostedFileBase>())).Returns(false);
_imageRepository.Setup(x => x.AddImageToDb("UserId", It.IsAny <HttpPostedFileBase>()));
//When
var result = _manageController.ChangeAvatar(model) as ViewResult;
//Then
Assert.NotNull(result);
Assert.AreEqual(String.Empty, result.ViewName);
Assert.IsInstanceOf <ChangeAvatarViewModel>(result.Model);
}
public void Given_Valid_ChangeAvatarViewModel_When_ChangeAvatar_Returns_IndexView()
{
//Given
var model = new ChangeAvatarViewModel();
model.file = new Mock <HttpPostedFileBase>().Object;
_fileValidator.Setup(x => x.IsValidFiletype(It.IsAny <HttpPostedFileBase>())).Returns(true);
_imageRepository.Setup(x => x.AddImageToDb("UserId", It.IsAny <HttpPostedFileBase>()));
//When
var result = _manageController.ChangeAvatar(model) as RedirectToRouteResult;
//Then
Assert.NotNull(result);
Assert.AreEqual("Manage", result.RouteValues["controller"].ToString());
Assert.AreEqual("Index", result.RouteValues["action"].ToString());
}
public ActionResult ChangeAvatar(ChangeAvatarViewModel changeAvatarViewModel)
{
if (!this.ModelState.IsValid)
{
return(this.View(changeAvatarViewModel));
}
var loggedUserName = this.User.Identity.Name;
var extension = Path.GetExtension(changeAvatarViewModel.NewAvatar.FileName);
var filename = loggedUserName + extension;
var path = Server.MapPath($"~/UserAvatars/{loggedUserName}/") + filename;
changeAvatarViewModel.NewAvatar.SaveAs(path);
var imageUrl = $"/UserAvatars/{loggedUserName}/" + filename;
var logedUserId = this.GetLoggedUserId();
this.accountManagementService.SetUserAvatar(logedUserId, imageUrl);
return(this.RedirectToAction(nameof(ManageController.ChangeAvatar)));
}
public async Task <IActionResult> ChangeAvatar(ChangeAvatarViewModel model)
{
if (ModelState.IsValid)
{
ApplicationUser user = await userManager.GetUserAsync(User);
if (model.Photo != null)
{
if (model.ExistingAvatarPhotoPath != null)
{
string filePath = Path.Combine(_hostingEnvironment.WebRootPath, "images/avatars",
model.ExistingAvatarPhotoPath);
System.IO.File.Delete(filePath);
}
}
user.AvatarPhotoPatch = ProcessUploadedFile(model, "images/avatars");
await userManager.UpdateAsync(user);
return(View("ChangeAvatarConfirmation", model));
}
return(View());
}
public async Task <ActionResult> ChangeAvatar(ChangeAvatarViewModel model)
{
if (ModelState.IsValid)
{
//Change avatar
if (Request.Files.Count > 0)
{
var manager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new ApplicationDbContext()));
var currentUser = manager.FindById(User.Identity.GetUserId());
HttpPostedFileBase file = Request.Files[0];
//Check for image size
if (file.ContentLength > 0 && file.ContentLength < 4000000)
{
if (file.ContentType.Contains("image/jpeg") || file.ContentType.Contains("image/png") || file.ContentType.Contains("image/gif"))
{
//Create random name & save with path
string fileNameRandomExt = Guid.NewGuid().ToString() + Path.GetExtension(file.FileName);
string uploadResult = Path.Combine(Server.MapPath("~/Content/uploads"), fileNameRandomExt);
file.SaveAs(uploadResult);
currentUser.Avatar = fileNameRandomExt;
var result = await manager.UpdateAsync(currentUser);
if (result.Succeeded)
{
return(RedirectToAction("Index", new { Message = ManageMessageId.ChangeAvatarSuccess }));
}
}
}
}
return(RedirectToAction("Index", new { Message = ManageMessageId.Error }));
}
else
{
return(View(model));
}
}
public async Task <ActionResult> ChangeAvatar(ChangeAvatarViewModel model)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user == null)
{
return(RedirectToAction("ChangeAvatar", new { message = ManageMessageId.Error }));
}
var file = Server.MapPath(model.SelectedAvatar);
if (!string.IsNullOrEmpty(file))
{
FileStream stream = System.IO.File.OpenRead(file);
var fileBytes = new byte[stream.Length];
stream.Read(fileBytes, 0, fileBytes.Length);
stream.Close();
var ext = Path.GetExtension(stream.Name).Substring(1);
user.AvatarImage = fileBytes;
user.AvatarMimeType = ext;
}
var result = await UserManager.UpdateAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("ChangeAvatar", new { message = ManageMessageId.ChangeAvatarSuccess }));
}
else
{
return(RedirectToAction("ChangeAvatar", new { message = ManageMessageId.Error }));
}
}
public ActionResult ChangeAvatar(ChangeAvatarViewModel model)
{
if (!this.ModelState.IsValid)
{
return this.View(model);
}
Avatar newAvatar = this.Users.CreateAvatar(
model.Contents.FileName,
StreamHelper.ReadFully(model.Contents.InputStream, model.Contents.ContentLength),
this.UserProfile);
return this.RedirectToAction("Index", "Profile");
}
