public void Rename(MediaFolder @new, MediaFolder old)
{
throw new NotImplementedException();
}
/// <summary>
/// Deletes the given model.
/// </summary>
/// <param name="model">The media</param>
public Task DeleteFolderAsync(MediaFolder model)
{
return(DeleteFolderAsync(model.Id));
}
public void Add(MediaFolder item)
{
MediaFolders.AddFolder(item);
}
public void Remove(MediaFolder item)
{
MediaFolders.RemoveFolder(item);
(new MediaContentProvider()).Delete(item);
}
public void MigrateUploadedFiles(SmartObjectContext ctx)
{
var fileSet = ctx.Set <MediaFile>();
var folderSet = ctx.Set <MediaFolder>();
using (var scope = new DbContextScope(ctx,
hooksEnabled: false,
autoCommit: false,
validateOnSave: false,
lazyLoading: false,
autoDetectChanges: false))
{
var albumId = _albumRegistry.GetAlbumByName(SystemAlbumProvider.Files)?.Id;
var rootFolder = _mediaFileSystem.GetFolder("Uploaded");
if (!rootFolder.Exists)
{
return;
}
ProcessFolder(rootFolder, albumId.Value);
void ProcessFolder(IFolder folder, int mediaFolderId)
{
var newFiles = new List <FilePair>();
foreach (var uploadedFile in _mediaFileSystem.ListFiles(folder.Path))
{
var file = new MediaFile
{
CreatedOnUtc = uploadedFile.LastUpdated,
UpdatedOnUtc = uploadedFile.LastUpdated,
Extension = uploadedFile.Extension.TrimStart('.'),
Name = uploadedFile.Name,
MimeType = MimeTypes.MapNameToMimeType(uploadedFile.Name),
Size = Convert.ToInt32(uploadedFile.Size),
FolderId = mediaFolderId,
Version = 2
};
ProcessMediaFile(file);
newFiles.Add(new FilePair {
MediaFile = file, UploadedFile = uploadedFile
});
fileSet.Add(file);
}
// Process/save files of current folder
try
{
// Save files to DB
int num = scope.Commit();
// Copy/Move files
foreach (var newFile in newFiles)
{
if (_isFsProvider)
{
var newPath = GetStoragePath(newFile.MediaFile);
if (!_mediaFileSystem.FileExists(newPath))
{
// TODO: (mm) (mc) should we actually MOVE the file?
_mediaFileSystem.CopyFile(newFile.UploadedFile.Path, newPath);
}
}
else
{
_mediaStorageProvider.Save(newFile.MediaFile, MediaStorageItem.FromFile(newFile.UploadedFile));
}
}
if (!_isFsProvider)
{
// MediaFile.MediaStorageId has been updated, we need to save again.
num = scope.Commit();
}
}
catch
{
throw;
}
finally
{
newFiles.Clear();
// Breathe
ctx.DetachEntities <MediaFile>(deep: true);
}
foreach (var uploadedFolder in _mediaFileSystem.ListFolders(folder.Path))
{
var mediaFolder = new MediaFolder
{
Name = uploadedFolder.Name,
ParentId = mediaFolderId
};
// Add folder and save ASAP, we need the folder id
folderSet.Add(mediaFolder);
ctx.SaveChanges();
ProcessFolder(uploadedFolder, mediaFolder.Id);
}
}
}
}
public IQueryable <MediaFolder> ChildFolders(MediaFolder parent)
{
return(MediaFolders.ChildFolders(parent).AsQueryable());
}
private void FolderRemoved(MediaFolder folder)
{
RaiseTreeNodeRemovedEvent(folder);
}
public static string GetMediaDirectoryPath(this MediaFolder mediaFolder)
{
return(UrlUtility.Combine(new string[] { mediaFolder.Repository.Name.ToLower(), MediaDirectoryName }
.Concat(mediaFolder.NamePaths)
.ToArray()));
}
/// <summary>
/// Adds or updates the given model in the database
/// depending on its state.
/// </summary>
/// <param name="model">The model</param>
public static void SaveFolder(this MediaService service, MediaFolder model)
{
service.SaveFolderAsync(model).GetAwaiter().GetResult();
}
public void LoadThumbnails(MediaFolder folder)
{
new Thread(() => LoadThumbnailsThread(folder)).Start();
}
/// <summary>
/// Replaces the file or if it doesn't exist, creates it.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// <c>PutFileResponse</c> with a file id.
/// </returns>
public PutFileResponse Put(PutFileRequest request)
{
IEnumerable <MediaFolder> parentFolderFuture = null;
if (request.Data.FolderId.HasValue)
{
parentFolderFuture = repository.AsQueryable <MediaFolder>()
.Where(c => c.Id == request.Data.FolderId.Value && !c.IsDeleted)
.ToFuture();
}
var mediaFile = repository.AsQueryable <MediaFile>()
.Where(file => file.Id == request.Id)
.FetchMany(f => f.AccessRules)
.ToFuture()
.FirstOrDefault();
MediaFolder parentFolder = null;
if (parentFolderFuture != null)
{
parentFolder = parentFolderFuture.First();
if (parentFolder.Type != Module.MediaManager.Models.MediaType.File)
{
throw new CmsApiValidationException("Folder must be type of an file.");
}
}
var createFile = mediaFile == null;
if (createFile)
{
mediaFile = new MediaFile
{
Id = request.Id.GetValueOrDefault(),
Type = Module.MediaManager.Models.MediaType.File,
AccessRules = new List <AccessRule>()
};
}
else if (request.Data.Version > 0)
{
mediaFile.Version = request.Data.Version;
}
unitOfWork.BeginTransaction();
if (!createFile)
{
repository.Save(mediaFile.CreateHistoryItem());
}
mediaFile.Title = request.Data.Title;
mediaFile.Description = request.Data.Description;
mediaFile.Size = request.Data.FileSize;
mediaFile.PublicUrl = request.Data.PublicUrl;
mediaFile.Folder = parentFolder;
mediaFile.PublishedOn = request.Data.PublishedOn;
mediaFile.OriginalFileName = request.Data.OriginalFileName;
mediaFile.OriginalFileExtension = request.Data.OriginalFileExtension;
mediaFile.Image = request.Data.ThumbnailId.GetValueOrDefault() != default(Guid)
? repository.AsProxy <MediaImage>(request.Data.ThumbnailId.Value)
: null;
mediaFile.FileUri = new Uri(request.Data.FileUri);
mediaFile.IsUploaded = request.Data.IsUploaded;
mediaFile.IsTemporary = request.Data.IsTemporary;
mediaFile.IsCanceled = request.Data.IsCanceled;
var archivedMedias = new List <Media>();
var unarchivedMedias = new List <Media>();
if (mediaFile.IsArchived != request.Data.IsArchived)
{
if (request.Data.IsArchived)
{
archivedMedias.Add(mediaFile);
mediaService.ArchiveSubMedias(mediaFile, archivedMedias);
}
else
{
unarchivedMedias.Add(mediaFile);
mediaService.UnarchiveSubMedias(mediaFile, unarchivedMedias);
}
}
mediaFile.IsArchived = request.Data.IsArchived;
IList <Tag> newTags = null;
if (request.Data.Tags != null)
{
tagService.SaveMediaTags(mediaFile, request.Data.Tags, out newTags);
}
if (request.Data.AccessRules != null)
{
mediaFile.AccessRules.RemoveDuplicateEntities();
var accessRules =
request.Data.AccessRules.Select(
r => (IAccessRule) new AccessRule {
AccessLevel = (Core.Security.AccessLevel)(int) r.AccessLevel, Identity = r.Identity, IsForRole = r.IsForRole
})
.ToList();
accessControlService.UpdateAccessControl(mediaFile, accessRules);
}
if (request.Data.Categories != null)
{
categoryService.CombineEntityCategories <Media, MediaCategory>(mediaFile, request.Data.Categories);
}
repository.Save(mediaFile);
unitOfWork.Commit();
// Fire events.
Events.RootEvents.Instance.OnTagCreated(newTags);
if (createFile)
{
Events.MediaManagerEvents.Instance.OnMediaFileUploaded(mediaFile);
}
else
{
Events.MediaManagerEvents.Instance.OnMediaFileUpdated(mediaFile);
}
foreach (var archivedMedia in archivedMedias.Distinct())
{
Events.MediaManagerEvents.Instance.OnMediaArchived(archivedMedia);
}
foreach (var archivedMedia in unarchivedMedias.Distinct())
{
Events.MediaManagerEvents.Instance.OnMediaUnarchived(archivedMedia);
}
return(new PutFileResponse
{
Data = mediaFile.Id
});
}
/// <summary>
/// Replaces the image or if it doesn't exist, creates it.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// <c>PutImageResponse</c> with a image id.
/// </returns>
public PutImageResponse Put(PutImageRequest request)
{
IEnumerable <MediaFolder> parentFolderFuture = null;
if (request.Data.FolderId.HasValue)
{
parentFolderFuture = repository.AsQueryable <MediaFolder>()
.Where(c => c.Id == request.Data.FolderId.Value && !c.IsDeleted)
.ToFuture();
}
var mediaImage = repository.AsQueryable <MediaImage>()
.Where(file => file.Id == request.Id)
.ToFuture()
.FirstOrDefault();
MediaFolder parentFolder = null;
if (parentFolderFuture != null)
{
parentFolder = parentFolderFuture.First();
if (parentFolder.Type != Module.MediaManager.Models.MediaType.Image)
{
throw new CmsApiValidationException("Folder must be type of an image.");
}
}
var createImage = mediaImage == null;
if (createImage)
{
mediaImage = new MediaImage
{
Id = request.Id.GetValueOrDefault(),
Type = Module.MediaManager.Models.MediaType.Image
};
}
else if (request.Data.Version > 0)
{
mediaImage.Version = request.Data.Version;
}
unitOfWork.BeginTransaction();
if (!createImage)
{
repository.Save(mediaImage.CreateHistoryItem());
}
mediaImage.Title = request.Data.Title;
mediaImage.Description = request.Data.Description;
mediaImage.Caption = request.Data.Caption;
mediaImage.Size = request.Data.FileSize;
mediaImage.PublicUrl = request.Data.ImageUrl;
mediaImage.Width = request.Data.Width;
mediaImage.Height = request.Data.Height;
mediaImage.PublicThumbnailUrl = request.Data.ThumbnailUrl;
mediaImage.ThumbnailWidth = request.Data.ThumbnailWidth;
mediaImage.ThumbnailHeight = request.Data.ThumbnailHeight;
mediaImage.ThumbnailSize = request.Data.ThumbnailSize;
mediaImage.Folder = parentFolder;
mediaImage.PublishedOn = request.Data.PublishedOn;
mediaImage.OriginalFileName = request.Data.OriginalFileName;
mediaImage.OriginalFileExtension = request.Data.OriginalFileExtension;
mediaImage.OriginalWidth = request.Data.OriginalWidth;
mediaImage.OriginalHeight = request.Data.OriginalHeight;
mediaImage.OriginalSize = request.Data.OriginalSize;
mediaImage.PublicOriginallUrl = request.Data.OriginalUrl;
mediaImage.FileUri = new Uri(request.Data.FileUri);
mediaImage.IsUploaded = request.Data.IsUploaded;
mediaImage.IsTemporary = request.Data.IsTemporary;
mediaImage.IsCanceled = request.Data.IsCanceled;
mediaImage.OriginalUri = new Uri(request.Data.OriginalUri);
mediaImage.ThumbnailUri = new Uri(request.Data.ThumbnailUri);
var archivedMedias = new List <Media>();
var unarchivedMedias = new List <Media>();
if (mediaImage.IsArchived != request.Data.IsArchived)
{
if (request.Data.IsArchived)
{
archivedMedias.Add(mediaImage);
mediaService.ArchiveSubMedias(mediaImage, archivedMedias);
}
else
{
unarchivedMedias.Add(mediaImage);
mediaService.UnarchiveSubMedias(mediaImage, unarchivedMedias);
}
}
mediaImage.IsArchived = request.Data.IsArchived;
if (request.Data.Categories != null)
{
categoryService.CombineEntityCategories <Media, MediaCategory>(mediaImage, request.Data.Categories);
}
repository.Save(mediaImage);
IList <Tag> newTags = null;
if (request.Data.Tags != null)
{
tagService.SaveMediaTags(mediaImage, request.Data.Tags, out newTags);
}
unitOfWork.Commit();
// Fire events.
Events.RootEvents.Instance.OnTagCreated(newTags);
if (createImage)
{
Events.MediaManagerEvents.Instance.OnMediaFileUploaded(mediaImage);
}
else
{
Events.MediaManagerEvents.Instance.OnMediaFileUpdated(mediaImage);
}
foreach (var archivedMedia in archivedMedias.Distinct())
{
Events.MediaManagerEvents.Instance.OnMediaArchived(archivedMedia);
}
foreach (var archivedMedia in unarchivedMedias.Distinct())
{
Events.MediaManagerEvents.Instance.OnMediaUnarchived(archivedMedia);
}
return(new PutImageResponse
{
Data = mediaImage.Id
});
}
/// <summary>
/// Replaces the folder or if it doesn't exist, creates it.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// <c>PutFolderResponse</c> with a folder id.
/// </returns>
public PutFolderResponse Put(PutFolderRequest request)
{
IEnumerable <MediaFolder> parentFolderFuture = null;
if (request.Data.ParentFolderId.HasValue)
{
parentFolderFuture = repository.AsQueryable <MediaFolder>()
.Where(c => c.Id == request.Data.ParentFolderId.Value && !c.IsDeleted)
.ToFuture();
}
var mediaFolder = repository.AsQueryable <MediaFolder>()
.Fetch(media => media.Folder)
.Distinct()
.ToFuture()
.FirstOrDefault(folder => folder.Id == request.Id);
MediaFolder parentFolder = null;
if (parentFolderFuture != null)
{
parentFolder = parentFolderFuture.First();
if (parentFolder.Type != (Module.MediaManager.Models.MediaType)(int) request.Data.Type)
{
throw new CmsApiValidationException("Parent folder type does not match to this folder type.");
}
}
var createFolder = mediaFolder == null;
if (createFolder)
{
mediaFolder = new MediaFolder
{
Id = request.Id.GetValueOrDefault(),
ContentType = Module.MediaManager.Models.MediaContentType.Folder,
Type = (Module.MediaManager.Models.MediaType)(int) request.Data.Type
};
}
else if (request.Data.Version > 0)
{
mediaFolder.Version = request.Data.Version;
}
unitOfWork.BeginTransaction();
mediaFolder.Title = request.Data.Title;
mediaFolder.Folder = parentFolder;
mediaFolder.PublishedOn = DateTime.Now;
var archivedMedias = new List <Media>();
var unarchivedMedias = new List <Media>();
if (mediaFolder.IsArchived != request.Data.IsArchived)
{
if (request.Data.IsArchived)
{
archivedMedias.Add(mediaFolder);
mediaService.ArchiveSubMedias(mediaFolder, archivedMedias);
}
else
{
unarchivedMedias.Add(mediaFolder);
mediaService.UnarchiveSubMedias(mediaFolder, unarchivedMedias);
}
}
mediaFolder.IsArchived = request.Data.IsArchived;
repository.Save(mediaFolder);
unitOfWork.Commit();
// Fire events.
if (createFolder)
{
Events.MediaManagerEvents.Instance.OnMediaFolderCreated(mediaFolder);
}
else
{
Events.MediaManagerEvents.Instance.OnMediaFolderUpdated(mediaFolder);
}
foreach (var archivedMedia in archivedMedias.Distinct())
{
Events.MediaManagerEvents.Instance.OnMediaArchived(archivedMedia);
}
foreach (var archivedMedia in unarchivedMedias.Distinct())
{
Events.MediaManagerEvents.Instance.OnMediaUnarchived(archivedMedia);
}
return(new PutFolderResponse {
Data = mediaFolder.Id
});
}
private void InternalDeleteFolder(
MediaFolder folder,
TreeNode <MediaFolderNode> node,
TreeNode <MediaFolderNode> root,
FolderDeleteResult result,
FileHandling strategy)
{
// (perf) We gonna check file tracks, so we should preload all tracks.
_fileRepo.Context.LoadCollection(folder, (MediaFolder x) => x.Files, false, q => q.Include(f => f.Tracks));
var files = folder.Files.ToList();
var lockedFiles = new List <MediaFile>(files.Count);
var trackedFiles = new List <MediaFile>(files.Count);
// First delete files
if (folder.Files.Any())
{
var albumId = strategy == FileHandling.MoveToRoot
? _folderService.FindAlbum(folder.Id).Value.Id
: (int?)null;
foreach (var batch in files.Slice(500))
{
foreach (var file in batch)
{
if (strategy == FileHandling.Delete && file.Tracks.Any())
{
// Don't delete tracked files
trackedFiles.Add(file);
continue;
}
if (strategy == FileHandling.Delete)
{
try
{
result.DeletedFileNames.Add(file.Name);
DeleteFile(file, true);
}
catch (DeleteTrackedFileException)
{
trackedFiles.Add(file);
}
catch (IOException)
{
lockedFiles.Add(file);
}
}
else if (strategy == FileHandling.SoftDelete)
{
DeleteFile(file, false);
file.FolderId = null;
result.DeletedFileNames.Add(file.Name);
}
else if (strategy == FileHandling.MoveToRoot)
{
file.FolderId = albumId;
result.DeletedFileNames.Add(file.Name);
}
}
_fileRepo.Context.SaveChanges();
}
if (lockedFiles.Any())
{
// Retry deletion of failed files due to locking.
// INFO: By default "LocalFileSystem" waits for 500ms until the lock is revoked or it throws.
foreach (var lockedFile in lockedFiles.ToArray())
{
try
{
DeleteFile(lockedFile, true);
lockedFiles.Remove(lockedFile);
}
catch { }
}
_fileRepo.Context.SaveChanges();
}
}
if (lockedFiles.Count > 0)
{
var fullPath = CombinePaths(root.Value.Path, lockedFiles[0].Name);
throw new IOException(T("Admin.Media.Exception.InUse", fullPath));
}
if (lockedFiles.Count == 0 && trackedFiles.Count == 0 && node.Children.All(x => result.DeletedFolderIds.Contains(x.Value.Id)))
{
// Don't delete folder if a containing file could not be deleted,
// any tracked file was found or any of its child folders could not be deleted..
_folderService.DeleteFolder(folder);
//_fileRepo.Context.SaveChanges();
result.DeletedFolderIds.Add(folder.Id);
}
result.LockedFileNames = lockedFiles.Select(x => x.Name).ToList();
result.TrackedFileNames = trackedFiles.Select(x => x.Name).ToList();
}
public void FolderCollapsed(MediaFolder folder)
{
//_expandedFolders.Remove(folder);
}
/// <summary>
/// Executes this command.
/// </summary>
public ConfirmUploadResponse Execute(MultiFileUploadViewModel request)
{
ConfirmUploadResponse response = new ConfirmUploadResponse {
SelectedFolderId = request.SelectedFolderId ?? Guid.Empty, ReuploadMediaId = request.ReuploadMediaId
};
if (request.UploadedFiles != null && request.UploadedFiles.Count > 0)
{
MediaFolder folder = null;
if (request.SelectedFolderId != null && request.SelectedFolderId.Value != Guid.Empty)
{
folder = Repository.AsProxy <MediaFolder>(request.SelectedFolderId.Value);
if (folder.IsDeleted)
{
response.FolderIsDeleted = true;
return(response);
}
}
UnitOfWork.BeginTransaction();
List <MediaFile> files = new List <MediaFile>();
if (request.ReuploadMediaId.HasDefaultValue())
{
foreach (var fileId in request.UploadedFiles)
{
if (!fileId.HasDefaultValue())
{
var file = Repository.FirstOrDefault <MediaFile>(fileId);
if (folder != null && (file.Folder == null || file.Folder.Id != folder.Id))
{
file.Folder = folder;
}
file.IsTemporary = false;
file.PublishedOn = DateTime.Now;
Repository.Save(file);
files.Add(file);
}
}
}
else
{
// Re-upload performed.
var fileId = request.UploadedFiles.FirstOrDefault();
if (!fileId.HasDefaultValue())
{
var originalMedia = Repository.First <MediaFile>(request.ReuploadMediaId);
var historyItem = originalMedia.CreateHistoryItem();
Repository.Save(historyItem);
var file = Repository.FirstOrDefault <MediaFile>(fileId);
file.CopyDataTo(originalMedia);
originalMedia.Description = historyItem.Description;
originalMedia.IsArchived = historyItem.IsArchived;
originalMedia.Folder = historyItem.Folder;
originalMedia.Image = historyItem.Image;
if (file is MediaImage && originalMedia is MediaImage)
{
((MediaImage)originalMedia).Caption = ((MediaImage)historyItem).Caption;
((MediaImage)originalMedia).ImageAlign = ((MediaImage)historyItem).ImageAlign;
}
originalMedia.IsTemporary = false;
originalMedia.PublishedOn = DateTime.Now;
files.Add(originalMedia);
}
}
if (cmsConfiguration.AccessControlEnabled)
{
foreach (var userAccess in files.SelectMany(x => request.UserAccessList.Select(model => new UserAccess
{
ObjectId = x.Id,
AccessLevel = model.AccessLevel,
RoleOrUser = model.RoleOrUser
})))
{
Repository.Save(userAccess);
}
}
UnitOfWork.Commit();
response.Medias = files.Select(Convert).ToList();
// Notify.
foreach (var mediaFile in files)
{
Events.MediaManagerEvents.Instance.OnMediaFileUpdated(mediaFile);
}
}
return(response);
}
private static bool ScanSubFolder(GalleryDatabase galleryDatabase, GallerySource source, MediaFolder folder,
bool reScan, ref int folderCount, ref int fileCount, int depth)
{
try
{
folderCount++;
RaiseStatusUpdatedEvent("Scanning folder #" + folderCount + " at depth " + depth + ", found " + fileCount + " files...");
GetFolders(source, folder);
GetFiles(galleryDatabase, source, folder, reScan);
if (folder.SubFolders.Count == 0 && folder.Files.Count == 0)
{
return(false);
}
RaiseMediaFolderAddedEvent(folder);
depth++;
fileCount += folder.Files.Count;
List <MediaFolder> emptyFolders = new List <MediaFolder>();
foreach (MediaFolder subFolder in folder.SubFolders)
{
if (!ScanSubFolder(galleryDatabase, source, subFolder, reScan, ref folderCount, ref fileCount, depth))
{
emptyFolders.Add(subFolder);
}
}
foreach (MediaFolder emptyFolder in emptyFolders)
{
folder.SubFolders.Remove(emptyFolder);
}
if (folder.SubFolders.Count == 0 && folder.Files.Count == 0)
{
RaiseMediaFolderRemovedEvent(folder);
return(false);
}
}
catch { }
return(true);
}
public static string GetMediaFolderItemPath(this MediaFolder mediaFolder, string itemName)
{
return(UrlUtility.Combine(mediaFolder.GetMediaDirectoryPath(), itemName));
}
private static void GetFiles(GalleryDatabase galleryDatabase, GallerySource source, MediaFolder parentFolder, bool reScan)
{
List <string> files = Directory.GetFiles(Path.Combine(source.RootedPath, parentFolder.RelativePathName)).ToList();
files.Sort();
foreach (string file in files)
{
try
{
string extension = Path.GetExtension(file).ToLower();
string fileName = Path.GetFileName(file);
string relativePath = RemoveAbsolutePath(Path.GetDirectoryName(file), source.RootedPath);
FileInfo fileInfo = new FileInfo(file);
if (MediaFile.IMAGE_FILE_EXTENSIONS.Contains(extension))
{
if (!files.Any(filePath => (Path.GetFileName(filePath) == Path.GetFileNameWithoutExtension(file))))
{
ImageFile imageFile = new ImageFile(fileName, relativePath, parentFolder, source)
{
FileSize = fileInfo.Length
};
try
{
imageFile.Size = ImageFileHelper.GetDimensions(file);
}
catch {}
int existingIndex = parentFolder.Files.FindIndex(mediaFile => mediaFile.Name == fileName);
if (existingIndex != -1)
{
parentFolder.Files.RemoveAt(existingIndex);
}
parentFolder.Files.Add(imageFile);
AddDatabaseImageEntry(galleryDatabase, imageFile, reScan);
}
}
else if (MediaFile.VIDEO_FILE_EXTENSIONS.Contains(extension))
{
VideoFile videoFile = new VideoFile(fileName, relativePath, parentFolder, source)
{
FileSize = fileInfo.Length
};
try
{
TagLib.File tagFile = TagLib.File.Create(file);
videoFile.Duration = tagFile.Properties.Duration;
videoFile.Size = new Size(tagFile.Properties.VideoWidth, tagFile.Properties.VideoHeight);
foreach (TagLib.ICodec codec in tagFile.Properties.Codecs)
{
MediaCodec mediaCodec = new MediaCodec(MediaCodec.TranslateCodecType(codec.MediaTypes), codec.Description);
if (source.Gallery.Codecs.Contains(mediaCodec))
{
mediaCodec = source.Gallery.Codecs.First(x => x.Equals(mediaCodec));
}
else
{
source.Gallery.Codecs.Add(mediaCodec);
}
videoFile.Codecs.Add(mediaCodec);
}
}
catch {}
int existingIndex = parentFolder.Files.FindIndex(mediaFile => mediaFile.Name == fileName);
if (existingIndex != -1)
{
parentFolder.Files.RemoveAt(existingIndex);
}
parentFolder.Files.Add(videoFile);
AddDatabaseImageEntry(galleryDatabase, videoFile, reScan);
}
}
catch {}
}
}
private static MediaFolder ToMediaFolder(Repository repository, string fullName, MediaFolder folderProperties)
{
return(new MediaFolder(repository, fullName)
{
DisplayName = folderProperties.DisplayName,
UserId = folderProperties.UserId,
UtcCreationDate = folderProperties.UtcCreationDate,
AllowedExtensions = folderProperties.AllowedExtensions
});
}
public IQueryable <MediaFolder> ChildFolders(MediaFolder parent)
{
return(RemoteServiceFactory.CreateService <IMediaFolderService>().ChildFolders(parent.Repository.Name, parent.FullName).AsQueryable());
}
public MediaFolder Get(MediaFolder dummy)
{
return(MediaFolders.GetFolder(dummy));
}
public void Add(MediaFolder item)
{
RemoteServiceFactory.CreateService <IMediaFolderService>().Add(item.Repository.Name, item);
}
public void Update(MediaFolder @new, MediaFolder old)
{
MediaFolders.UpdateFolder(@new);
}
public void Update(MediaFolder @new, MediaFolder old)
{
RemoteServiceFactory.CreateService <IMediaFolderService>().Update(@new.Repository.Name, @new);
}
private MediaFolder CreateMediaFolderByPath(MediaFolder folder, string pathName)
{
return(new MediaFolder(folder.Repository, pathName, folder));
}
public void Remove(MediaFolder item)
{
RemoteServiceFactory.CreateService <IMediaFolderService>().Delete(item.Repository.Name, item.FullName);
//(new MediaContentProvider()).Delete(item);
}
/// <summary>
/// Executes this command.
/// </summary>
public ConfirmUploadResponse Execute(MultiFileUploadViewModel request)
{
ConfirmUploadResponse response = new ConfirmUploadResponse {
SelectedFolderId = request.SelectedFolderId ?? Guid.Empty, ReuploadMediaId = request.ReuploadMediaId
};
if (request.UploadedFiles != null && request.UploadedFiles.Count > 0)
{
MediaFolder folder = null;
if (request.SelectedFolderId != null && request.SelectedFolderId.Value != Guid.Empty)
{
folder = Repository.AsProxy <MediaFolder>(request.SelectedFolderId.Value);
if (folder.IsDeleted)
{
response.FolderIsDeleted = true;
return(response);
}
}
UnitOfWork.BeginTransaction();
List <MediaFile> files = new List <MediaFile>();
var updateAccessControl = true;
if (request.ReuploadMediaId.HasDefaultValue())
{
UpdateMedia(request, folder, files);
}
else
{
// Re-upload performed.
var fileId = request.UploadedFiles.FirstOrDefault();
var file = Repository.FirstOrDefault <MediaFile>(fileId);
if (!fileId.HasDefaultValue())
{
var originalMedia = Repository.First <MediaFile>(request.ReuploadMediaId);
if (cmsConfiguration.Security.AccessControlEnabled && !(originalMedia is IAccessControlDisabled))
{
AccessControlService.DemandAccess(originalMedia, Context.Principal, AccessLevel.ReadWrite);
}
file.Original = originalMedia;
// Do not update access control, if re-uploading
updateAccessControl = false;
file.Title = originalMedia.Title;
file.Description = originalMedia.Description;
file.IsArchived = originalMedia.IsArchived;
file.Folder = originalMedia.Folder;
file.Image = originalMedia.Image;
if (file is MediaImage && originalMedia is MediaImage)
{
((MediaImage)file).Caption = ((MediaImage)originalMedia).Caption;
((MediaImage)file).ImageAlign = ((MediaImage)originalMedia).ImageAlign;
}
file.IsTemporary = false;
file.PublishedOn = DateTime.Now;
var temp = (MediaFile)file.Clone();
originalMedia.CopyDataTo(file);
temp.CopyDataTo(originalMedia);
files.Add(originalMedia);
}
}
if (updateAccessControl && cmsConfiguration.Security.AccessControlEnabled)
{
foreach (var file in files)
{
if (!(file is MediaImage))
{
var currentFile = file;
var fileEntity = Repository.AsQueryable <MediaFile>().Where(f => f.Id == currentFile.Id).FetchMany(f => f.AccessRules).ToList().FirstOne();
accessControlService.UpdateAccessControl(
fileEntity, request.UserAccessList != null ? request.UserAccessList.Cast <IAccessRule>().ToList() : new List <IAccessRule>());
}
}
}
UnitOfWork.Commit();
if (request.ReuploadMediaId.HasDefaultValue())
{
foreach (var file in files)
{
if (file is MediaImage)
{
file.PublicUrl += string.Format("?{0}", DateTime.Now.ToString(MediaManagerModuleDescriptor.HardLoadImageDateTimeFormat));
((MediaImage)file).PublicThumbnailUrl += string.Format("?{0}", DateTime.Now.ToString(MediaManagerModuleDescriptor.HardLoadImageDateTimeFormat));
}
}
}
response.Medias = files.Select(Convert).ToList();
// Notify.
foreach (var mediaFile in files)
{
Events.MediaManagerEvents.Instance.OnMediaFileUpdated(mediaFile);
}
}
return(response);
}
public override async Task InitializeAsync()
{
using (var api = CreateApi())
{
Piranha.App.Init(api);
// Add media folders
var folder1 = new MediaFolder
{
Name = "Images"
};
await api.Media.SaveFolderAsync(folder1);
folder1Id = folder1.Id;
// Add media
using (var stream = File.OpenRead("../../../Assets/HLD_Screenshot_01_mech_1080.png"))
{
var image1 = new Models.StreamMediaContent
{
Filename = "HLD_Screenshot_01_mech_1080.png",
Data = stream
};
await api.Media.SaveAsync(image1);
image1Id = image1.Id.Value;
// Add some additional meta data
var image = await api.Media.GetByIdAsync(image1Id);
image.Title = "Screenshot";
image.AltText = "This is a screenshot";
image.Description = "Screenshot from Hyper Light Drifter";
image.Properties["Game"] = "Hyper Light Drifter";
await api.Media.SaveAsync(image);
}
using (var stream = File.OpenRead("../../../Assets/HLD_Screenshot_01_rise_1080.png"))
{
var image2 = new Models.StreamMediaContent
{
FolderId = folder1Id,
Filename = "HLD_Screenshot_01_rise_1080.png",
Data = stream
};
await api.Media.SaveAsync(image2);
image2Id = image2.Id.Value;
}
using (var stream = File.OpenRead("../../../Assets/HLD_Screenshot_01_robot_1080.png"))
{
var image3 = new Models.StreamMediaContent
{
Filename = "HLD_Screenshot_01_robot_1080.png",
Data = stream
};
await api.Media.SaveAsync(image3);
image3Id = image3.Id.Value;
}
using (var stream = File.OpenRead("../../../Assets/HLD Screenshot 01 mech 1080.png"))
{
var image5 = new Models.StreamMediaContent
{
Filename = "HLD Screenshot 01 mech 1080.png",
Data = stream
};
await api.Media.SaveAsync(image5);
image5Id = image5.Id.Value;
}
}
}
///@Example:
/// var imageData =
/// {
/// Name : "Testing of images",
/// Description: "This is the description of the group of images",
/// Links : ["/images/sample_1.jpg","/images/sample_2.jpg","/images/sample_3.jpg","/images/sample_4.jpg",
/// "/images/sample_5.jpg","/images/sample_6.jpg","/images/sample_7.jpg","/images/sample_8.jpg"],
/// Captions : ["image 1", "image 2", "image 3", "image 4", "image 5", "image 6", "image 7", "image 8"],
/// ThumbNails: [],
/// Dims : ["100wX100h","100wX100h","100wX100h","100wX100h","100wX100h","100wX100h","100wX100h","100wX100h"]
/// };
public static string ToJsonForImageGallery(string variableName, MediaFolder folder, IList<MediaFile> allFiles, string owner)
{
var buffer = new StringBuilder();
// only include ones that are public.
var files = (from file in allFiles where file.IsPublic || string.Compare(file.CreateUser, owner) == 0 select file).ToList();
var links = files.JoinDelimited(",", (file) => "\"" + file.AbsoluteUrl + "\"");
links = links.Replace("\\", "/");
var titles = files.JoinDelimited(",", (file) => ComLib.Web.Helpers.JsonHelper.EscapeString(file.Title, true) );
var captions = files.JoinDelimited(",", (file) => ComLib.Web.Helpers.JsonHelper.EscapeString(file.Description, true));
var dims = files.JoinDelimited(",", (file) => "[" + file.Width + "," + file.Height + "]");
var thumbnails = "";
var name = folder == null ? string.Empty : folder.Name;
var desc = folder == null ? string.Empty : folder.Description;
buffer.Append("var " + variableName + " = { " + Environment.NewLine);
buffer.Append("Name : \"" + name + "\"," + Environment.NewLine);
buffer.Append("Description : \"" + desc + "\"," + Environment.NewLine);
buffer.Append("Titles: [" + titles + "]," + Environment.NewLine);
buffer.Append("Links : [" + links + "]," + Environment.NewLine);
buffer.Append("Captions : [" + captions + "]," + Environment.NewLine);
buffer.Append("ThumbNails : [" + thumbnails + "]," + Environment.NewLine);
buffer.Append("Dims : [" + dims + "]" + Environment.NewLine);
buffer.Append("}; " + Environment.NewLine);
return buffer.ToString();
}
public MediaFolderInfo CreateFolder(string path)
{
Guard.NotEmpty(path, nameof(path));
path = FolderService.NormalizePath(path, false);
ValidateFolderPath(path, "CreateFolder", nameof(path));
var dupe = _folderService.GetNodeByPath(path);
if (dupe != null)
{
throw _exceptionFactory.DuplicateFolder(path, dupe.Value);
}
var sep = "/";
var folderNames = path.Split(new[] { sep }, StringSplitOptions.RemoveEmptyEntries);
bool flag = false;
int folderId = 0;
path = string.Empty;
using (_folderService.BeginScope(true))
{
for (int i = 0; i < folderNames.Length; i++)
{
var folderName = MediaHelper.NormalizeFolderName(folderNames[i]);
path += (i > 0 ? sep : string.Empty) + folderName;
if (!flag)
{
// Find the last existing node in path trail
var currentNode = _folderService.GetNodeByPath(path)?.Value;
if (currentNode != null)
{
folderId = currentNode.Id;
}
else
{
if (i == 0)
{
throw new NotSupportedException(T("Admin.Media.Exception.TopLevelAlbum", path));
}
flag = true;
}
}
if (flag)
{
// Create missing folders in trail
using (new DbContextScope(autoCommit: true))
{
var mediaFolder = new MediaFolder {
Name = folderName, ParentId = folderId
};
_folderService.InsertFolder(mediaFolder);
folderId = mediaFolder.Id;
}
}
}
}
return(new MediaFolderInfo(_folderService.GetNodeById(folderId)));
}
