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