public async Task <IActionResult> Create(UserFormViewModel model)
{
if (!ModelState.IsValid || model.ImageFile == null)
{
TempData.AddErrorMessage(WebConstants.ErrorTryAgain);
return(View(model));
}
Picture profilePicture = new Picture(); // Creates instance of Picture entity
Image profilePictureImage = PictureServiceHelpers.ConvertIFormFileToImage(model.ImageFile); // Converts the uploaded image to System.Drawing.Image
if (profilePictureImage == null) // The uploaded file is not a picture
{
TempData.AddErrorMessage(WebConstants.ErrorTryAgain);
return(View(model));
}
bool imageInsertSuccess = await pictureService.InsertAsync(profilePicture, profilePictureImage); // inserts image into database and file system
if (!imageInsertSuccess) // if something with the image goes wrong return error
{
TempData.AddErrorMessage(WebConstants.ErrorTryAgain);
return(View(model));
}
User user = new User
{
UserName = AuthenticationHelpers.GenerateUniqueUsername(model.FirstName, model.LastName),
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
PhoneNumber = model.PhoneNumber,
ProfilePictureFileName = profilePicture.FileName
};
IdentityResult result = await userManager.CreateAsync(user, model.Password);
if (!result.Succeeded) // If something with the insert of a user goes wrong return an error
{
await pictureService.DeleteAsync(profilePicture); // In that case delete the already inserted profile picture
AddErrors(result);
return(View(model));
}
TempData.AddSuccessMessage(WebConstants.SuccessfulCreate, UserString);
return(RedirectToAction(nameof(Index)));
}
public async Task <ActionResult> ListingPhotoDelete(int id)
{
try
{
await _pictureService.DeleteAsync(id);
var itemPicture = _listingPictureservice.Query(x => x.PictureID == id).Select().FirstOrDefault();
if (itemPicture != null)
{
await _listingPictureservice.DeleteAsync(itemPicture.ID);
}
await _unitOfWorkAsync.SaveChangesAsync();
var path = Path.Combine(Server.MapPath("~/images/listing"), string.Format("{0}.{1}", id.ToString("00000000"), "jpg"));
System.IO.File.Delete(path);
var result = new { Success = "true", Message = "" };
return(Json(result, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
var result = new { Success = "false", Message = ex.Message };
return(Json(result, JsonRequestBehavior.AllowGet));
}
}
public override async Task <IActionResult> Delete(int id)
{
Car carToDelete = await carService.GetByIdAsync(id);
Picture pictureOfCar = carToDelete.Picture;
if (carToDelete == null)
{
TempData.AddErrorMessage(WebConstants.ErrorTryAgain);
return(NotFound());
}
IActionResult result = await base.Delete(id);
if (result.GetType() == base.RedirectToHome().GetType()) // If the delete action was successful
{
await pictureService.DeleteAsync(pictureOfCar);
User owner = await userManager.FindByIdAsync(carToDelete.OwnerId.ToString());
if (owner.Cars.Count() == 0) // If the user no longer has cars, remove his driver role
{
await userManager.RemoveFromRoleAsync(carToDelete.Owner, CommonConstants.DriverRole);
await signInManager.RefreshSignInAsync(owner);
}
}
await service.SaveAsync();
return(result);
}
public async Task <IActionResult> UpdatePost(PostUpdateDTO postUpdateDto)
{
if (ModelState.IsValid)
{
try
{
string userName = User.Identity.Name;
var user = await _userManager.FindByNameAsync(userName);
var userViewDTO = _mapper.Map <UserViewDto>(user);
if (postUpdateDto.NewPictures != null)
{
List <Picture> pictures = AddFiles(postUpdateDto.NewPictures, postUpdateDto.Id, userName);
foreach (var picture in pictures)
{
await _pictureService.CreateAsync(picture);
}
}
if (postUpdateDto.PictureViewDTOs != null)
{
foreach (var picture in postUpdateDto.PictureViewDTOs)
{
if (picture.Delete == true)
{
System.IO.File.Delete(picture.Path);
await _pictureService.DeleteAsync(picture.Id);
}
}
}
postUpdateDto.Modified = DateTime.Now;
postUpdateDto.ModifiedBy = userName;
var postToUpdate = _mapper.Map <Post>(postUpdateDto);
await _postService.UpdateEntryAsync(postToUpdate);
}
catch (DbUpdateException ex)
{
return(Content(ex.Message));
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
}
return(RedirectToAction("Index", "Home"));
}
return(View(postUpdateDto));
}
public async Task <JsonResult> DeleteFile(string file)
{
var pictureViewModel = await _pictureService.GetByNameAsync(file);
if (pictureViewModel == null)
{
return(Json("Error"));
}
else
{
var res = _filesHelper.DeleteFile(file);
if (res == "Ok")
{
var result = await _pictureService.DeleteAsync(pictureViewModel.Id);
if (result)
{
return(Json("OK"));
}
}
return(Json("Error"));
}
}
public async Task <IActionResult> OnPostDeleteAsync(params long[] id)
{
await _service.DeleteAsync(id);
return(JsonData(true));
}
public async Task <IActionResult> Update(UserUpdateDto userUpdateDto, List <string> roles)
{
if (ModelState.IsValid)
{
try
{
var user = await _userManager.FindByIdAsync(userUpdateDto.Id.ToString());
if (userUpdateDto.Avatar != null)
{
// Get the user's prifile picture
var currentAvatar = await _pictureService.GetAvatarAsync(user.Id);
Picture avatar = new Picture();
if (currentAvatar != null)
{
// Delete the current profile pictures
await _pictureService.DeleteAsync(currentAvatar.Id);
System.IO.File.Delete(currentAvatar.Path);
}
AddAvatar(userUpdateDto.Avatar, user.Id, out avatar);
await _pictureService.CreateAsync(avatar);
}
if (user != null)
{
user.UserName = userUpdateDto.UserName;
user.Email = userUpdateDto.Email;
user.FacebookLink = userUpdateDto.FacebookLink;
user.InstagramLink = userUpdateDto.InstagramLink;
user.LinkedInLink = userUpdateDto.LinkedInLink;
user.TwitterLink = userUpdateDto.TwitterLink;
user.YoutubeLink = userUpdateDto.YoutubeLink;
user.AutomaticEmailNotification = userUpdateDto.AutomaticEmailNotification;
}
if (User.IsInRole("SuperAdmin"))
{
// получем список ролей пользователя
var userRoles = await _userManager.GetRolesAsync(user);
// получаем все роли
var allRoles = _roleManager.Roles.ToList();
// получаем список ролей, которые были добавлены
var addedRoles = roles.Except(userRoles);
// получаем роли, которые были удалены
var removedRoles = userRoles.Except(roles);
await _userManager.AddToRolesAsync(user, addedRoles);
await _userManager.RemoveFromRolesAsync(user, removedRoles);
}
await _userManager.UpdateAsync(user);
}
catch (DbUpdateException ex)
{
return(Content(ex.Message));
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
}
if (User.IsInRole("SuperAdmin"))
{
return(RedirectToAction("Users", "Admin"));
}
return(RedirectToAction("Index", "Home"));
}
return(View(userUpdateDto));
}
public async Task <IActionResult> DeletePictureAsync([FromRoute] int id)
{
ServiceResponse <string> response = await _pictureService.DeleteAsync(id);
return(Ok(response));
}
