public IHttpActionResult PutUserImage(int id, UserImageDTO userImage)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != userImage.UserImageID)
{
return(BadRequest());
}
try
{
db.Update(userImage);
}
catch (DbUpdateConcurrencyException)
{
if (!UserImageExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public UserDataModel UpdateUserImage(UserDataModel dataModel)
{
if (dataModel != null)
{
ImageDTO imageDTO = new ImageDTO();
UserImageDTO userImageDTO = new UserImageDTO();
imageDTO = UserDataModelAssembler.ToImageDTO(dataModel);
userImageDTO = UserDataModelAssembler.ToUserImageDTO(dataModel);
if (CheckUserImageExist(dataModel.UserID))
{
if (imageDTO != null)
{
imageDTO = imageBL.Update(imageDTO);
}
}
else
{
if (imageDTO != null)
{
imageDTO = imageBL.Create(imageDTO);
}
if (userImageDTO != null)
{
userImageDTO.ImageID = imageDTO.ImageID;
userImageDTO = userImageBL.Create(userImageDTO);
}
}
}
return(dataModel);
}
public HttpResponseMessage Add([FromBody] UserImageDTO userImageDTO)
{
UserDTO userDTO = userImageDTO.User;
userDTO.ProfileImage = saveImage(userImageDTO.Image, userImageDTO.Name);
return(Request.CreateResponse(HttpStatusCode.OK, this.UserBusinessLogic.Add(userDTO)));
}
/// <summary>
/// Invoked when <see cref="ToDTO"/> operation is about to return.
/// </summary>
/// <param name="dto"><see cref="UserDTO"/> converted from <see cref="User"/>.</param>
static partial void OnDTO(this UserImage entity, UserImageDTO dto)
{
if (entity.Image != null)
{
dto.Image = ImageAssembler.ToDTO(entity.Image);
}
}
/// <summary>
/// Creates a User object within the database. If an image is provided
/// then one will be created and associated with the User account
/// </summary>
/// <param name="user"><see cref="User"/></param>
/// <param name="image"><see cref="UserImageDTO"/></param>
/// <returns></returns>
public async Task <User> CreateUser(User user, UserImageDTO image)
{
const string sp = "CreateUser";
DynamicParameters param = new DynamicParameters();
param.Add("@FirstName", user.FirstName);
param.Add("@LastName", user.LastName);
param.Add("@Birthday", user.Birthday);
param.Add("@Interests", user.Interests);
param.Add("@Street1", user.Address.Street1);
param.Add("@Street2", user.Address.Street2);
param.Add("@City", user.Address.City);
param.Add("@State", user.Address.State);
param.Add("@Zip", user.Address.Zip);
if (image != null)
{
param.Add("@ImageType", image.Type);
param.Add("@ImageData", image.Base64Image);
}
using (IDbConnection db = this.DatabaseConnection)
{
int userId = await db.QueryFirstAsync <int>(sp, param, commandType : CommandType.StoredProcedure);
return(await this.GetSingle(userId));
}
}
public int AddImages(UserImageDTO dto)
{
using (UnitOfWork uow = new UnitOfWork())
{
try
{
var EmployeeImageAdded = uow.Images.AddImages(dto);
if (EmployeeImageAdded > 0)
{
bool isAdded = uow.Users.AddUserImage(EmployeeImageAdded, dto.EmployeeId);
if (isAdded == true)
{
return(dto.EmployeeId);
}
else
{
return(0);
}
}
else
{
return(0);
}
}
catch (Exception ex)
{
ex.Data.Add("AddImages", "An error occurred while trying to create Employee Image Record - BLL");
uow.Rollback();
return(0);
}
}
}
public async void Validate_Get_User_Default_Image()
{
var repo = getRepo();
UserImageDTO resp = await repo.GetUserImage(-1);
Assert.Equal("image/png", resp.Type);
Assert.True(resp.Base64Image.Length > 2);
}
public UserImageDTO Create(UserImageDTO modelDTO)
{
if (modelDTO != null)
{
return(UserImageAssembler.ToDTO(UserImagesRepo.Create(UserImageAssembler.ToEntity(modelDTO))));
}
return(null);
}
public void NewImage(UserImageDTO image)
{
var action = new
{
type = "NEW_IMAGE",
item = image
};
session.Broadcast(action);
}
public IHttpActionResult PostUserImage(UserImageDTO userImage)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Create(userImage);
return(CreatedAtRoute("DefaultApi", new { id = userImage.UserImageID }, userImage));
}
public IHttpActionResult GetUserImage(int id)
{
UserImageDTO userImage = db.Get(id);
if (userImage == null)
{
return(NotFound());
}
return(Ok(userImage));
}
public UserImageDTO Update(UserImageDTO modelDTO)
{
UserImageDTO returnUserImage = null;
if (modelDTO != null && modelDTO.UserImageID > 0)
{
UserImagesRepo.Update(0, UserImageAssembler.ToEntity(modelDTO));
returnUserImage = modelDTO;
}
return(returnUserImage);
}
public static UserImageDTO ToUserImageDTO(UserDataModel datamodel)
{
UserImageDTO dto = new UserImageDTO();
if (datamodel != null)
{
dto.ImageID = datamodel.ImageID;
dto.UserImageID = datamodel.UserImageID;
dto.UserID = datamodel.UserID;
dto.IsPrimary = datamodel.UserimagePrimary;
}
return(dto);
}
public UserImageDTO Get(int id)
{
UserImageDTO oUserImageDTO = new UserImageDTO();
if (id > 0)
{
UserImage oUserImage = UserImagesRepo.Get(id);
if (oUserImage != null)
{
oUserImageDTO = UserImageAssembler.ToDTO(oUserImage);
}
}
return(oUserImageDTO);
}
/// <summary>
/// Converts this instance of <see cref="UserImage"/> to an instance of <see cref="UserImageDTO"/>.
/// </summary>
/// <param name="entity"><see cref="UserImage"/> to convert.</param>
public static UserImageDTO ToDTO(this UserImage entity)
{
if (entity == null)
{
return(null);
}
var dto = new UserImageDTO();
dto.UserImageID = entity.UserImageID;
dto.UserID = entity.UserID;
dto.ImageID = entity.ImageID;
dto.IsPrimary = entity.IsPrimary;
entity.OnDTO(dto);
return(dto);
}
/// <summary>
/// Converts this instance of <see cref="UserImageDTO"/> to an instance of <see cref="UserImage"/>.
/// </summary>
/// <param name="dto"><see cref="UserImageDTO"/> to convert.</param>
public static UserImage ToEntity(this UserImageDTO dto)
{
if (dto == null)
{
return(null);
}
var entity = new UserImage();
entity.UserImageID = dto.UserImageID;
entity.UserID = dto.UserID;
entity.ImageID = dto.ImageID;
entity.IsPrimary = dto.IsPrimary;
dto.OnEntity(entity);
return(entity);
}
public ActionResult ImagesDetails(int id)
{
// Declare PageVM
UserImageVM model;
using (Db db = new Db())
{
// Get the page
UserImageDTO dto = db.Images.Find(id);
// Confirm page exists
if (dto == null)
{
return(Content("The item does not exist."));
}
// Init PageVM
model = new UserImageVM(dto);
}
// Return view with model
return(View(model));
}
public ActionResult ImageAdd(UserImageVM model)
{
string filename = Path.GetFileNameWithoutExtension(model.ImageFile.FileName);
string extension = Path.GetExtension(model.ImageFile.FileName);
filename = filename + DateTime.Now.ToString("yymmssff") + extension;
model.ImagePath = "~/Image/" + filename;
filename = Path.Combine(Server.MapPath("~/Image/"), filename);
model.ImageFile.SaveAs(filename);
UserImageDTO dto = new UserImageDTO();
using (Db db = new Db())
{
dto.Title = model.Title;
dto.ImageId = model.ImageId;
dto.ImagePath = model.ImagePath;
db.Images.Add(dto);
db.SaveChanges();
ModelState.Clear();
TempData["SM"] = "Image Uploaded Successfully";
return(View());
}
}
public int AddImages(UserImageDTO dto)
{
var savedImages = new UserImage()
{
file_stream = dto.file_stream,
Id = dto.Id,
file_name = dto.FileNameWithExtension,
file_type = dto.ContentType
};
Create(savedImages);
_uow.Save();
int isSaved = 0;
if (savedImages.Id > 0)
{
isSaved = savedImages.Id;
}
else
{
isSaved = 0;
}
return(isSaved);
}
/// <summary> /// Invoked when <see cref="ToEntity"/> operation is about to return. /// </summary> /// <param name="entity"><see cref="UserImage"/> converted from <see cref="UserImageDTO"/>.</param> static partial void OnEntity(this UserImageDTO dto, UserImage entity);
/// <summary> /// Invoked when <see cref="ToDTO"/> operation is about to return. /// </summary> /// <param name="dto"><see cref="UserImageDTO"/> converted from <see cref="UserImage"/>.</param> static partial void OnDTO(this UserImage entity, UserImageDTO dto);
public async Task <ActionResult> GetUserImage(int id)
{
UserImageDTO img = await this.userService.GetUserImage(id);
return(this.File(System.Convert.FromBase64String(img.Base64Image), img.Type));
}
/// <summary>
/// Returns a User Image based on the User Id provided
/// </summary>
/// <param name="id">Id of the User</param>
/// <returns><see cref="UserImageDTO"/></returns>
public async Task <UserImageDTO> GetUserImage(int id)
{
UserImageDTO result = await this.userRepository.GetUserImage(id);
return(result);
}
public ActionResult AddUserImage(int EmployeeId)
{
UsersImageViewModel model = new UsersImageViewModel();
model.UserId = EmployeeId;
if (EmployeeId > 1)
{
foreach (string upload in Request.Files)
{
if (Request.Files[upload].FileName != "")
{
string fileName = Request.Files[upload].FileName;
string contentType = Request.Files[upload].ContentType;
long fileLength = Request.Files[upload].InputStream.Length;
byte[] fileContent = new byte[fileLength];
using (MemoryStream memoryStream = new MemoryStream())
{
Request.Files[upload].InputStream.CopyTo(memoryStream);
fileContent = memoryStream.ToArray();
var image = Image.FromStream(memoryStream);
var ratioX = (double)350 / image.Width;
var ratioY = (double)200 / image.Height;
var ratio = Math.Min(ratioX, ratioY);
var width = (int)(image.Width * ratio);
var height = (int)(image.Height * ratio);
var newImage = new Bitmap(width, height);
Graphics.FromImage(newImage).DrawImage(image, 0, 0, width, height);
Bitmap bmp = new Bitmap(newImage);
ImageConverter converter = new ImageConverter();
fileContent = (byte[])converter.ConvertTo(bmp, typeof(byte[]));
}
//string directory = Server.MapPath("/Image/");
HttpPostedFileBase photo = Request.Files["ImageFile"];
string ImagePath = "";
if (photo != null && photo.ContentLength > 0)
{
var PhfileName = Path.GetFileName(photo.FileName);
//var path = Path.Combine(directory, PhfileName);
//photo.SaveAs(path);
ImagePath = "~/Image/" + PhfileName;
}
UserImageDTO dto = new UserImageDTO();
dto.EmployeeId = EmployeeId;
dto.file_stream = fileContent;
dto.ContentType = contentType;
dto.FileNameWithExtension = fileName;
int saved = _UsersBusinessLogic.AddImages(dto);
}
TempData["Success"] = MStart.Common.App_LocalResources.Resource.Success;
}
return(RedirectToAction("Index"));
}
else
{
TempData["Success"] = MStart.Common.App_LocalResources.Resource.Error;
return(RedirectToAction("Index"));
}
}
public UserImageVM(UserImageDTO row)
{
ImageId = row.ImageId;
ImagePath = row.ImagePath;
Title = row.Title;
}
