public HttpResponseMessage Update(HttpRequestMessage request, SlideViewModel slideViewModel)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
//trả về lỗi để bên ngoài bắt được sự kiện lỗi này
response = request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var dbSlide = _sildeService.GetById(slideViewModel.ID);
dbSlide.UpdateSlide(slideViewModel);
_sildeService.Update(dbSlide);
_sildeService.Save();
var responseData = Mapper.Map <Slide, SlideViewModel>(dbSlide);
response = request.CreateResponse(HttpStatusCode.Created, responseData);
}
return response;
}));
}
public IActionResult Edit(SlideViewModel model)
{
if (model == null)
{
return(NotFound());
}
var slide = _mapper.Map <SlideViewModel, HomeSlider>(model);
if (ModelState.IsValid)
{
var updateslide = _homeRepository.GEtHomeSliderById(model.Id);
if (model.File == null)
{
slide.Image = updateslide.Image;
}
else
{
slide.Image = _fileManager.Upload(model.File);
}
updateslide.ModifiedBy = _admin.Name;
updateslide.ModifiedDate = DateTime.Now;
_homeRepository.UpdateSlide(updateslide, slide);
return(RedirectToAction("index"));
}
return(View(model));
}
public App()
{
// The root page of your application
SlideViewModel model = new SlideViewModel();
MainPage = new SlidePage(model);
}
public async Task <IActionResult> EditSlide(int Id, Image newimage, IFormFile file)
{
if (Id != newimage.Id)
{
Content("Invalid Id");
}
SlideViewModel slideViewModel = new SlideViewModel();
slideViewModel.Image = await _offerDbContext.Images.SingleOrDefaultAsync(x => x.Id == Id);
if (slideViewModel.Image != null)
{
if (file == null || file.Length == 0)
{
Content("No file chosen");
return(View());
}
string slidePath = Path.Combine(_hostenv.WebRootPath, "images", Path.GetFileName(file.FileName));
using (var stream = new FileStream(slidePath, FileMode.Create))
{
await file.CopyToAsync(stream);
}
newimage.Path = file.FileName;
slideViewModel.Image.Path = newimage.Path;
await _offerDbContext.SaveChangesAsync();
}
return(RedirectToAction(nameof(Slide)));
}
public ActionResult Put(SlideViewModel slideVm)
{
var message = string.Empty;
if (ModelState.IsValid)
{
var slide = _SlideService.GetById(slideVm.ID);
if (slide != null)
{
try
{
slide.UpdateSlide(slideVm);
_SlideService.Update(slide);
_SlideService.Save();
message = ResultState.Update_SUCCESS;
return(RedirectToAction("Index", "Slide"));
}
catch (Exception e)
{
ModelState.AddModelError("", e.Message);
}
}
else
{
ModelState.AddModelError("", "Không tìm dữ liệu nào!");
}
}
else
{
ModelState.AddModelError("", ResultState.Update_FALSE);
}
return(View(slideVm));
}
// GET: CaiDat
public ActionResult Slide()
{
if (Session["MaTKAdmin"] == null)
{
return(RedirectToAction("Login", "Admin"));
}
else
{
try
{
ShopEntities shop = new ShopEntities();
ViewData["Slide1"] = shop.Slides.Single(s => s.MaAnh == 1);
ViewData["Slide2"] = shop.Slides.Single(s => s.MaAnh == 2);
var model = new SlideViewModel()
{
Slides1 = shop.Slides.ToList()[0],
Slides2 = shop.Slides.ToList()[1]
};
return(View(model));
}
catch (Exception)
{
return(RedirectToAction("Slide"));
}
}
}
public ActionResult Create(SlideViewModel viewmodel)
{
try
{
if (ModelState.IsValid)
{
var model = new Slide();
model.Img = viewmodel.Img;
model.Status = viewmodel.Status;
model.CreateDate = DateTime.Now;
model.Deleted = false;
model.CreateBy = 1;
_db.Slides.Add(model);
_db.SaveChanges();
Notification.set_flash("Lưu thành công!", "success");
ModelState.Clear();
}
else
{
Notification.set_flash("Nhập đầy đủ thông tin!", "warning");
}
return(View());
}
catch (Exception ex)
{
Notification.set_flash("Thêm thất bại!", "warning");
throw ex;
}
}
public IActionResult Create(SlideViewModel model)
{
if (model == null)
{
return(NotFound());
}
var homeslider = _mapper.Map <SlideViewModel, HomeSlider>(model);
if (ModelState.IsValid)
{
homeslider.AddedBy = _admin.Name;
homeslider.AddedDate = DateTime.Now;
if (model.File != null)
{
homeslider.Image = _fileManager.Upload(model.File);
}
else
{
homeslider.Image = null;
}
_homeRepository.CreateHomeSlider(homeslider);
return(RedirectToAction("index"));
}
return(View());
}
public IActionResult Edit(SlideViewModel slidevm, IFormFile uploadedFilePhoto, IFormFile uploadedFileVideo)
{
ViewBag.Slider = new SelectList(sliderService.GetSliders(), "Id", "Name");
if (ModelState.IsValid)
{
Slide slide = slideService.GetSlide(slidevm.Id);
slide.SliderId = slide.SliderId;
slide.Title = slidevm.Title;
slide.SubTitle = slidevm.SubTitle;
slide.Description = slidevm.Description;
slide.CallToActionText = slidevm.CallToActionText;
slide.CallToActionUrl = slidevm.CallToActionUrl;
slide.DisplayTexts = slidevm.DisplayTexts;
slide.SliderId = slidevm.SliderId;
slide.Position = slideService.CountSlide() + 1;
slide.AddedBy = slidevm.AddedBy;
slide.AddedDate = slidevm.AddedDate;
slide.ModifiedBy = User.Identity.Name ?? "username";
slide.ModifiedDate = DateTime.Now;
slide.Photo = slidevm.Photo;
slide.Video = slidevm.Video;
slideService.UpdateSlide(slide);
slideService.SaveSlide();
return(RedirectToAction("Index"));
}
return(View(slidevm));
}
public async Task <BaseReponse <ModelListResult <SlideViewModel> > > GetAllPaging(SlideRequest request)
{
var query = (await _slideRepository.FindAll()).AsNoTracking().AsParallel();
if (!string.IsNullOrEmpty(request.SearchText))
{
query = query.AsParallel().AsOrdered().WithDegreeOfParallelism(3).Where(x => x.Name.Contains(request.SearchText));
}
int totalRow = query.AsParallel().AsOrdered().WithDegreeOfParallelism(3).Count();
var data = query.AsParallel().AsOrdered().WithDegreeOfParallelism(3).OrderByDescending(x => x.Id)
.Skip((request.PageIndex - 1) * request.PageSize)
.Take(request.PageSize);
var items = new SlideViewModel().Map(data).ToList();
return(new BaseReponse <ModelListResult <SlideViewModel> >
{
Data = new ModelListResult <SlideViewModel>()
{
Items = items,
Message = Message.Success,
RowCount = totalRow,
PageSize = request.PageSize,
PageIndex = request.PageIndex
},
Message = Message.Success,
Status = (int)QueryStatus.Success
});
}
public async Task <IActionResult> Slide(IFormFile file, Image myimage)
{
if (file == null || file.Length == 0)
{
Content("No file chosen");
return(View());
}
string slidePath = Path.Combine(_hostenv.WebRootPath, "images", Path.GetFileName(file.FileName));
using (var stream = new FileStream(slidePath, FileMode.Create))
{
await file.CopyToAsync(stream);
}
myimage.Path = file.FileName;
_offerDbContext.Images.Add(myimage);
await _offerDbContext.SaveChangesAsync();
SlideViewModel svmodel = new SlideViewModel();
svmodel.Images = await _offerDbContext.Images.ToListAsync();
return(RedirectToAction(nameof(Slide)));
}
public async Task <IActionResult> Create(SlideViewModel model)
{
if (ModelState.IsValid)
{
var files = HttpContext.Request.Form.Files;
foreach (var Image in files)
{
if (Image != null && Image.Length > 0)
{
var file = Image;
var uploads = Path.Combine(_env.WebRootPath, "images/slidebanner");
if (file.Length > 0)
{
var fileName = ContentDispositionHeaderValue.Parse
(file.ContentDisposition).FileName.Trim('"');
System.Console.WriteLine(fileName);
using (var fileStream = new FileStream(Path.Combine(uploads, file.FileName), FileMode.Create))
{
await file.CopyToAsync(fileStream);
model.LinkImage = file.FileName;
}
}
}
}
var result = _mapper.Map <SlideViewModel, Slide>(model);
_slideService.Insert(result);
return(RedirectToAction("Index", "Slide"));
}
return(View());
}
public SlideViewModel Add(SlideViewModel viewModel)
{
var slide = Mapper.Map <SlideViewModel, Slide>(viewModel);
_slideRepository.Add(slide);
return(viewModel);
}
public async Task <IViewComponentResult> InvokeAsync()
{
try{
var sort = 1;
var slides = new List <SlideViewModel>();
var slideModel = await Task.Factory.StartNew(() => _imageRepo.GetSlide());
foreach (var s in slideModel)
{
var slide = new SlideViewModel()
{
Id = s.Id,
Name = s.Name,
Alias = s.Alias,
Image = s.Image,
Sort = sort
};
slides.Add(slide);
sort++;
}
return(View(slides));
}
catch (Exception ex)
{
_logger.Error(ex.Message);
throw;
}
}
public HttpResponseMessage Create(HttpRequestMessage request, SlideViewModel slideVm)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var newSlide = new Slide();
newSlide.UpdateSlide(slideVm);
newSlide.CreatedDate = DateTime.Now;
//newSlide.CreatedBy = User.Identity.Name;
_slideService.Add(newSlide);
_slideService.SaveChanges();
var responseData = Mapper.Map <Slide, SlideViewModel>(newSlide);
response = request.CreateResponse(HttpStatusCode.Created, responseData);
}
return response;
}));
}
public async Task <IActionResult> SaveEntity(SlideViewModel slideViewModel)
{
if (!ModelState.IsValid)
{
var allErrors = ModelState.Values.SelectMany(v => v.Errors);
return(new BadRequestObjectResult(allErrors));
}
else
{
if (slideViewModel.Id == 0)
{
var notificationId = Guid.NewGuid().ToString();
var announcement = new AnnouncementViewModel
{
Title = User.GetSpecificClaim("FullName"),
DateCreated = DateTime.Now,
Content = $"Slide {slideViewModel.Name} has been created",
Id = notificationId,
UserId = User.GetUserId(),
Image = User.GetSpecificClaim("Avatar"),
Status = Status.Active
};
var announcementUsers = new List <AnnouncementUserViewModel>()
{
new AnnouncementUserViewModel()
{
AnnouncementId = notificationId, HasRead = false, UserId = User.GetUserId()
}
};
_slideService.Add(announcement, announcementUsers, slideViewModel);
await _hubContext.Clients.All.SendAsync("ReceiveMessage", announcement);
}
else
{
var notificationId = Guid.NewGuid().ToString();
var announcement = new AnnouncementViewModel
{
Title = User.GetSpecificClaim("FullName"),
DateCreated = DateTime.Now,
Content = $"Slide {slideViewModel.Name} has been updated",
Id = notificationId,
UserId = User.GetUserId(),
Image = User.GetSpecificClaim("Avatar"),
Status = Status.Active
};
var announcementUsers = new List <AnnouncementUserViewModel>()
{
new AnnouncementUserViewModel()
{
AnnouncementId = notificationId, HasRead = false, UserId = User.GetUserId()
}
};
_slideService.Update(announcement, announcementUsers, slideViewModel);
await _hubContext.Clients.All.SendAsync("ReceiveMessage", announcement);
}
_slideService.Save();
return(new OkObjectResult(slideViewModel));
}
}
public bool RebuildCurrentSectionAfterSetNextSlide(SlideViewModel nextSlide)
{
MoveCurrentSlideContentToPrevSlide();
MoveNextSlideContentToCurrentSlide();
return(BuildCurrentSectionNextSlide(nextSlide));
}
public async Task <IActionResult> Slide()
{
SlideViewModel svmodel = new SlideViewModel();
svmodel.Images = await _offerDbContext.Images.ToListAsync();
return(View(svmodel));
}
public async Task <IActionResult> EditSlide(int Id)
{
SlideViewModel slideViewModel = new SlideViewModel();
slideViewModel.Image = await _offerDbContext.Images.SingleOrDefaultAsync(x => x.Id == Id);
return(View(slideViewModel));
}
public bool RebuildCurrentSectionAfterSetPrevSlide(SlideViewModel prevSlide)
{
MoveCurrentSlideContentToNextSlide();
MovePrevSlideContentToCurrentSlide();
return(BuildCurrentSectionPrevSlide(prevSlide));
}
public static void UpdateSlide(this Slide slide, SlideViewModel slideVm)
{
slide.ID = slideVm.ID;
slide.Name = slideVm.Name;
slide.Image = slideVm.Image;
slide.Url = slideVm.Url;
slide.DisplayOrder = slideVm.DisplayOrder;
slide.Status = slideVm.Status;
}
public ActionResult Create(SlideViewModel viewModel)
{
var slide = viewModel.Slide;
_unitOfWork.Slide.Add(slide);
_unitOfWork.Complete();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Delete(int sectionId, [FromForm] SlideViewModel model)
{
var slide = await repo.GetSlideAsync(model.Id);
repo.DeleteSlide(slide);
await repo.SaveAsync();
return(RedirectToAction("Index"));
}
public HttpResponseMessage Detail(HttpRequestMessage request, int id)
{
return(CreateHttpResponse(request, () =>
{
Slide slideDb = _slideService.GetById(id);
SlideViewModel slideVm = Mapper.Map <SlideViewModel>(slideDb);
return request.CreateResponse(HttpStatusCode.OK, slideVm);
}));
}
public static void UpdateSlide(this Slide slide, SlideViewModel slideVM)
{
slide.ID = slideVM.ID;
slide.Name = slideVM.Name;
slide.Description = slideVM.Description;
slide.Image = slideVM.Image;
slide.URL = slideVM.URL;
slide.DisplayOrder = slideVM.DisplayOrder;
slide.Status = slideVM.Status;
}
public Slide(SlideViewModel slideVm)
{
Name = slideVm.Name;
Description = slideVm.Description;
Image = slideVm.Image;
Url = slideVm.Url;
DisplayOrder = slideVm.DisplayOrder;
Status = slideVm.Status;
Content = slideVm.Content;
OrtherPageHome = slideVm.OrtherPageHome;
}
public static void UpdateSlide(this Slide slide, SlideViewModel slideVm)
{
slide.ID = slideVm.ID;
slide.Image = slideVm.Image;
slide.Name = slideVm.Name;
slide.Content = slideVm.Content;
slide.Status = slideVm.Status;
slide.DisplayOrder = slideVm.DisplayOrder;
slide.Description = slideVm.Description;
slide.Url = slideVm.Url;
}
public ActionResult Update(int id)
{
var model = _db.Slides.Where(x => x.SlideId == id).SingleOrDefault();
var viewModel = new SlideViewModel();
viewModel.SlideId = model.SlideId;
viewModel.Img = model.Img;
viewModel.Status = model.Status;
ViewBag.Img = model.Img;
return(View(viewModel));
}
public static SlideViewModel ToSlideViewModel(this Slide model)
{
var slideViewModel = new SlideViewModel();
slideViewModel.ID = model.ID;
slideViewModel.Name = model.Name;
slideViewModel.URL = model.URL;
slideViewModel.Image = model.Image;
slideViewModel.Description = model.Description;
slideViewModel.DisplayOrder = model.DisplayOrder;
return(slideViewModel);
}
public async Task <IActionResult> DeleteSlide(int Id, Image currentimage)
{
SlideViewModel svmodel = new SlideViewModel();
svmodel.Image = await _offerDbContext.Images.SingleOrDefaultAsync(x => x.Id == Id);
currentimage = svmodel.Image;
_offerDbContext.Images.Remove(currentimage);
await _offerDbContext.SaveChangesAsync();
return(RedirectToAction(nameof(Slide)));
}
public ActionResult MoveTo(SlideViewModel model)
{
var targetSlide = this.slides.GetById(model.Id);
// move to the left
if (model.Motion == SlideMotionType.MoveLeft)
{
Slide prevToprevSlide, nextSlide;
var prevSlide = this.slides.GetById((int)targetSlide.PrevSlideId);
targetSlide.PrevSlideId = prevSlide.PrevSlideId;
if(prevSlide.PrevSlideId != null)
{
prevToprevSlide = this.slides.GetById((int)prevSlide.PrevSlideId);
prevToprevSlide.NextSlideId = targetSlide.Id;
}
prevSlide.NextSlideId = targetSlide.NextSlideId;
if(targetSlide.NextSlideId != null)
{
nextSlide = this.slides.GetById((int)targetSlide.NextSlideId);
nextSlide.PrevSlideId = prevSlide.Id;
}
prevSlide.PrevSlideId = targetSlide.Id;
targetSlide.NextSlideId = prevSlide.Id;
}
// move to the right
if (model.Motion == SlideMotionType.MoveRight)
{
Slide nextToNextSlide, prevSlide;
var nextSlide = this.slides.GetById((int)targetSlide.NextSlideId);
targetSlide.NextSlideId = nextSlide.NextSlideId;
if(nextSlide.NextSlideId != null)
{
nextToNextSlide = this.slides.GetById((int)nextSlide.NextSlideId);
nextToNextSlide.PrevSlideId = targetSlide.Id;
}
nextSlide.PrevSlideId = targetSlide.PrevSlideId;
if(targetSlide.PrevSlideId != null)
{
prevSlide = this.slides.GetById((int)targetSlide.PrevSlideId);
prevSlide.NextSlideId = nextSlide.Id;
}
nextSlide.NextSlideId = targetSlide.Id;
targetSlide.PrevSlideId = nextSlide.Id;
}
// delete
if(model.Motion == SlideMotionType.Delete)
{
Slide prevSlide, nextSlide;
if(targetSlide.PrevSlideId != null)
{
prevSlide = this.slides.GetById((int)targetSlide.PrevSlideId);
prevSlide.NextSlideId = targetSlide.NextSlideId;
}
if(targetSlide.NextSlideId != null)
{
nextSlide = this.slides.GetById((int)targetSlide.NextSlideId);
nextSlide.PrevSlideId = targetSlide.PrevSlideId;
}
this.slides.Delete(targetSlide);
}
if(model.Motion == SlideMotionType.HardDelete)
{
targetSlide = this.slides.AllWithDeleted().FirstOrDefault(s => s.Id == model.Id);
this.slides.HardDelete(targetSlide);
}
if(model.Motion == SlideMotionType.Restore)
{
var lastSlide = this.slides.All().FirstOrDefault(s => s.NextSlideId == null);
targetSlide = this.slides.AllWithDeleted().FirstOrDefault(s => s.Id == model.Id);
lastSlide.NextSlideId = targetSlide.Id;
targetSlide.PrevSlideId = lastSlide.Id;
targetSlide.NextSlideId = null;
targetSlide.IsDeleted = false;
}
this.slides.Save();
return RedirectToAction("Index");
}
