public ActionResult Create()
{
var model = new AlbumCreateViewModel();
model.ChosenCategories = this.CategoryService.GetAllCheckbox().ToList();
return this.View(model);
}
public ActionResult AlbumCreate(AlbumCreateViewModel model)
{
ClaimsIdentity currentIdentity = User.Identity as ClaimsIdentity;
int userid = int.Parse(currentIdentity.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier).Value);
userRepo.CreateAlbum(userid, model.Name, model.Description);
#region notused
//using (PhotoExplorerEntities cx = new PhotoExplorerEntities())
//{
// AlbumEntityModel newEntityAlbum = new AlbumEntityModel()
// {
// Name = model.Name,
// Description = model.Description,
// };
// var userEntity = cx.Users.FirstOrDefault(u => u.Id == userid);
// userEntity.Albums.Add(newEntityAlbum);
// cx.SaveChanges();
//}
#endregion
System.Threading.Thread.Sleep(500);//simulate waiting time
return(RedirectToAction("Dashboard", "Account"));
}
public async Task <ActionResult> Create(AlbumCreateViewModel albumCreateViewModel)
{
if (!ModelState.IsValid)
{
ModelState.AddModelError(string.Empty, "Model is not valid");
return(View());
}
try
{
var newModel = await _albumService.AddAsync(new Album
{
Artist = _htmlEncoder.Encode(albumCreateViewModel.Artist),
Title = albumCreateViewModel.Title,
CoverUrl = albumCreateViewModel.CoverUrl,
Price = albumCreateViewModel.Price,
ReleaseDate = albumCreateViewModel.ReleaseDate
});
return(RedirectToAction(nameof(Details), new { id = newModel.Id }));
}
catch
{
return(View(albumCreateViewModel));
}
}
public IActionResult CreateArtiest(string inputStr = "")
{
AlbumCreateViewModel model = new AlbumCreateViewModel {
Titel = inputStr
};
return(View(model));
}
public IActionResult Create(AlbumCreateViewModel model)
{
var album = Mapper.Map <Album>(model);
var createdAlbum = this.AlbumService.CreateAlbum(album);
var albumViewModel = Mapper.Map <AlbumDetailsViewModel>(createdAlbum);
return(this.Details(albumViewModel));
}
public IActionResult CreateAlbum(string inputStr)
{
AlbumCreateViewModel model = new AlbumCreateViewModel()
{
Artiest = inputStr
};
return(View(model));
}
public ActionResult Create(AlbumCreateViewModel createModel)
{
if (ModelState.IsValid)
{
if (this.AlbumService.Create(createModel))
{
return this.RedirectToAction("Index", "AlbumCategory");
}
}
return this.View(createModel);
}
public static Album MapAlbum(this AlbumCreateViewModel viewModel)
{
var album = new Album
{
Id = Guid.NewGuid(),
Name = viewModel.Name,
UserId = UserRepository.GetUserId(viewModel.Creator)
};
return(album);
}
public ActionResult Create(AlbumCreateViewModel model)
{
if (ModelState.IsValid)
{
AlbumRepository.Add(model.MapAlbum());
var albums = new List <AlbumViewModel>();
albums.MapAlbums(AlbumRepository.GetItems().ToList());
return(PartialView("List", albums));
}
return(PartialView(model));
}
public async Task <IActionResult> Create(AlbumCreateViewModel albumCreateViewModel)
{
if (!ModelState.IsValid)
{
ModelState.AddModelError(string.Empty, "創建失敗");
return(View());
}
var entity = _mapper.Map <Album>(albumCreateViewModel);
await _albumService.AddAsync(entity);
return(RedirectToAction("Details", new { id = entity.Id }));
}
public IActionResult Create(AlbumCreateViewModel model)
{
var name = model.Name.UrlDecode();
var cover = model.Cover.UrlDecode();
if (this.albumService.ContainsAlbum(name))
{
this.Model.Data[DisplayError] = Inline;
this.Model.Data[ErrorMessage] = AlbumNameExists;
return(this.View());
}
this.albumService.AddAlbum(name, cover);
return(new RedirectResult("/Album/All"));
}
public IActionResult Create(AlbumCreateViewModel model)
{
Album album = new Album
{
Naam = model.Naam
};
using (MemoryStream stream = new MemoryStream())
{
model.Foto.CopyTo(stream);
album.AlbumFoto = stream.ToArray();
}
_context.Albums.Add(album);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Create(AlbumCreateViewModel album)
{
if (!ModelState.IsValid)
{
return(View(album));
}
var owner = User.Identity.Name.ToLowerInvariant();
if (this.repository.GetAlbumsByOwner(owner).FirstOrDefault(o => o.AlbumId == SlugHelper.GetSlug(album.Title)) != null)
{
ModelState.AddModelError("Title", "An album with the same name already exists.");
return(View(album));
}
this.repository.CreateAlbum(album.Title, owner);
return(RedirectToAction("Index"));
}
public IActionResult Create(AlbumCreateViewModel model)
{
string name = model.Name;
string cover = model.Cover;
try
{
this.albumService.CreateAlbum(name, cover);
}
catch (Exception e)
{
var errorViewContent = File.ReadAllText(GlobalConstants.ErrorViewPath);
errorViewContent = errorViewContent.Replace(GlobalConstants.ErrorModel, e.Message);
return(this.ThrowError(errorViewContent));
}
return(this.Redirect(AllView));
}
public async Task <IActionResult> CreateAlbum(AlbumCreateViewModel model)
{
MuziekArtiest artiest = _context.MuziekArtiest.FirstOrDefault(ma => ma.Naam == model.Artiest);
if (artiest == null)
{
_context.MuziekArtiest.Add(new MuziekArtiest()
{
Naam = model.Artiest
});
artiest = _context.MuziekArtiest.FirstOrDefault(ma => ma.Naam == model.Artiest);
_context.SaveChanges();
}
MuziekAlbum album = _context.MuziekAlbum.FirstOrDefault(ma => ma.ArtiestId == _context.MuziekArtiest.FirstOrDefault(mar => mar.Naam == model.Artiest).Id&& ma.Titel == model.Titel);
int id;
if (album == null)
{
MuziekAlbum muziekAlbum = new MuziekAlbum()
{
ArtiestId = _context.MuziekArtiest.FirstOrDefault(ma => ma.Naam == model.Artiest).Id,
Titel = model.Titel
};
if (model.AlbumArt != null)
{
using (var memoryStream = new MemoryStream())
{
await model.AlbumArt.CopyToAsync(memoryStream);
muziekAlbum.AlbumArt = memoryStream.ToArray();
}
}
_context.MuziekAlbum.Add(muziekAlbum);
_context.SaveChanges();
id = _context.MuziekAlbum.FirstOrDefault(ma => ma.Titel == model.Titel).Id;
}
else
{
id = album.Id;
}
return(RedirectToAction("AlbumDetail", new { id }));
}
public ActionResult CreateAlbum(AlbumCreateViewModel model, HttpPostedFileBase file)
{
if (ModelState.IsValid && file != null && file.ContentLength > 0)
{
var currentUser = Session["User"] as UserDTO;
MemoryStream fileContent = new MemoryStream();
file.InputStream.CopyTo(fileContent);
_albumService.InsertAlbum(new AlbumDTO
{
AlbumName = model.AlbumName,
AlbumImage = fileContent.ToArray(),
UserId = currentUser.Id,
CategoryId = model.CategoryId
});
return(RedirectToAction("AllAlbums", "Album"));
}
return(View(model));
}
public ActionResult Create(AlbumCreateViewModel model)
{
if (ModelState.IsValid)
{
string uniqueFileName = null;
// If the Photo property on the incoming model object is not null, then the user
// has selected an image to upload.
if (model.Image != null)
{
// The image must be uploaded to the images folder in wwwroot
// To get the path of the wwwroot folder we are using the inject
// HostingEnvironment service provided by ASP.NET Core
string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "images");
// To make sure the file name is unique we are appending a new
// GUID value and an underscore to the file name
uniqueFileName = Guid.NewGuid().ToString() + "_" + model.Image.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
// Use CopyTo() method provided by IFormFile interface to
// copy the file to wwwroot/images folder
model.Image.CopyTo(new FileStream(filePath, FileMode.Create));
}
Album album = new Album();
album.AlbumId = 0;
album.Name = model.Name;
album.Type = model.Type;
album.Image = uniqueFileName;
this._albumRepository.Add(album);
return(RedirectToAction("Index"));
}
return(View());
}
public Task <Album> InsertAlbumAsync(AlbumCreateViewModel model)
{
throw new NotImplementedException();
}
public async Task <IHttpActionResult> CreateAlbum()
{
Response res;
List <Photo> AlbumPhotoList = new List <Photo>();
// Check if the request contains multipart/form-data.
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var provider = await Request.Content.ReadAsMultipartAsync <InMemoryMultipartFormDataStreamProvider>(new InMemoryMultipartFormDataStreamProvider());
//access form data
NameValueCollection formData = provider.FormData;
//access files
IList <HttpContent> files = provider.Files;
AlbumCreateViewModel acvm = new AlbumCreateViewModel()
{
AlbumName = formData["AlbumName"].ToString(),
SchoolCode = formData["SchoolCode"].ToString(),
};
foreach (HttpContent docfile in files)
{
string thisFileName = docfile.Headers.ContentDisposition.FileName.Trim('\"');
string fileFormat = docfile.Headers.ContentType.ToString();
if (fileFormat.Equals("image/jpeg") || fileFormat.Equals("image/png"))
{
Stream input = await docfile.ReadAsStreamAsync();
string baseUrl = $"{HttpContext.Current.Request.Url.Scheme}://{HttpContext.Current.Request.Url.Authority}{HttpContext.Current.Request.ApplicationPath.TrimEnd('/')}/";
string ServerDocsPath = $"{baseUrl}wwwroot/image/gallery/{acvm.SchoolCode}/{acvm.AlbumName}/";
string ServerDocsURL = ServerDocsPath + thisFileName;
string DocsPath = HttpContext.Current.Server.MapPath($"~/wwwroot/image/gallery/{acvm.SchoolCode}/{acvm.AlbumName}/");
string URL = DocsPath + thisFileName;
if (!Directory.Exists(DocsPath))
{
Directory.CreateDirectory(DocsPath);
}
if (File.Exists(URL))
{
File.Delete(URL);
}
using (Stream file = File.OpenWrite(URL))
{
input.CopyTo(file);
file.Close();
}
Photo photo = new Photo()
{
PHOTO_NAME = thisFileName,
PHOTO_IMG = ServerDocsURL
};
AlbumPhotoList.Add(photo);
}
}
if (AlbumPhotoList.Count > 0)
{
#region Insert Or Update Into DB
int lastAlbumId;
var CheckAlbum = _albumService.GetAllAlbums().
Where(
x => x.SchoolCode.ToLower().Equals(acvm.SchoolCode.ToLower()) &&
x.ALBUM_NAME.ToLower().Equals(acvm.AlbumName.ToLower())
).FirstOrDefault();
if (CheckAlbum == null)
{
Album InsertAlbum = new Album()
{
ALBUM_IMG = AlbumPhotoList?[0].PHOTO_IMG,
ALBUM_NAME = acvm.AlbumName,
SchoolCode = acvm.SchoolCode
};
_albumService.InsertAlbum(InsertAlbum);
lastAlbumId = _albumService.GetLatestAlbums(1).FirstOrDefault().ID;
}
else
{
lastAlbumId = CheckAlbum.ID;
}
foreach (var item in AlbumPhotoList)
{
item.ALBUM_ID = lastAlbumId;
var checkPhoto = _photoService.GetAllPhotos().Where(
x => x.ALBUM_ID.Equals(lastAlbumId) &&
x.PHOTO_NAME.ToLower().Equals(item.PHOTO_NAME.ToLower())
).FirstOrDefault();
if (checkPhoto == null)
{
_photoService.InsertPhoto(item);
}
}
#endregion
res = new Response()
{
ResponseCode = HttpStatusCode.OK.ToString(),
ResponseMessage = "Success",
Result = "Album Created Successfully."
};
}
else
{
res = new Response()
{
ResponseCode = HttpStatusCode.OK.ToString(),
ResponseMessage = "Success",
Result = "Album Not Created."
};
}
return(Ok(res));
}
// GET: Album/Create
public ActionResult Create()
{
var newModel = new AlbumCreateViewModel();
return(View(newModel));
}
