public async Task <IActionResult> Create(ArtworkViewModel artwork)
{
if (ModelState.IsValid)
{
string uniqueFileName = UploadedFile(artwork);
Artwork art = new Artwork()
{
Title = artwork.Title,
Type = artwork.Type,
Length = artwork.Length,
Width = artwork.Width,
Price = artwork.Price,
ArtImage = uniqueFileName,
Materials = artwork.Materials.ToModel(m => new Material
{
MaterialId = m.MaterialId,
Title = m.Title,
Category = m.Category
}).ToList()
};
_context.Add(art);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Artwork)));
}
return(View());
}
public void CheckIfFirstAddedArtAlsoIsFirstInViewModel_FirstArtworkMatch()
{
List <Artwork> listOfArt = new List <Artwork>();
Artwork uniqueArt = new Artwork()
{
ArtName = "SameName"
};
listOfArt.Add(uniqueArt);
for (int i = 0; i < 10; i++)
{
Artwork art = new Artwork()
{
ArtName = "Test"
};
listOfArt.Add(art);
}
IEnumerable <Artwork> collectiveArt = listOfArt;
List <Member> member = new List <Member>();
ArtworkViewModel artworkViewmodel = new ArtworkViewModel(collectiveArt, member);
string expected = "SameName";
string actual = artworkViewmodel.CollectiveArt[0].ArtName;
Assert.Equal(expected, actual);
}
// GET: ArtWorks
//public ActionResult Index()
//{
// List<ArtworkViewModel> collection = new List<ArtworkViewModel>();
// try
// {
// using (ViewModels.ArtworkViewModel ViewModel = new ArtworkViewModel())
// {
// collection = ViewModel.GetData();
// }
// }
// catch (Exception ex)
// {
// throw ex;
// }
// return View(collection);
//}
public ActionResult GetDataPagination(int?Page_No)
{
List <ArtworkViewModel> collection = new List <ArtworkViewModel>();
var pagedData = new PagedDataSet <ArtworkViewModel>();
int pageSize = 10;
try
{
using (ViewModels.ArtworkViewModel ViewModel = new ArtworkViewModel())
{
var pageNumber = (Page_No.HasValue) ? ((Page_No.Value >= 1) ? Page_No.Value : 0) : 0;
pagedData = ViewModel.GetDataPagination(pageNumber);
//pick coilumns you need
var selectedData = (from p in pagedData.Items
select new
{
ArtWorkID = p.ArtWorkID
, ArtTitle = p.ArtTitle
, Location = p.CurrenTLocation.Value
}
).ToList();
// model = new PagedList<ArtworkViewModel>(collection, Page_No.HasValue?Page_No.Value:1, pageSize);
// //collection.ToPagedList(pageValue, 10);
// model.PageCount = ViewModel.GetData().Count();
// obj = ViewModel.GetDataPagination(Page_No);
}
}
catch (Exception ex)
{
throw ex;
}
return(View(pagedData.Items.ToPagedList(pageNumber: Page_No ?? 1, pageSize: 10)));
}
public IActionResult Edit(Guid ArtworkId)
{
// get artwork from database (ArtworkModel)
ArtworkModel model = _artworkDataManager.GetOneArtwork(ArtworkId);
ArtworkViewModel viewModel = new ArtworkViewModel();
viewModel.Id = model.Id;
viewModel.Title = model.Title;
ArtistModel[] artists = _artistDataManager.GetArtists();
var artistList = artists.Select(x => new { x.Id, x.FullName }).ToList();
viewModel.ArtistDropdown = new SelectList(artistList, "Id", "FullName", model.Artist.FullName);
StyleModel[] styles = _artworkDataManager.GetStyles();
var styleList = styles.Select(x => new { x.Id, x.Style }).ToList();
viewModel.StyleDropdown = new SelectList(styleList, "Id", "Style", model.Style.Style);
viewModel.Year = model.Year;
viewModel.Description = model.Description;
viewModel.Type = model.Type;
viewModel.Price = model.Price;
viewModel.Availability = model.Availability;
// return view
return(View(viewModel));
}
public ActionResult Index(int?Page_No)
{
List <ArtworkViewModel> collection = new List <ArtworkViewModel>();
var pagedData = new PagedDataSet <ArtworkViewModel>();
int pageSize = 10;
try
{
using (ViewModels.ArtworkViewModel ViewModel = new ArtworkViewModel())
{
var pageNumber = (Page_No.HasValue) ? ((Page_No.Value >= 1) ? Page_No.Value : 0) : 0;
pagedData = ViewModel.GetDataPagination(pageNumber);
// model = new PagedList<ArtworkViewModel>(collection, Page_No.HasValue?Page_No.Value:1, pageSize);
// //collection.ToPagedList(pageValue, 10);
// model.PageCount = ViewModel.GetData().Count();
// obj = ViewModel.GetDataPagination(Page_No);
}
}
catch (Exception ex)
{
throw ex;
}
return(View(pagedData));
}
// GET: Artworks/Delete/5
public async Task <IActionResult> Delete(int?id)
{
if (id == null)
{
return(NotFound());
}
var artwork = await _context.Artwork
.Include(x => x.Materials)
.FirstOrDefaultAsync(x => x.ProductId == id);
var artworkViewModel = new ArtworkViewModel()
{
ArtId = artwork.ProductId,
Title = artwork.Title,
Type = artwork.Type,
Length = artwork.Length,
Width = artwork.Width,
Price = artwork.Price,
ExistingImage = artwork.ArtImage,
Materials = artwork.Materials.ToDynamicList(m => new MaterialViewModel()
{
MaterialId = m.MaterialId,
Title = m.Title,
Category = m.Category
})
};
if (artwork == null)
{
return(NotFound());
}
return(View(artworkViewModel));
}
public FileContentResult GetImg(int id)
{
try
{
byte[] fileData = null;
using (ArtworkViewModel vm = new ArtworkViewModel())
{
using (var c = new ArtWorkDBEntities1())
{
fileData = (from p in c.Artworks
where p.ArtworkID == id
select p.Image).FirstOrDefault();
var fileExtension = (from p in c.Artworks
where p.ArtworkID == id
select p.FileExtension).FirstOrDefault();
}
FileContentResult varFile = new FileContentResult(fileData, "image/octet-stream");
return(varFile);
// return new FileContentResult(fileData, "application/octet-stream", 1);
}
}
catch (Exception)
{
throw;
}
}
public ActionResult Create(ArtworkViewModel model)
{
ArtworkViewModel ViewModel = new ArtworkViewModel();
ModelState.Clear();
return(View(model));
}
public ActionResult Edit(ArtworkViewModel model)
{
var id = 0;
var viewModel = new ArtworkViewModel();
if (ModelState.IsValid)
{
if (model.Image != null)
{
//image cannot be length cannot be more than
byte[] pic = this.ConvertToBytes(model.Image);
string extension = System.IO.Path.GetExtension(model.Image.FileName);
if (extension == ".png" || extension.Equals(".jpeg") || extension.Equals(".jpg"))
{
model.fileExtension = extension;
model.Photo = pic;
id = model.Update(model);
if (id > 0)
{
using (ArtworkViewModel ArtWorkViewMod = new ArtworkViewModel())
{
viewModel = ArtWorkViewMod.GetObject(model.ArtWorkID);
}
}
}
else
{
ModelState.AddModelError("Image", "Invalid File formats:Only png,jpeg,jpg are allowed");
//throw new Exception("Invalid File formats:Only png,jpeg,jpg are allowed");
}
}
else
{
id = model.Update(model);
if (id > 0)
{
using (ArtworkViewModel ArtWorkViewMod = new ArtworkViewModel())
{
viewModel = ArtWorkViewMod.GetObject(model.ArtWorkID);
}
}
}
//map
}
else
{
//model errors
ModelState.AddModelError("", "There are form errors; please correct them to continue!");
}
// return RedirectToAction("Edit", new { id = model.ArtWorkID });
return(View(model));
}
public async Task <IActionResult> Index(string Id)
{
var member = MemberRepository.GetAllMembers();
IEnumerable <Artwork> listOfArtworks = await ArtRepository.GetArtThatsPosted();
ArtworkViewModel = new ArtworkViewModel(listOfArtworks, member);
return(View(ArtworkViewModel));
}
public void CheckIfViewModelCanContainEmptyList_ReturnsEmptyList()
{
IEnumerable <Artwork> collectiveArt = new List <Artwork>();
List <Member> member = new List <Member>();
ArtworkViewModel artworkViewmodel = new ArtworkViewModel(collectiveArt, member);
Assert.NotNull(artworkViewmodel);
}
public IActionResult Index()
{
ArtworkViewModel artworkViewModel = new ArtworkViewModel();
artworkViewModel.AllArtwork = _artworkRepository.AllArtwork;
artworkViewModel.ArtworkCount = _artworkRepository.AllArtwork.Count();
return(View(artworkViewModel));
}
public ActionResult CreateArtwork()
{
var viewModel = new ArtworkViewModel();
viewModel.Artists = new ArtistRepository().GetAllArtist().ToList().ConvertToViewModel();
viewModel.Categories = new CategoryRepository().GetAllCategories().ToList().ConvertToViewModel();
return(View(viewModel));
}
public IActionResult AddArtwork(ArtworkViewModel model)
{
ArtistModel artistmodel = _artistDataManager.GetOneArtist(model.SelectedArtist);
StyleModel stylemodel = _artworkDataManager.GetOneStyle(model.SelectedStyle);
_artworkDataManager.AddArtwork(model.Title, artistmodel, stylemodel, model.Year, model.Description, model.Type, model.Price, model.Availability);
return(RedirectToAction(nameof(Index)));
}
/// <summary>
/// Returns the ViewModel and enables presentation of posted Artworks and Exhibition on the Home page.
/// </summary>
/// <param name="members"></param>
/// <returns></returns>
public async Task <ArtworkViewModel> GetViewModel(List <Member> members)
{
var listOfArt = await GetArtThatsPosted();
var listOfArtFromExhibitions = await GetAllArtToExhibitions();
List <Exhibit> exhibits = await GetExhibits();
var model = new ArtworkViewModel(listOfArt, members, exhibits, listOfArtFromExhibitions.ToList());
return(model);
}
public ActionResult EditArtwork(int artworkId)
{
var artwork = _artRepository.Get(artworkId);
var viewModel = new ArtworkViewModel
{
Id = artwork.Id,
Name = artwork.Name
};
return(View(viewModel));
}
public IActionResult FavoriteArtworks()
{
var user = _userManager.GetUserAsync(User).Result;
ArtworkViewModel viewModel = new ArtworkViewModel();
var artworks = _artworkDataManager.GetFavoriteArtworks(user);
viewModel.Artworks = artworks;
viewModel.UserId = user.Id;
/*foreach (var artwork in viewModel.Artworks){
* if (artwork.Users.Any(x => x.Id == viewModel.UserId)){}}*/
return(View("FavoriteArtworks", viewModel));
}
public ActionResult CreateArtwork(ArtworkViewModel model)
{
if (ModelState.IsValid)
{
var repo = new ArtworkRepository();
Artwork artwork = model.ConvertToBusinessModel();
artwork.Active = true;
artwork.Date = DateTime.Now;
repo.InsertArtwork(artwork);
}
model.Artists = new ArtistRepository().GetAllArtist().ToList().ConvertToViewModel();
model.Categories = new CategoryRepository().GetAllCategories().ToList().ConvertToViewModel();
return(View(model));
}
public static Artwork ConvertToBusinessModel(this ArtworkViewModel model)
{
var artwork = new Artwork
{
Artist = model.Artist,
Category = model.Category,
Description = model.Description,
ImgFileName = "",
Price = model.Price,
SizeHeight = model.SizeHeight,
SizeWidth = model.SizeWidth,
Title = model.Title
};
return(artwork);
}
private string UploadedFile(ArtworkViewModel artwork)
{
string uniqueFileName = null;
if (artwork.ProductImage != null)
{
string uploadsFolder = Path.Combine(webHostEnvironment.WebRootPath, "images");
uniqueFileName = Guid.NewGuid().ToString() + "_" + artwork.ProductImage.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
artwork.ProductImage.CopyTo(fileStream);
}
}
return(uniqueFileName);
}
public ActionResult Save(ArtworkViewModel model, HttpPostedFileBase file)
{
var id = 0;
var viewModel = new ArtworkViewModel();
if (ModelState.IsValid)
{
if (model.Image != null)
{
byte[] pic = this.ConvertToBytes(model.Image);
string extension = System.IO.Path.GetExtension(model.Image.FileName);
if (extension == ".png" || extension.Equals(".jpeg") || extension.Equals(".jpg"))
{
model.fileExtension = extension;
viewModel = model;
viewModel.Photo = pic;
}
else
{
throw new Exception("Invalid File formats:Only png,jpeg,jpg are allowed");
}
}
id = model.Update(viewModel);
if (id > 0)
{
using (ArtworkViewModel ArtWorkViewMod = new ArtworkViewModel())
{
viewModel = ArtWorkViewMod.GetObject(model.ArtWorkID);
}
}
}
else
{
//model errors
ModelState.AddModelError("", "There are form errors; please correct them to continue!");
}
return(RedirectToAction("Edit", new { id = model.ArtWorkID }));
}
public ActionResult Create(ArtworkViewModel model, HttpPostedFileBase file)
{
var newID = 0;
HttpPostedFileBase uploadfile = Request.Files["upload"];
var viewModel = new ArtworkViewModel();
if (ModelState.IsValid)
{
if (model.Image != null)
{
//image cannot be length cannot be more than
byte[] pic = this.ConvertToBytes(model.Image);
model.Photo = pic;
string extension = System.IO.Path.GetExtension(model.Image.FileName);
if (extension == ".png" || extension.Equals(".jpeg") || extension.Equals(".jpg"))
{
model.fileExtension = extension;
}
else
{
ModelState.AddModelError("", "Invalid File formats:Only png,jpeg,jpg are allowed");
throw new Exception("Invalid File formats:Only png,jpeg,jpg are allowed");
}
}
newID = model.Insert(model);
if (newID > 0)
{
using (ArtworkViewModel ArtWorkViewMod = new ArtworkViewModel())
{
viewModel = ArtWorkViewMod.GetObject(newID);
return(RedirectToAction("Edit", new { id = newID }));
}
}
}
else
{
//model errors
ModelState.AddModelError("", "There are form errors; please correct them to continue!");
}
return(View(model));
}
public async Task <IActionResult> Edit(int id, ArtworkViewModel artwork)
{
if (id != artwork.ArtId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
string uniqueFileName = UploadedFile(artwork);
var artModel = new Artwork();
artModel.ProductId = artwork.ArtId;
artModel.Title = artwork.Title;
artModel.Type = artwork.Type;
artModel.Length = artwork.Length;
artModel.Width = artwork.Width;
artModel.Price = artwork.Price;
artModel.ArtImage = uniqueFileName;
artModel.Materials = artwork.Materials.ToModel(m => new Material
{
MaterialId = m.MaterialId,
Title = m.Title,
Category = m.Category
}).ToList();
if (artwork.ProductImage == null)
{
artModel.ArtImage = uniqueFileName;
}
else if (artwork.ProductImage != null)
{
if (artwork.ExistingImage != null)
{
string filePath = Path.Combine(webHostEnvironment.WebRootPath, "images", artwork.ExistingImage);
System.IO.File.Delete(filePath);
}
artModel.ArtImage = UploadedFile(artwork);
}
_context.Update(artModel);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Artwork)));
}
return(View(artwork));
}
public async Task <IActionResult> Category(string Id)
{
List <Artwork> ArtList = new List <Artwork>();
var member = MemberRepository.GetAllMembers();
IEnumerable <Artwork> listOfArtworks = await ArtRepository.GetArtThatsPosted();
foreach (Artwork piece in listOfArtworks)
{
if (piece.Type == Id)
{
ArtList.Add(piece);
}
}
ArtworkViewModel = new ArtworkViewModel(ArtList, member);
return(View(Id, ArtworkViewModel));
}
public ActionResult Edit(Int32?id)
{
if (User.Identity.IsAuthenticated)
{
ArtworkViewModel ViewModel = new ArtworkViewModel();
if (id.HasValue)
{
ViewModel = ViewModel.GetObject(id.Value);
}
//does modle state have any errors
return(View(ViewModel));
}
else
{
return(RedirectToAction("Index", "ArtWorks"));
}
}
public ActionResult AddArtwork(ArtworkViewModel viewModel)
{
if (!ModelState.IsValid)
{
foreach (var error in ModelState.Values.SelectMany(m => m.Errors).Select(e => e.ErrorMessage))
{
_orchardServices.Notifier.Error(T(error));
}
return(RedirectToAction("AddArtwork"));
}
// If art file with the name already exist we are adding GUID ending
var fileName = viewModel.Name;
var existingArtwork = _artRepository.Table
.FirstOrDefault(a => a.ArtCulture == cultureUsed && a.Name == viewModel.Name);
if (existingArtwork != null)
{
fileName = string.Format(ArtworkFileNameTemplate, viewModel.Name, Guid.NewGuid());
}
var success = SaveArtworkImages(
viewModel.ArtworkSvgImage,
viewModel.ArtworkPngImage,
fileName);
if (!success)
{
return(RedirectToAction("AddArtwork"));
}
var art = new ArtRecord
{
Name = viewModel.Name,
FileName = string.Format(ArtworkSvgImageFileNameTemplate, viewModel.Name),
ArtCulture = cultureUsed
};
_artRepository.Create(art);
_orchardServices.Notifier.Information(T("Artwork \"{0}\" has been added", viewModel.Name));
return(RedirectToAction("Index"));
}
private ArtworkViewModel ModelToViewModel(Artwork model)
{
var artworkViewModel = new ArtworkViewModel()
{
ArtId = model.ProductId,
Title = model.Title,
Type = model.Type,
Length = model.Length,
Width = model.Width,
Price = model.Price,
Materials = model.Materials.ToDynamicList(m => new MaterialViewModel()
{
MaterialId = m.MaterialId,
Title = m.Title,
Category = m.Category
})
};
return(artworkViewModel);
}
public ActionResult EditArtwork(ArtworkViewModel viewModel)
{
if (!ModelState.IsValid)
{
foreach (var error in ModelState.Values.SelectMany(m => m.Errors).Select(e => e.ErrorMessage))
{
_orchardServices.Notifier.Error(T(error));
}
return(RedirectToAction("EditArtwork"));
}
var artwork = _artRepository.Get(viewModel.Id);
// If art file with the name already exist we are adding GUID ending
var fileName = viewModel.Name;
var existingArtwork = _artRepository.Table
.FirstOrDefault(a => a.Name == viewModel.Name && a != artwork);
if (existingArtwork != null)
{
fileName = string.Format(ArtworkFileNameTemplate, viewModel.Name, Guid.NewGuid());
}
var success = UpdateArtworkImages(
viewModel.ArtworkSvgImage,
viewModel.ArtworkPngImage,
fileName,
artwork.Name);
if (!success)
{
RedirectToAction("EditArtwork", new { artworkId = artwork.Id });
}
artwork.Name = viewModel.Name;
artwork.FileName = string.Format(ArtworkSvgImageFileNameTemplate, viewModel.Name);
_artRepository.Update(artwork);
_orchardServices.Notifier.Information(T("Artwork \"{0}\" has been edited.", artwork.Name));
return(RedirectToAction("Index"));
}
private Artwork ViewModelToModel(ArtworkViewModel viewModel)
{
string uniqueFileName = UploadedFile(viewModel);
return(new Artwork()
{
ProductId = viewModel.ArtId,
Title = viewModel.Title,
Type = viewModel.Type,
Length = viewModel.Length,
Width = viewModel.Width,
Price = viewModel.Price,
ArtImage = uniqueFileName,
Materials = viewModel.Materials.ToModel(m => new Material
{
MaterialId = m.MaterialId,
Title = m.Title,
Category = m.Category
}).ToList()
});
}
public void CheckIfValuesMatchFromViewModel_AllArtFollowsFromViewModel()
{
List <Artwork> listOfArt = new List <Artwork>();
for (int i = 0; i < 10; i++)
{
Artwork art = new Artwork()
{
ArtName = "Test"
};
listOfArt.Add(art);
}
List <Member> member = new List <Member>();
IEnumerable <Artwork> collectiveArt = listOfArt;
ArtworkViewModel artworkViewmodel = new ArtworkViewModel(collectiveArt, member);
int expected = 10;
int actual = artworkViewmodel.CollectiveArt.Count;
Assert.Equal(expected, actual);
}
