public string SaveImage(ProfilePictureViewModel profilePictureViewModel)
{
var fileUrl = "";
var t = profilePictureViewModel.File.Substring(22);
byte[] bytes = Convert.FromBase64String(t);
if (profilePictureViewModel.File != null && profilePictureViewModel.File.Length > 0)
{
var uploads = Path.Combine(_hostingEnvironment.ContentRootPath, "src");
var pathToData = Path.GetFullPath(Path.Combine(uploads, "assets/profilepicture"));
var guid = Guid.NewGuid();
fileUrl = guid + profilePictureViewModel.FileName;
var filePath = Path.Combine(pathToData, fileUrl);
using (var ms = new MemoryStream(bytes))
{
using (var stream = new FileStream(filePath, FileMode.Create))
{
ms.CopyTo(stream);
stream.Dispose();
}
ms.Dispose();
}
return(fileUrl);
}
return(fileUrl);
}
public async Task UpdateProfilePicture(ProfilePictureViewModel model)
{
model.Picture = await _imageStorage.SaveAsync(model);
var updateCommand = _mapper.Map <UpdateProfilePictureCommand>(model);
await Bus.SendCommand(updateCommand);
}
public IActionResult Upload(ProfilePictureViewModel model)
{
User user = new User();
if (ModelState.IsValid)
{
var pictureLocation = userContainer.GetPictureUser(currentUser.ID);
if (pictureLocation != "")
{
GC.Collect();
GC.WaitForPendingFinalizers();
System.IO.File.Delete("wwwroot/ProfilePictures/" + pictureLocation);
}
if (model.Image != null)
{
string uploadsFolder = Path.Combine(hostingEnviroment.WebRootPath, "ProfilePictures");
user.PictureLocation = Guid.NewGuid().ToString() + "_" + model.Image.FileName;
string filePath = Path.Combine(uploadsFolder, user.PictureLocation);
model.Image.CopyTo(new FileStream(filePath, FileMode.Create));
userContainer.ReturnInsertImage(user, currentUser.ID);
ViewBag.SuccesOrNot = "Photo Saved!";
}
else
{
ViewBag.SuccesOrNot = "ERROR! Photo not saved. ";
}
}
return(RedirectToAction("userPage", "Home"));
}
public async Task <IActionResult> ProfilePicture(ProfilePictureViewModel viewModel)
{
var user = await userManagerExtended.GetUserAsync(this.User);
profilePictureManager.SaveProfilePicture(viewModel, user);
return(RedirectToAction("Index", "Home"));
}
public async Task <string> SaveProfilePicture([FromBody] ProfilePictureViewModel profilePictureViewModel)
{
var userId = _caller.Claims.Single(c => c.Type == "id");
var customer = await _appDbContext.Customers.Include(c => c.Identity).SingleAsync(c => c.Identity.Id == userId.Value);
if (!string.IsNullOrEmpty(customer.Identity.PictureUrl))
{
var uploads = Path.Combine(_hostingEnvironment.ContentRootPath, "src");
var pathToData = Path.GetFullPath(Path.Combine(uploads, "assets/profilepicture"));
var filePath = Path.Combine(pathToData, customer.Identity.PictureUrl);
System.IO.File.Delete(filePath);
var profileUrl = SaveImage(profilePictureViewModel);
customer.Identity.PictureUrl = profileUrl;
}
else
{
var profileUrl = SaveImage(profilePictureViewModel);
customer.Identity.PictureUrl = profileUrl;
}
_appDbContext.SaveChanges();
return(customer.Identity.PictureUrl);
}
public async Task UpdateProfilePicture(ProfilePictureViewModel model)
{
await _storage.Remove(model.Id, "images");
model.Picture = await _storage.Upload(model);
var updateCommand = _mapper.Map <UpdateProfilePictureCommand>(model);
await Bus.SendCommand(updateCommand);
}
public async Task <bool> UpdateProfilePicture(ProfilePictureViewModel model)
{
await _storage.Remove(model.Filename, "images");
model.Picture = await _storage.Upload(model);
var updateCommand = _mapper.Map <UpdateProfilePictureCommand>(model);
return(await Bus.SendCommand(updateCommand));
}
public async Task <string> SaveAsync(ProfilePictureViewModel image)
{
var container = await GetBlobContainer();
await RemovePreviousImage(image.Id.Value.ToString(), container);
var newPicture = await UploadNewOne(image, container);
return(newPicture.StorageUri.PrimaryUri.AbsoluteUri);
}
private static async Task <CloudBlockBlob> UploadNewOne(ProfilePictureViewModel file, CloudBlobContainer container)
{
// Upload the new one.
var newImageName = Guid.NewGuid() + file.FileType.Replace("image/", ".");
var newPicture = container.GetBlockBlobReference(newImageName);
byte[] imageBytes = Convert.FromBase64String(file.Value);
newPicture.Properties.ContentType = file.FileType; //.Replace("image/", "");
await newPicture.UploadFromByteArrayAsync(imageBytes, 0, imageBytes.Length);
return(newPicture);
}
public async Task <ActionResult <bool> > UpdateProfilePicture([FromBody] ProfilePictureViewModel model)
{
if (!ModelState.IsValid)
{
NotifyModelStateErrors();
return(ModelStateErrorResponseError());
}
model.Id = _systemUser.UserId;
await _userAppService.UpdateProfilePicture(model);
return(ResponsePutPatch());
}
public async Task <ActionResult <bool> > UpdateProfilePicture([FromBody] ProfilePictureViewModel model)
{
if (!ModelState.IsValid)
{
NotifyModelStateErrors();
return(ModelStateErrorResponseError());
}
model.Username = _systemUser.Username;
model.Filename = $"{_systemUser.Username}{model.FileType.Replace("image/", ".")}";
await _userAppService.UpdateProfilePicture(model);
return(ResponsePutPatch());
}
public async Task <IActionResult> UploadFile([FromBody] ProfilePictureViewModel file)
{
if (!file.FileType.Contains("image"))
{
NotifyError("Type", "Invalid filetype");
return(Response());
}
var user = await _userManager.GetUserAsync(User);
user.Picture = await _imageStorage.SaveAsync(file);
await _userManager.UpdateAsync(user);
return(Response(user.Picture));
}
public IActionResult ManageProfile_ProfilePicture(ProfilePictureViewModel model)
{
var check = _db.Clients_Profile.Find(_userManager.GetUserId(User));
var image = model.ProfilePicture;
if (image != null && check != null)
{
var uniqueFileName = GetUniqueFileName(image.FileName);
var uploads = Path.Combine(_ihostingEnviroment.WebRootPath, "ProfilePictures");
var Filepath = Path.Combine(uploads, uniqueFileName);
using (var fileStream = new FileStream(Filepath, FileMode.Create))
{
image.CopyToAsync(fileStream);
}
check.ProfilePicture = uniqueFileName;
_db.SaveChanges();
}
return(RedirectToAction("Index"));
}
public async Task <ActionResult <DefaultResponse <bool> > > UpdateProfilePicture([FromBody] ProfilePictureViewModel model)
{
if (!ModelState.IsValid)
{
NotifyModelStateErrors();
return(Response(false));
}
model.Id = GetUserId();
await _userAppService.UpdateProfilePicture(model);
return(Response(true));
}
public Task UpdateProfilePicture(ProfilePictureViewModel model)
{
throw new NotImplementedException();
}
