public override void OnNavigatedTo(NavigatedToEventArgs e, Dictionary <string, object> viewModelState)
{
Album = JsonConvert.DeserializeObject <VideoAlbum>(e.Parameter.ToString());
if (viewModelState.Count > 0)
{
Videos = JsonConvert.DeserializeObject <PaginatedCollection <Video> >(
viewModelState[nameof(Videos)].ToString());
_offset = (int)viewModelState[nameof(_offset)];
Videos.LoadMoreItems = LoadMoreVideos;
}
else
{
_offset = 0;
Videos = new PaginatedCollection <Video>(LoadMoreVideos);
}
if (Videos.Count > 0)
{
SetDefaultMode();
}
base.OnNavigatedTo(e, viewModelState);
}
public async Task <ActionResult <VideoAlbumDto> > PutVideoAlbum([FromRoute] int id, [FromBody] VideoAlbumDto videoAlbumDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != videoAlbumDto.ID)
{
return(BadRequest());
}
VideoAlbum videoAlbum = DtoToEntityIMapper.Map <VideoAlbumDto, VideoAlbum>(videoAlbumDto);
repository.ModifyEntryState(videoAlbum, EntityState.Modified);
try
{
await uoW.SaveAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!VideoAlbumExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public AlbumHeader(VideoAlbum va, bool pickMode = false, bool forceAllowEditDelete = false)
{
this._va = va;
this._pickMode = pickMode;
this._forceAllowEditDelete = forceAllowEditDelete;
EventAggregator.Current.Subscribe(this);
}
public int addVideoAlbum(string title, string description)
{
VideoAlbum videoAlbum = new VideoAlbum();
videoAlbum.Title = title;
videoAlbum.Description = description;
this.db.VideoAlbums.InsertOnSubmit(videoAlbum);
return videoAlbum.VideoAlbumId;
}
public VideoCatalogItem(VideoAlbum album)
{
this.id = album.id;
this.owner_id = album.owner_id;
this.title = album.title;
this.count = album.count;
this.updated_time = album.updated_time;
this.type = "album";
this.photo_160 = album.photo_160;
this.photo_320 = album.photo_320;
}
public async Task <IHttpActionResult> GetVideoAlbum(int id)
{
VideoAlbum item = await UoW.GetRepository <VideoAlbum>().GetItemAsycn(e => e.ID == id);
if (item == null)
{
return(NotFound());
}
var DTO = EntityToDtoIMapper.Map <VideoAlbum, VideoAlbumDto>(item);
return(Ok(DTO));
}
public IActionResult CreateVideoAlbum()
{
VideoAlbum videoAlbum = new VideoAlbum();
videoAlbum = db.VideoAlbums.FirstOrDefault(x => x.Name == "New");
if (videoAlbum != null)
{
videoAlbum.Name = "New";
db.VideoAlbums.Add(videoAlbum);
db.SaveChanges();
}
return(View(videoAlbum));
}
public async Task <IHttpActionResult> DeleteVideoAlbum(int id)
{
VideoAlbum videoAlbum = await UoW.GetRepository <VideoAlbum>().GetItemAsycn(e => e.ID == id);
if (videoAlbum == null)
{
return(NotFound());
}
UoW.GetRepository <VideoAlbum>().Delete(videoAlbum);
await UoW.SaveAsync();
return(Ok(videoAlbum));
}
public async Task <ActionResult <VideoAlbumDto> > PostVideoAlbum([FromBody] VideoAlbumDto videoAlbumDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
VideoAlbum videoAlbum = DtoToEntityIMapper.Map <VideoAlbumDto, VideoAlbum>(videoAlbumDto);
repository.Add(videoAlbum);
await uoW.SaveAsync();
return(CreatedAtAction("GetVideoAlbum", new { id = videoAlbum.ID }, videoAlbumDto));
}
public void Update(VideoAlbum obj, out OperationResult operationResult)
{
lock (Lock)
{
if (obj == null)
{
operationResult = new OperationResult {
Type = OperationResult.ResultType.Warning
};
return;
}
Common.Instance.Update
(obj, objs => objs.VideoAlbumId == obj.VideoAlbumId && objs.LanguageId == obj.LanguageId, out operationResult);
}
}
public void Insert(VideoAlbum obj, out OperationResult operationResult)
{
lock (Lock)
{
if (obj == null)
{
operationResult = new OperationResult {
Type = OperationResult.ResultType.Warning
};
}
else
{
Common.Instance.Insert(obj, out operationResult);
}
}
}
public async Task <IActionResult> EditVideoAlbum(VideoAlbum videoAlbum, IFormFile uploadedFile)
{
if (uploadedFile != null)
{
string path = $"/Media/Video/{videoAlbum.Name}/{uploadedFile.FileName}";
using (var fileStream = new FileStream(
_appEnvironment.WebRootPath + path, FileMode.Create))
{
await uploadedFile.CopyToAsync(fileStream);
}
videoAlbum.PathToCover = path;
}
db.VideoAlbums.Update(videoAlbum);
await db.SaveChangesAsync();
return(RedirectToAction("Video"));
}
public VideoAlbum getVideoAlbum(int videoAlbumId)
{
VideoAlbum result;
try
{
VideoAlbum videoAlbum = (
from a in this.db.VideoAlbums
where a.VideoAlbumId == videoAlbumId
select a).FirstOrDefault<VideoAlbum>();
result = videoAlbum;
}
catch (ArgumentNullException)
{
result = new VideoAlbum
{
VideoAlbumId = -1
};
}
return result;
}
public async Task <ActionResult <VideoAlbumDto> > DeleteVideoAlbum([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
VideoAlbum videoAlbum = await repository.GetAsync(a => a.ID == id);
if (videoAlbum == null)
{
return(NotFound());
}
repository.Delete(videoAlbum);
await uoW.SaveAsync();
VideoAlbumDto videoAlbumDto = EntityToDtoIMapper.Map <VideoAlbum, VideoAlbumDto>(videoAlbum);
return(Ok(videoAlbumDto));
}
public async Task <StatusCodeResult> AddVideo(int?id, IFormFile uploadedFile)
{
VideoAlbum videoAlbum = await db.VideoAlbums.FirstOrDefaultAsync(videoAlbum => videoAlbum.Id == id);
Video video = new Video();
string path = $"/Media/Video/{videoAlbum.Name}/{uploadedFile.FileName}";
using (FileStream fileStream = new FileStream(_appEnvironment.WebRootPath + path, FileMode.Create, FileAccess.Write))
{
await uploadedFile.CopyToAsync(fileStream);
}
video.Name = uploadedFile.FileName;
video.VideoAlbumId = id;
video.PathToVideo = path;
video.VideoAlbum = videoAlbum;
await db.Videos.AddAsync(video);
await db.SaveChangesAsync();
return(StatusCode(200));
}
public async Task <IActionResult> CreateVideoAlbum(VideoAlbum videoAlbum, IFormFile uploadedFile)
{
if (uploadedFile != null)
{
string path = $"/Media/Video/";
string subPath = $"{videoAlbum.Name}/";
CreateDirectory(path, subPath);
using (var fileStream = new FileStream(
_appEnvironment.WebRootPath + path + subPath + uploadedFile.FileName, FileMode.Create))
{
await uploadedFile.CopyToAsync(fileStream);
}
videoAlbum.PathToCover = path + subPath + uploadedFile.FileName;
}
db.VideoAlbums.Add(videoAlbum);
await db.SaveChangesAsync();
return(RedirectToAction("Video"));
}
public async Task <IActionResult> DeleteVideoAlbum(int?id)
{
if (id != null)
{
VideoAlbum videoAlbum = await db.VideoAlbums.FirstOrDefaultAsync(x => x.Id == id);
if (videoAlbum != null)
{
foreach (var video in db.Videos.Where(x => x.VideoAlbumId == id))
{
db.Videos.Remove(video);
DeleteFileFromDirectory(video.PathToVideo);
}
db.VideoAlbums.Remove(videoAlbum);
await db.SaveChangesAsync();
DeleteDirectory(videoAlbum.PathToCover);
return(RedirectToAction("Video"));
}
}
return(NotFound());
}
public async Task <ActionResult <VideoDto> > AssociateWithVideos([FromRoute] int id, [FromBody] int[] albumIDs)
{
Video video = await repository.GetAsync(e => e.ID == id);
if (video == null)
{
return(BadRequest());
}
foreach (int albumID in albumIDs)
{
VideoAlbum videoAlbum = await uoW.GetRepository <VideoAlbum>().GetAsync(e => e.ID == id);
if (videoAlbum == null)
{
continue;
}
var relation = new VideoAlbumVideo()
{
VideoAlbumID = albumID,
VideoID = id,
Video = video,
VideoAlbum = videoAlbum
};
if (videoAlbum.Videos == null)
{
video.VideoAlbums = new List <VideoAlbumVideo>();
}
repository.ModifyEntryState(video, EntityState.Modified);
video.VideoAlbums.Add(relation);
}
await uoW.SaveAsync();
return(Ok());
}
public MoveVideoToAlbum(VideoHeader video, VideoAlbum album)
: base(video)
{
this.Album = album;
}
public void Update(VideoAlbum album)
{
Exec("[dbo].[VideoAlbum_Update]", album);
}
public int Insert(VideoAlbum album)
{
return(Exec <int>("[dbo].[VideoAlbum_Insert]", album));
}
