// GET: Admin/Slide/Edit/5
        public async Task <IActionResult> Edit(long?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            var slide = await _context.Slides.FindAsync(id);

            SlideEditViewModel slideEdit = new SlideEditViewModel
            {
                Id             = slide.Id,
                ExistImagePath = slide.Image,
                Status         = slide.Status,
                Link           = slide.Link,
                Description    = slide.Description,
                DisplayOrder   = slide.DisplayOrder
            };

            if (slide == null)
            {
                return(NotFound());
            }
            return(View(slideEdit));
        }
Esempio n. 2
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,Image,Name,Description")] SlideEditViewModel newSlide)
        {
            if (id != newSlide.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                // Старые данные объекта
                Slide slide = newSlide.GetModelByViewModel();

                try
                {
                    db.Update(slide);
                    await db.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!SlideExists(slide.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction("List"));
            }
            return(View(newSlide));
        }
Esempio n. 3
0
        // GET: Slide/Create
        public ActionResult Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            var slide = db.Slide.Find(id);

            if (slide == null)
            {
                return(HttpNotFound());
            }

            var model = new SlideEditViewModel()
            {
                ID          = slide.ID,
                Description = slide.Description,
                Position    = slide.Position,
                IsPublished = slide.IsPublished,
                Html        = slide.Html
            };

            return(View(model));
        }
        private string ProcessUploadedFile(SlideEditViewModel slide)
        {
            string uniqueFileName = null;

            if (slide.Image != null)
            {
                string upLoadFolder = Path.Combine(hostingEnvironment.WebRootPath, "image_slide");
                uniqueFileName = Guid.NewGuid().ToString() + "_" + slide.Image.FileName;
                string filePath = Path.Combine(upLoadFolder, uniqueFileName);
                slide.Image.CopyTo(new FileStream(filePath, FileMode.Create));
            }

            return(uniqueFileName);
        }
Esempio n. 5
0
        // GET: Slides/Edit/5
        public async Task <IActionResult> Edit(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            var slide = await SlideEditViewModel.GetViewModelByModelId(id);

            if (slide == null)
            {
                return(NotFound());
            }
            return(View(slide));
        }
Esempio n. 6
0
        public ActionResult Edit([Bind(Include = "ID,Description,Position,IsPublished,Html")] SlideEditViewModel model)
        {
            if (ModelState.IsValid)
            {
                var slide = db.Slide.Find(model.ID);

                slide.Description   = model.Description;
                slide.Position      = model.Position;
                slide.IsPublished   = model.IsPublished;
                slide.Html          = model.Html;
                slide.ModifDate     = DateTime.Now;
                slide.ModifUserName = User.Identity.Name;

                db.Entry(slide).State = EntityState.Modified;
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            return(View(model));
        }
 public async Task <IActionResult> Edit(SlideEditViewModel slide)
 {
     if (ModelState.IsValid)
     {
         try
         {
             Slide slide1 = _context.Slides.Find(slide.Id);
             slide1.DisplayOrder = slide.DisplayOrder;
             slide1.Description  = slide.Description;
             slide1.ModifiedDate = DateTime.Now;
             slide1.Link         = slide.Link;
             if (slide.Image != null)
             {
                 //if (slide.ExistImagePath != null)
                 //{
                 //    string filePath = Path.Combine(hostingEnvironment.WebRootPath, "image_slide", slide.ExistImagePath);
                 //    System.IO.File.Delete(filePath);
                 //}
                 slide1.Image = @"/image_slide/" + ProcessUploadedFile(slide);
             }
             _context.Update(slide1);
             await _context.SaveChangesAsync();
         }
         catch (DbUpdateConcurrencyException)
         {
             if (!SlideExists(slide.Id))
             {
                 return(NotFound());
             }
             else
             {
                 throw;
             }
         }
         return(RedirectToAction(nameof(Index)));
     }
     return(View(slide));
 }