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);
}
