public void ContainsFile_TestNullFile() { MediaFile file = null; MediaAlbum album = new MediaAlbum(); album.ContainsFile(file); }
private static async Task <MediaAlbum> EnsureTimelinePhotoAlbumExistsAsync( ApplicationDbContext dbContext, UserInfo userEntity) { if (!userEntity.TimelineImagesMediaAlbumId.HasValue) { var timelineAlbum = new MediaAlbum { User = userEntity, Title = "Timeline Photos", Description = "Photos posted to my timeline" }; userEntity.TimelineImagesAlbum = timelineAlbum; dbContext.MediaAlbums.Add(timelineAlbum); await dbContext.SaveChangesAsync(); return(timelineAlbum); } if (userEntity.TimelineImagesAlbum == null) { await dbContext.Entry(userEntity).Reference(u => u.TimelineImagesAlbum).LoadAsync(); } return(userEntity.TimelineImagesAlbum); }
public async Task Put( int id, AlbumDefinition modifyRequest) { MediaAlbum album = await DbContext.MediaAlbums.SingleOrDefaultAsync( a => a.MediaAlbumId == id); if (album == null) { throw new HttpResponseException(HttpStatusCode.NotFound); } if (album.UserId != UserId) { throw new HttpResponseException(HttpStatusCode.Forbidden); } UserInfo user = await GetUserInfoAsync(); HttpStatusCode result = await AlbumOperations.ChangeAlbumAsync( DbContext, user, id, modifyRequest); if (result != HttpStatusCode.OK) { throw new HttpResponseException(result); } }
public async Task PostImage(int albumId, AddImageToAlbum createRequest) { MediaAlbum albumEntity = await DbContext.MediaAlbums .SingleOrDefaultAsync(a => a.MediaAlbumId == albumId); if (albumEntity == null) { throw new HttpResponseException(HttpStatusCode.NotFound); } if (albumEntity.UserId != UserId) { throw new HttpResponseException(HttpStatusCode.Forbidden); } UserMedia mediaEntity = await DbContext.UserMedias .SingleOrDefaultAsync(um => um.UserMediaId == createRequest.MediaId); if (mediaEntity == null) { throw new HttpResponseException(HttpStatusCode.BadRequest); } if (mediaEntity.UserId != UserId) { throw new HttpResponseException(HttpStatusCode.Forbidden); } await AlbumOperations.AddMediaToAlbumAsync(DbContext, albumEntity, mediaEntity, createRequest); }
public static async Task <AlbumSummary> CreateAlbumAsync( ApplicationDbContext dbContext, UserInfo user, AlbumDefinition createRequest) { var entity = new MediaAlbum { User = user, Title = createRequest.Title, Description = createRequest.Description }; dbContext.MediaAlbums.Add(entity); await dbContext.SaveChangesAsync(); await SearchOperations.IndexAlbumAsync(entity); return(new AlbumSummary { Id = entity.MediaAlbumId, UserId = user.UserInfoId, Title = entity.Title, Description = entity.Description, SampleMediaUrls = new string[0] }); }
/// <summary> /// Creates or updates a cover photo for the specified album. /// </summary> /// <param name="album">The album to create or update the cover photo for.</param> /// <param name="mediaName">Optional: the display name of the media file.</param> /// <returns></returns> private async Task CreateOrUpdateCoverAsync(MediaAlbum album, string mediaName = null) { const string FILE_NAME = "MediaUrl"; var saveToDisk = true; var userId = await GetUserIdAsync(); album.UserId = userId; if (!HasUploadedFile(FILE_NAME)) { // if no file was uploaded, check for an existing media var fileId = Request.Form["MediaFileId"]; if (long.TryParse(fileId, out var mfid) && MediaFileExists(mfid, out var file, userId)) { // a stored media file exists, use it for the cover photo album.MediaFileId = mfid; album.MediaUrl = file.GetMediaUrl(); } else { album.MediaFileId = 0; album.MediaUrl = null; } }
public static async Task <HttpStatusCode> ChangeAlbumAsync( ApplicationDbContext dbContext, UserInfo user, int albumId, AlbumDefinition modifyRequest) { MediaAlbum entity = await dbContext.MediaAlbums.SingleOrDefaultAsync( a => a.MediaAlbumId == albumId); if (entity == null) { return(HttpStatusCode.NotFound); } if (entity.UserId != user.UserInfoId) { return(HttpStatusCode.Forbidden); } entity.Title = modifyRequest.Title; entity.Description = modifyRequest.Description; await dbContext.SaveChangesAsync(); await SearchOperations.IndexAlbumAsync(entity); return(HttpStatusCode.OK); }
public static async Task AddMediaToAlbumAsync( ApplicationDbContext dbContext, MediaAlbum albumEntity, UserMedia mediaEntity, AddImageToAlbum createRequest) { albumEntity.UserMedias.Add(mediaEntity); mediaEntity.MediaAlbum = albumEntity; if (mediaEntity.State == UserMediaState.UploadedButUnused) { mediaEntity.State = UserMediaState.InUse; } mediaEntity.Title = createRequest.Title; if (!string.IsNullOrWhiteSpace(createRequest.Description)) { mediaEntity.Description = await TextOperations.CreateTextAsync( dbContext, createRequest.Description); } await dbContext.SaveChangesAsync(); await SearchOperations.IndexMediaAsync(new[] { mediaEntity }); if (mediaEntity.Description != null) { await UserOperations.NotifyMentionsAsync( dbContext, "Album Entry", mediaEntity.UserId, mediaEntity.Description); } }
private MediaAlbum GetDefaultAlbum(int?id) { try { MediaAlbum album = _dbContext.MediaAlbums.FirstOrDefault(x => x.Id == id || x.ShortName == "Default"); if (album == null) { album = new MediaAlbum() { UserId = 1, ShortName = "Default", FullName = "Default Album", Description = "Album mặc định", CreateTime = DateTime.Now, }; _dbContext.MediaAlbums.Add(album); _dbContext.SaveChanges(); } return(album); } catch (Exception ex) { Console.WriteLine(ex); return(null); } }
/// <summary> /// Lägger till ett nytt album till databasen /// </summary> public void AddNewAlbum(MediaAlbum album) { using (var db = new MediaPlayerContext()) { db.MediaAlbums.Add(album); db.SaveChanges(); } }
private async Task <IActionResult> DoUploadFile(MediaAlbum album, IEnumerable <IFormFile> files, AppDBContext dbContext) { try { string albumDir = Path.Combine(mediaPath, album.ShortName); if (!Directory.Exists(albumDir)) { Directory.CreateDirectory(albumDir); } List <MediaFile> newFiles = new List <MediaFile>(); foreach (var file in files) { string fileName = file.FileName.ToLower(); string fileExt = Path.GetExtension(fileName); while (true) { fileName = Common.Random_Mix(6).ToLower() + fileExt; string filePath = Path.Combine(albumDir, fileName); if (!System.IO.File.Exists(filePath)) { using (var stream = new FileStream(filePath, FileMode.Create)) await file.CopyToAsync(stream); break; } } MediaFile newFile = new MediaFile() { AlbumId = album.Id, FileName = file.FileName.ToLower(), FullPath = Path.Combine(album.ShortName, fileName), FileSize = file.Length, CreateTime = DateTime.Now, }; newFiles.Add(newFile); dbContext.MediaFiles.Add(newFile); } dbContext.SaveChanges(); return(new JsonResult(new FileUploadResult { initialPreview = newFiles.Select(x => Path.Combine(mediaUrl, x.FullPath)).ToArray(), initialPreviewConfig = newFiles.Select(x => new { key = x.Id, caption = x.FileName, size = x.FileSize, showDrag = false }).ToArray(), })); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
public async Task <IActionResult> FileUpload(int?id, IEnumerable <IFormFile> files) { MediaAlbum album = GetDefaultAlbum(id); if (album == null) { return(BadRequest("Could not create Default Album!")); } return(await DoUploadFile(album, files, _dbContext)); }
public void ContainsFile_TestContainsFile() { MediaFile file = new MediaFile() { FileName = "filename", ImagePath = "imagepath" }; MediaAlbum album = new MediaAlbum(); album.MediaFiles.Add(file); Assert.IsTrue(album.ContainsFile(file)); }
/// <summary> /// Ändrar namnet på ett album i databasen /// </summary> public void ChangeAlbumName(MediaAlbum album, string newName) { using (var db = new MediaPlayerContext()) { album = GetPointerToAlbum(album.Name, db); if (album != null) { album.Name = newName; db.SaveChanges(); } } }
/// <summary> /// Tar bort ett album ur databasen /// </summary> public void DeleteAlbum(string albumName) { using (var db = new MediaPlayerContext()) { MediaAlbum albumToRemove = GetPointerToAlbum(albumName, db); if (albumToRemove != null) { db.MediaAlbums.Remove(albumToRemove); db.SaveChanges(); } } }
public static Task IndexAlbumAsync( MediaAlbum album) { return(IndexItemAsync( new MessageIndexEntry { ItemId = "album-" + album.MediaAlbumId, Title = album.Title, Content = album.Description, MediaAlbumId = album.MediaAlbumId })); }
/// <summary> /// Uppdaterar det aktuella albument i databasen /// </summary> public void UpdateAlbum(MediaAlbum updatedAlbum) { using (var db = new MediaPlayerContext()) { MediaAlbum existingAlbum = GetPointerToAlbum(updatedAlbum.Name, db); if (existingAlbum != null) { MatchExistingAlbumToUpdated(existingAlbum, updatedAlbum, db); CopyFileDescriptions(existingAlbum, updatedAlbum, db); db.SaveChanges(); } } }
/// <summary> /// Kontrollerar om det finns ett album med samma namn som metodparametern i databasen /// </summary> public bool AlbumExists(string albumName) { using (var db = new MediaPlayerContext()) { MediaAlbum album = GetPointerToAlbum(albumName, db); if (album != null) { return(true); } return(false); } }
public async Task <IActionResult> FileUploadBanner(int?id, IEnumerable <IFormFile> files) { var albumBanner = _dbContext.MediaAlbums.Include(x => x.MediaFiles).Where(x => x.ShortName.Equals("Banner")).Select(x => x.Id).FirstOrDefault(); MediaAlbum album = GetDefaultAlbumBanner(albumBanner); if (album == null) { return(BadRequest("Could not create Default Album!")); } return(await DoUploadFile(album, files, _dbContext)); }
/// <summary> /// Kopierar mediafilernas Description från albumet som ska sparas till det som finns lagrat i databasen /// </summary> /// <param name="existingAlbum"></param> /// <param name="updatedAlbum"></param> private void CopyFileDescriptions(MediaAlbum existingAlbum, MediaAlbum updatedAlbum, MediaPlayerContext db) { foreach (MediaFile updatedFile in updatedAlbum.MediaFiles) { foreach (MediaFile oldFile in existingAlbum.MediaFiles) { if (oldFile.Matches(updatedFile)) { oldFile.Description = updatedFile.Description; break; } } } }
public static async Task <AlbumDetail> GetAlbumAsync( ApplicationDbContext dbContext, int albumId) { MediaAlbum entity = await dbContext.MediaAlbums .Include(a => a.UserMedias.Select(um => um.Description)) .Include(a => a.UserMedias.Select(um => um.Likes.Select(like => like.User))) .Include(a => a.UserMedias.Select(um => um.CommentThread.Comments.Select(c => c.Text))) .Include(a => a.UserMedias.Select(um => um.CommentThread.Comments.Select(c => c.User.Avatar))) .Include(a => a.Likes.Select(like => like.User)) .Include(a => a.CommentThread.Comments.Select(c => c.Text)) .Include(a => a.CommentThread.Comments.Select(c => c.User.Avatar)) .SingleOrDefaultAsync(a => a.MediaAlbumId == albumId); if (entity == null) { return(null); } return(new AlbumDetail { Title = entity.Title, UserId = entity.UserId, Description = entity.Description, Items = entity.UserMedias .Select( um => new AlbumItem { Id = um.UserMediaId, UserId = um.UserId, Title = um.Title, Description = um.Description?.Content, CreatedTime = um.CreatedUtc.ToString("s"), CreatedTimeAgo = TimeOperations.GetTimeAgo(um.CreatedUtc), MediaUrl = UserMediaOperations.GetUrl(um), LikeUrl = UserMediaOperations.GetLikeUrl(um), LikeGroups = LikeOperations.MakeLikeGroups(um.Likes), CommentUrl = UserMediaOperations.GetCommentUrl(um), Comments = CommentOperations.GetComments(um.CommentThread) }) .ToList(), LikeUrl = $"/api/Albums/{entity.MediaAlbumId}/Like", LikeGroups = LikeOperations.MakeLikeGroups(entity.Likes), CommentUrl = $"/api/Albums/{entity.MediaAlbumId}/Comment", Comments = CommentOperations.GetComments(entity.CommentThread) }); }
/// <summary> /// Returnerar en lista med kopior av alla MediaFiles som finns i ett album i databasen /// </summary> public List <MediaFile> GetFilesFromAlbum(string albumName) { List <MediaFile> files = new List <MediaFile>(); using (var db = new MediaPlayerContext()) { MediaAlbum album = GetPointerToAlbum(albumName, db); if (album != null) { foreach (MediaFile file in album.MediaFiles) { files.Add(new MediaFile(file)); } } } return(files); }
public Task <IMediaAlbum> CreateAlbum(string title) { return(Task.Run(() => { IMediaAlbum album = null; string id = null; if (PHPhotoLibrary.SharedPhotoLibrary.PerformChangesAndWait(() => { var request = PHAssetCollectionChangeRequest.CreateAssetCollection(title); id = request.PlaceholderForCreatedAssetCollection.LocalIdentifier; }, out var error)) { var col = (PHAssetCollection)PHAssetCollection.FetchAssetCollections(new[] { id }, null).First(); album = new MediaAlbum(col); } return album; })); }
/// <summary> /// Tar bort och lägger till filer från albument i databasen så att det matchar albumet som ska sparas /// </summary> /// <param name="Albumet som finns lagrat i databasen"></param> /// <param name="Albumet som ska sparas"></param> private void MatchExistingAlbumToUpdated(MediaAlbum existingAlbum, MediaAlbum updatedAlbum, MediaPlayerContext db) { foreach (MediaFile file in updatedAlbum.MediaFiles) { if (!IsInList(file, existingAlbum.MediaFiles)) { existingAlbum.MediaFiles.Add(file); } } foreach (MediaFile file in existingAlbum.MediaFiles) { if (!IsInList(file, updatedAlbum.MediaFiles)) { RemoveMediaFile(file, db); break; } } }
public async Task <IMediaAlbum[]> GetAlbumsAsync() { if (!await RequestAuthorizationAsync()) { return(new IMediaAlbum[] { }); } var projection = new[] { MediaStore.Images.ImageColumns.BucketId, MediaStore.Images.ImageColumns.BucketDisplayName }; var list = new List <IMediaAlbum>(); var cur = Context.ContentResolver.Query( MediaStore.Files.GetContentUri("external"), projection, $"{new MediaAssetQueryHelper(MediaAlbumContentType.All).GetSelectionMediaType()}) GROUP BY ({MediaStore.Images.ImageColumns.BucketId}", null, null); if (cur != null && cur.Count > 0) { if (cur.MoveToFirst()) { do { var album = new MediaAlbum(Context) { Id = cur.GetString(cur.GetColumnIndex(MediaStore.Images.ImageColumns.BucketId)), Title = cur.GetString(cur.GetColumnIndex(MediaStore.Images.ImageColumns.BucketDisplayName)), }; list.Add(album); } while (cur.MoveToNext()); } cur.Close(); } return(list.OrderBy(a => a.Title).ToArray()); }
public AlbumDisplayHint GetDisplayHint(MediaAlbum album) { if (album.Name == Catalog) { return(new AlbumDisplayHint { OverlayIcon = "fa fa-cube" }); } if (album.Name == Content) { return(new AlbumDisplayHint { OverlayIcon = "fa fa-sitemap" }); } if (album.Name == Downloads) { return(new AlbumDisplayHint { OverlayIcon = "fa fa-download" }); } if (album.Name == Messages) { return(new AlbumDisplayHint { OverlayIcon = "fa fa-envelope" }); } if (album.Name == Customers) { return(new AlbumDisplayHint { OverlayIcon = "fa fa-user" }); } if (album.Name == Files) { // TODO: var(--success) should be system default. return(new AlbumDisplayHint { Color = "var(--success)" }); } return(null); }
/// <summary> /// Sparar det aktuella albumet i databasen /// </summary> private void Save(MediaAlbum album) { Repository repository = (Repository)FindResource("repository"); if (repository.AlbumExists(album.Name)) { if (MessageBox.Show("Do you want to overwrite it?", "Album exists in data base", MessageBoxButton.OKCancel) == MessageBoxResult.OK) { repository.UpdateAlbum(album); } } else { AddDescriptionWindow window = new AddDescriptionWindow(); if (window.ShowDialog() == true) { album.Name = window.ChosenText; album.DateCreated = DateTime.Now; repository.AddNewAlbum(album); } } }
public static async Task <HttpStatusCode> AddOrRemoveAlbumLikeAsync( ApplicationDbContext dbContext, string userId, int entryId, LikeRequest like) { MediaAlbum albumEntity = await dbContext.MediaAlbums .SingleOrDefaultAsync(te => te.MediaAlbumId == entryId); if (albumEntity == null) { // The entry id is part of the URL, so return a 404. return(HttpStatusCode.NotFound); } return(await LikeOperations.AddOrRemoveLikeAsync( dbContext, userId, entryId, le => le.MediaAlbumId, like)); }
public static async Task <HttpStatusCode> AddAlbumCommentAsync( ApplicationDbContext dbContext, string userId, int albumId, CommentRequest comment) { MediaAlbum albumEntity = await dbContext.MediaAlbums .SingleOrDefaultAsync(te => te.MediaAlbumId == albumId); if (albumEntity == null) { // The entry id is part of the URL, so return a 404. return(HttpStatusCode.NotFound); } return(await CommentOperations.AddCommentAsync( dbContext, userId, new CommentItemIds { AlbumId = albumId }, e => e.CommentThread, albumEntity, comment)); }
public static async Task <HttpStatusCode> SetAvatarImage( ApplicationDbContext dbContext, UserInfo user, SetImage request) { UserMedia media = await dbContext.UserMedias .SingleOrDefaultAsync(um => um.UserMediaId == request.MediaId); if (media == null) { return(HttpStatusCode.BadRequest); } if (!media.MediaAlbumId.HasValue) { if (user.AvatarsMediaAlbumId.HasValue) { media.MediaAlbumId = user.AvatarsMediaAlbumId; } else { var avatarsAlbum = new MediaAlbum { User = user, Title = "Avatar Images", Description = "Images used as my avatar" }; user.AvatarsAlbum = avatarsAlbum; media.MediaAlbum = avatarsAlbum; } } user.Avatar = media; await dbContext.SaveChangesAsync(); return(HttpStatusCode.OK); }