public async Task DeleteImageAsync(string id) { string filePath = _hostingEnvironment.ContentRootPath + "\\Contents"; // Get the image by id, then URL, then the filename in the URL path var imgId = new ObjectId(id); PropertyImage img = await _imageRepository.GetImage(imgId); int start = img.Url.LastIndexOf("/"); string fName = img.Url.Substring(start + 1); try { await _imageRepository.RemoveImage(imgId); } catch (Exception ex) { throw ex; } string f = filePath + "\\" + fName; System.IO.File.Delete(f); // Delete the file from storage }
public async Task <IActionResult> Edit(Guid id, [Bind("FileName,FilePath,FileType,Id,CreatedDate,UpdatedDate")] PropertyImage propertyImage) { if (id != propertyImage.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(propertyImage); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!PropertyImageExists(propertyImage.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(propertyImage)); }
public async Task <IActionResult> UploadImage(IFormFile file, PropertyImage image)// [FromBody] PropertyImage image) //public async Task<IActionResult> UploadImage(IFormFile file, string id) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (file == null || file.Length == 0) { return(Content("file not selected")); } string path = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot\\images\\"); using (var fs = new FileStream(Path.Combine(path, file.FileName), FileMode.Create)) { await file.CopyToAsync(fs); // Add image path to DB await _imageRepository.AddImageAsync(new PropertyImage { //Url = "~/Contents/" + file.FileName, // Path.Combine(path, file.FileName), Url = "images/" + file.FileName, Caption = "First image for the property", PropertyId = image.PropertyId, // "62541", DateAdded = DateTime.Now }); } return(Content("file uploaded")); }
public async Task <PropertyImage> DeletePropertyImage(PropertyImage propertyImage) { _unitOfWork.PropertyImages.RemoveAsync(propertyImage); await _unitOfWork.CommitAsync(); return(propertyImage); }
public async Task <IActionResult> AddImage(PropertyImageViewModel model) { if (ModelState.IsValid) { var path = string.Empty; if (model.ImageFile != null) { path = await _imageHelper.UploadImageAsync(model.ImageFile); } var propertyImage = new PropertyImage { ImageUrl = path, Property = await _dataContext.Properties.FindAsync(model.Id) }; _dataContext.PropertyImages.Add(propertyImage); await _dataContext.SaveChangesAsync(); return(RedirectToAction($"{nameof(DetailsProperty)}/{model.Id}")); } return(View(model)); }
async Task <List <PropertyImageResponse> > IRequestHandler <CreatePropertyImageRangeCommand, List <PropertyImageResponse> > .Handle( CreatePropertyImageRangeCommand request, CancellationToken cancellationToken) { var images = new List <PropertyImage>(); foreach (var file in request.Images) { var fileName = ContentDispositionHeaderValue.Parse(file.ContentDisposition).FileName.Trim('"'); using var memoryStream = new MemoryStream(); await file.CopyToAsync(memoryStream); var propertyImage = new PropertyImage() { Image = memoryStream.ToArray(), PropertyId = request.PropertyId }; images.Add(propertyImage); await _propertyImagesService.CreateAsync(propertyImage); } return(_mapper.Map <List <PropertyImage>, List <PropertyImageResponse> >(images)); }
public async Task <PropertyImage> ToggleMainImageState(PropertyImage propertyImage) { propertyImage.IsMain = !propertyImage.IsMain; await _unitOfWork.CommitAsync(); return(propertyImage); }
public async Task <PropertyImage> CreatePropertyImage(PropertyImage propertyImage) { _context.PropertyImages.Add(propertyImage); await _context.SaveChangesAsync(); return(propertyImage); }
public ActionResult AddProperty([Bind(Include = "PropertyId,Title,Detail,Price,Area,RoomNumber,FloorNumber,TotalFloor,HeatingSystem,BuildingAge,Country,City, State, Address")] Property property) { if (ModelState.IsValid) { List <PropertyImage> propertyImageList = new List <PropertyImage>(); for (int i = 0; i < Request.Files.Count; i++) { var file = Request.Files[i]; if (file != null && file.ContentLength > 0) { var filename = Path.GetFileName(file.FileName); PropertyImage propertyImage = new PropertyImage() { ImageName = filename, Extenstion = Path.GetExtension(filename), Guid = Guid.NewGuid() }; propertyImageList.Add(propertyImage); var path = Path.Combine(Server.MapPath("~/Images/Property"), propertyImage.Guid + propertyImage.Extenstion); file.SaveAs(path); } } property.PropertyImages = propertyImageList; property.Date = DateTime.Now; db.Properties.Add(property); db.SaveChanges(); TempData["message"] = string.Format("Property added successfully"); return(RedirectToAction("PropertyList")); } return(View()); }
public async Task <PropertyImage> UpdatePropertyImage(PropertyImage propertyImage) { _context.Entry(propertyImage).State = EntityState.Modified; await _context.SaveChangesAsync(); return(propertyImage); }
public async Task <ICollection <PropertyImageViewModel> > UploadAsync(ICollection <IFormFile> files, Guid portfolioId, Guid propertyId) { var result = new List <PropertyImageViewModel>(); var resources = await files.ProcessResourcesAsync(HostingEnvironment.WebRootPath, portfolioId.ToString()); if (resources == null) { return(null); } foreach (var resource in resources) { var entity = new PropertyImage { PropertyId = propertyId, FileName = resource.FileName, Created = DateTime.Now }; await Context.PropertyImages.AddAsync(entity); await Context.SaveChangesAsync(); result.Add(new PropertyImageViewModel(entity)); } return(result); }
public async Task <int> AddImageProperty(ImagePropertyModelView imageProperty, CancellationToken token = default) { var property = await _uow.GetObjectByKeyAsync <Property>(imageProperty.IdProperty); if (property == null) { property = await CreateDefaultPropertyBuildingAsync(); } var propertyImage = new PropertyImage(_uow); propertyImage.Enabled = true; propertyImage.FileName = imageProperty.File.FileName; propertyImage.Property = property; using (MemoryStream fileStream = new MemoryStream()) { await imageProperty.File.CopyToAsync(fileStream); await fileStream.FlushAsync(); propertyImage.File = fileStream.ToArray(); } await _uow.CommitChangesAsync(); return(await Task.FromResult(propertyImage.Oid)); }
/// <summary> /// associates the image with the property that was uploaded /// </summary> /// <param name="file"></param> private void associateImagesWithProperty(UnitOfWork unitOfWork, HttpPostedFileBase[] files, Guid propertyID) { bool isPrimaryDisplay = true;//the first uploaded will be selected as the primary display foreach (var file in files) { string fileName = string.Empty; Guid guid = Guid.NewGuid(); fileName = guid.ToString() + Path.GetExtension(file.FileName); PropertyImage propertyImage = new PropertyImage() { ID = guid, PropertyID = propertyID, ImageURL = fileName, IsPrimaryDisplay = isPrimaryDisplay, DateTCreated = DateTime.Now }; if (isPrimaryDisplay == true) { isPrimaryDisplay = false; } unitOfWork.PropertyImage.Add(propertyImage); uploadPropertyImages(file, fileName); } }
public async Task <IActionResult> AddImage(PropertyImageViewModel model) { //Validamos si el modelo es válido if (ModelState.IsValid) { //creamos la variable path asumiendo que adiciono la imagen string path = string.Empty; //Imagefile=Iformfile donde se captura la imagen //Si hay una imagen if (model.ImageFile != null) { //Llamamos al método que creamos en la interface para subir la imagen //nos devuelve la ruta de como se va ha guradar en la bd path = await _imageHelper.UploadImageAsync(model.ImageFile); } //Creamos el objeto PropertyImage PropertyImage propertyImage = new PropertyImage { ImageUrl = path,//Es la ruta que nos devovlio del método en la interface //buscamos el objeto con el id, ya que desde el get no lo podemos enviar Property = await _dataContext.Properties.FindAsync(model.Id) }; //Finalmente guardamos en la coleccion de imagenes la propertyImage //retornamos al detailsProperty con el id de la propiedad _dataContext.PropertyImages.Add(propertyImage); await _dataContext.SaveChangesAsync(); return(RedirectToAction($"{nameof(DetailsProperty)}/{model.Id}")); } return(View(model)); }
public async Task <IHttpActionResult> PutPropertyImage(int id, PropertyImage propertyImage) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != propertyImage.ID) { return(BadRequest()); } db.Entry(propertyImage).State = EntityState.Modified; try { await db.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!PropertyImageExists(id)) { return(NotFound()); } else { throw; } } return(StatusCode(HttpStatusCode.NoContent)); }
public async Task <bool> CreateAsync(PropertyImage propertyImage) { await _dataContext.PropertyImages.AddAsync(propertyImage); var created = await _dataContext.SaveChangesAsync(); return(created > 0); }
public ActionResult DeleteConfirmed(int id) { PropertyImage propertyImage = db.PropertyImages.Find(id); db.PropertyImages.Remove(propertyImage); db.SaveChanges(); return(RedirectToAction("Index")); }
public PropertyDescription(Form form, Property property) { InitializeComponent(); this.form = form; this.property = property; this.propertyImage = new PropertyImage(); this.pd = new Entites.PropertyDescription(); this.da = new DataAccess(); }
public void SaveData(Property item, PropertyImageCollection imageCol) { item.AddUpdate(); PropertyImage img = new PropertyImage(); img.PRL = item.PRL; img.DeleteByPRL(); img.Add(imageCol); }
public IActionResult Post([FromBody] PropertyImage propertyImage) { using (var scope = new TransactionScope()) { _Repo.Insert(propertyImage); scope.Complete(); return(CreatedAtAction(nameof(Get), new { id = propertyImage.Id }, propertyImage)); } }
public void AddPropertyImage(PropertyImage propertyImage) { if (propertyImage == null) { throw new ArgumentNullException(nameof(propertyImage)); } _context.PropertyImage.Add(propertyImage); }
public PropertyImage AddPropertyImage(int propertyId, string path) { PropertyImage propertyImage = new PropertyImage(); propertyImage.PropertyId = propertyId; propertyImage.ImagePath = path; _db.PropertyImages.Add(propertyImage); _db.SaveChanges(); return(propertyImage); }
public ActionResult AddPictureProperty(PropertyImage pic) { if (pic.image != null) { db.PropertyImages.Add(pic); db.SaveChanges(); } return(RedirectToAction("Index")); }
public void DeleteData(string prl) { PropertyImage img = new PropertyImage(); img.PRL = prl; img.DeleteByPRL(); Property property = new Property(); property.DeleteByPRL(prl); }
public ActionResult Edit(Property property, IEnumerable <HttpPostedFileBase> files) { if (ModelState.IsValid) { try { property.DateAdded = DateTime.Now; unitOfWork.PropertyRepository.Update(property); unitOfWork.AddressRepository.Update(property.Address); int count = 0; foreach (var file in files) { if (file != null) { if (file.ContentLength > 0) { var fileName = Path.GetFileName(file.FileName); var path = Path.Combine(Server.MapPath("~/Images/user_uploads/" + User.Identity.Name), fileName); file.SaveAs(path); PropertyImage propertyImage = new PropertyImage(); propertyImage.url = "~/Images/user_uploads/" + User.Identity.Name + "/" + fileName; propertyImage.description = "Proba"; //unitOfWork.PropertyImageRepository.Insert(propertyImage); property.propertyImages.Add(propertyImage); count++; } } } if (count == 0) { PropertyImage propertyImage = new PropertyImage(); propertyImage.url = "~/Images/default.jpg"; propertyImage.description = "Proba"; //unitOfWork.PropertyImageRepository.Insert(propertyImage); property.propertyImages.Add(propertyImage); } unitOfWork.Save(); } catch (Exception e) { return(View(property)); } return(View("Details", property)); } return(View(property)); }
public ActionResult <PropertyImageDTO> AddPropertyImage([FromBody] PropertyImageDTO propertyImageCreation) { PropertyImage propertyImage = _mapper.Map <PropertyImage>(propertyImageCreation); _realStateAPIRepository.AddPropertyImage(propertyImage); _realStateAPIRepository.Save(); PropertyImageDTO propertyImageDTO = _mapper.Map <PropertyImageDTO>(propertyImage); return(new CreatedAtRouteResult("GetPropertyImageById", new { idPropertyImage = propertyImage.IdPropertyImage }, propertyImageDTO)); }
public IActionResult Post([FromBody] PropertyImage image) { var imageFromDb = _repository.GetPropertyImage(image.Id); string webRootPath = _hostingEnvironment.WebRootPath; //change from explorer path to url path var imagePath = imageFromDb.ImagePath.Replace('/', '\\'); var fullPath = Path.Combine(webRootPath, "uploads", imagePath); _repository.DeletePropertyImage(imageFromDb, fullPath); return(StatusCode(202)); }
public string DeletePropertyImage(PropertyImage image, string fileName) { if (System.IO.File.Exists(fileName)) { System.IO.File.Delete(fileName); } _db.PropertyImages.Remove(image); _db.SaveChanges(); return("File Deleted"); }
public PropertyImageViewModel(PropertyImage propertyImage) { if (propertyImage == null) { throw new ArgumentNullException(nameof(propertyImage)); } FileName = propertyImage.FileName; PropertyId = propertyImage.PropertyId; Id = propertyImage.Id; }
public ActionResult Edit([Bind(Include = "Id,Name,PropertyId")] PropertyImage propertyImage) { if (ModelState.IsValid) { db.Entry(propertyImage).State = EntityState.Modified; db.SaveChanges(); return(RedirectToAction("Index")); } ViewBag.PropertyId = new SelectList(db.Properties, "Id", "Name", propertyImage.PropertyId); return(View(propertyImage)); }