public ActionResult PrepareZipDownload(Entity.GalleryItem[] galleryItems, DisplayObjectType mediaSize) { try { return(AlbumController.PrepareZipDownload(galleryItems, mediaSize)); } catch (GallerySecurityException ex) { AppEventController.LogError(ex); return(new ActionResult { Title = "Cannot Download", Status = ActionResultStatus.Warning.ToString(), Message = ex.Message }); } catch (Exception ex) { AppEventController.LogError(ex); throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError) { Content = Utils.GetExStringContent(ex), ReasonPhrase = "Server Error" }); } }
/// <summary> /// Gets the name of the requested media file, without the prefix (e.g. "zThumb_", "zOpt_"). /// If a media object does not have a physical file (for example, external media objects), then return <see cref="String.Empty"/>. /// Ex: C:\Inetpub\wwwroot\galleryserverpro\mediaobjects\Summer 2005\sunsets\desert sunsets\sonorandesert.jpg /// </summary> /// <param name="mediaObject">The media object for which to return a path to the media file.</param> /// <param name="mediaSize">Size of the media file to return.</param> /// <returns>Returns the full path to the media object file.</returns> private static string GetMediaFileNameForZip(IGalleryObject mediaObject, DisplayObjectType mediaSize) { string fileName = String.Empty; IGallerySettings gallerySetting = Factory.LoadGallerySetting(mediaObject.GalleryId); switch (mediaSize) { case DisplayObjectType.Thumbnail: fileName = mediaObject.Thumbnail.FileName.Replace(gallerySetting.ThumbnailFileNamePrefix, String.Empty); break; case DisplayObjectType.Optimized: fileName = mediaObject.Optimized.FileName.Replace(gallerySetting.OptimizedFileNamePrefix, String.Empty); break; case DisplayObjectType.Original: fileName = mediaObject.Original.FileNamePhysicalPath; break; } if (String.IsNullOrEmpty(fileName)) { fileName = mediaObject.Original.FileName; } return(fileName); }
public MediaObjectHtmlBuilder(IGalleryObject mediaObject, IDisplayObject displayObject, Array browsers) { if (mediaObject == null) { throw new ArgumentNullException("mediaObject"); } if (displayObject == null) { throw new ArgumentNullException("displayObject"); } if ((browsers == null) || (browsers.Length < 1)) { throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Resources.GalleryServerPro.MediaObjectHtmlBuilder_Ctor_InvalidBrowsers_Msg)); } this._galleryObject = mediaObject; this._mediaObjectId = mediaObject.Id; this._albumId = mediaObject.Parent.Id; this._mimeType = displayObject.MimeType; this._mediaObjectPhysicalPath = displayObject.FileNamePhysicalPath; this._width = displayObject.Width; this._height = displayObject.Height; this._title = mediaObject.Title; this._browsers = browsers; this._displayType = displayObject.DisplayType; this._isPrivate = mediaObject.IsPrivate; this._galleryId = mediaObject.GalleryId; this._externalHtmlSource = displayObject.ExternalHtmlSource; }
private bool _hasBeenDisposed; // Used by Dispose() methods #endregion #region Constructors /// <summary> /// Initializes a new instance of the <see cref="DisplayObject"/> class. /// </summary> /// <param name="width">The width of this object, in pixels.</param> /// <param name="height">The height of this object, in pixels.</param> /// <param name="filename">The name of the file representing this object. Example: sonorandesert.jpg</param> /// <param name="parent">The media object to which this display object applies.</param> /// <param name="displayType">The type of the display object.</param> /// <param name="displayObjectCreator">The object responsible for generating the file this display object points to.</param> private DisplayObject(int width, int height, string filename, IGalleryObject parent, DisplayObjectType displayType, IDisplayObjectCreator displayObjectCreator) { #if DEBUG tt.Tools.StartingMethod(width, height, filename, parent, displayType, displayObjectCreator); #endif this._width = width; this._height = height; this._filename = filename; if (!String.IsNullOrEmpty(filename)) { this._mimeType = GalleryServerPro.Business.MimeType.LoadInstanceByFilePath(this._filename); } if (this._mimeType == null) { this._mimeType = new NullObjects.NullMimeType(); } this._parent = parent; this._displayType = displayType; this._displayObjectCreator = displayObjectCreator; if (this._parent is IAlbum) { this._mediaObjectId = int.MinValue; } else { this._mediaObjectId = parent.Id; } }
/// <summary> /// Gets the full file path of the requested media file, without the prefix (e.g. "zThumb_", "zOpt_"). /// This will be the value that is used to name the file entry in the ZIP file and in many cases does not /// correspond to an actual path to a file on the server. If a media object does not have a physical file /// (for example, external media objects), then return <see cref="string.Empty" />. /// Ex: C:\Inetpub\wwwroot\galleryserverpro\mediaobjects\Summer 2005\sunsets\desert sunsets\sonorandesert.jpg /// </summary> /// <param name="mediaObject">The media object for which to return a path to the media file.</param> /// <param name="mediaSize">Size of the media file to return.</param> /// <returns>Returns the full path to the media object file or an empty string.</returns> private static string GetMediaFilePathForZip(IGalleryObject mediaObject, DisplayObjectType mediaSize) { string fileExtension; switch (mediaSize) { case DisplayObjectType.Thumbnail: fileExtension = Path.GetExtension(mediaObject.Thumbnail.FileName); break; case DisplayObjectType.Optimized: fileExtension = Path.GetExtension(mediaObject.Optimized.FileName); break; case DisplayObjectType.Original: fileExtension = Path.GetExtension(mediaObject.Original.FileName); break; default: return(string.Empty); } if (string.IsNullOrEmpty(fileExtension)) { return(string.Empty); } // Combine original path with original file name and the thmb/opt/orig extension return(Path.Combine(mediaObject.FullPhysicalPathOnDisk, string.Concat(Path.GetFileNameWithoutExtension(mediaObject.Original.FileName), fileExtension))); }
/// <summary> /// Initializes a new instance of the <see cref="DisplayObject"/> class. /// </summary> /// <param name="width">The width of this object, in pixels.</param> /// <param name="height">The height of this object, in pixels.</param> /// <param name="filename">The name of the file representing this object. Example: sonorandesert.jpg</param> /// <param name="parent">The media object to which this display object applies.</param> /// <param name="displayType">The type of the display object.</param> /// <param name="displayObjectCreator">The object responsible for generating the file this display object points to.</param> private DisplayObject(int width, int height, string filename, IGalleryObject parent, DisplayObjectType displayType, IDisplayObjectCreator displayObjectCreator) { this._width = width; this._height = height; this._filename = filename; if (!String.IsNullOrEmpty(filename)) { this._mimeType = Business.MimeType.LoadMimeType(parent.GalleryId, this._filename); } if (this._mimeType == null) { this._mimeType = new NullObjects.NullMimeType(); } this._parent = parent; this._displayType = displayType; this._displayObjectCreator = displayObjectCreator; if (this._parent is IAlbum) { this._mediaObjectId = int.MinValue; } else { this._mediaObjectId = parent.Id; } }
/// <summary> /// Initializes a new instance of the <see cref="DisplayObject"/> class. /// </summary> /// <param name="parent">The parent.</param> /// <param name="displayType">The display type.</param> /// <param name="mimeType">Specifies the category to which this mime type belongs. This usually corresponds to the first portion of /// the full mime type description. (e.g. "image" if the full mime type is "image/jpeg").</param> private DisplayObject(IGalleryObject parent, DisplayObjectType displayType, MimeTypeCategory mimeType) { if (displayType != DisplayObjectType.External) { throw new BusinessException(String.Format(CultureInfo.CurrentCulture, "This overload of the DisplayObject constructor can only be called when the displayType parameter is DisplayObjectType.External. Instead, it was {0}.", displayType.ToString())); } this._width = int.MinValue; this._height = int.MinValue; this._filename = String.Empty; this._mimeType = GalleryServerPro.Business.MimeType.CreateInstance(mimeType); this._externalType = this._mimeType.TypeCategory; this._parent = parent; this._displayType = displayType; this._displayObjectCreator = new NullObjects.NullDisplayObjectCreator(); if (this._parent is IAlbum) { this._mediaObjectId = int.MinValue; } else { this._mediaObjectId = parent.Id; } }
/// <summary> /// Initializes a new instance of the <see cref="DisplayObject"/> class. /// </summary> /// <param name="width">The width of this object, in pixels.</param> /// <param name="height">The height of this object, in pixels.</param> /// <param name="filename">The name of the file representing this object. Example: sonorandesert.jpg</param> /// <param name="parent">The media object to which this display object applies.</param> /// <param name="displayType">The type of the display object.</param> /// <param name="displayObjectCreator">The object responsible for generating the file this display object points to.</param> private DisplayObject(int width, int height, string filename, IGalleryObject parent, DisplayObjectType displayType, IDisplayObjectCreator displayObjectCreator) { this._width = width; this._height = height; this._filename = filename; if (!String.IsNullOrEmpty(filename)) { this._mimeType = Factory.LoadMimeType(parent.GalleryId, this._filename); } if (this._mimeType == null) { this._mimeType = new NullObjects.NullMimeType(); } this._parent = parent; this._displayType = displayType; this._displayObjectCreator = displayObjectCreator; this._displayObjectCreator.Parent = this; if (this._parent is IAlbum) { this._mediaObjectId = int.MinValue; } else { this._mediaObjectId = parent.Id; } }
/// <summary> /// Gets the full path to the media object file. If <paramref name="mediaObject"/> /// is an <see cref="Image"/>, then return the thumbnail, compressed, or original file as specified in <paramref name="imageSize"/>. /// If a media object does not have a physical file (for example, external media objects), then return <see cref="String.Empty"/>. /// Ex: C:\Inetpub\wwwroot\galleryserverpro\mediaobjects\Summer 2005\sunsets\desert sunsets\sonorandesert.jpg /// </summary> /// <param name="mediaObject">The media object for which to return a path to the media file.</param> /// <param name="imageSize">Size of the image to return. This parameter applies only to <see cref="Image"/> media objects.</param> /// <returns>Returns the full path to the media object file.</returns> private static string GetMediaFilePath(IGalleryObject mediaObject, DisplayObjectType imageSize) { string filePath = String.Empty; if (mediaObject is Image) { switch (imageSize) { case DisplayObjectType.Thumbnail: filePath = mediaObject.Thumbnail.FileNamePhysicalPath; break; case DisplayObjectType.Optimized: filePath = mediaObject.Optimized.FileNamePhysicalPath; break; case DisplayObjectType.Original: filePath = mediaObject.Original.FileNamePhysicalPath; break; } } if (String.IsNullOrEmpty(filePath)) { filePath = mediaObject.Original.FileNamePhysicalPath; } return(filePath); }
/// <summary> /// Create a new display object instance with the specified properties. No data is retrieved from the /// data store. A lazy load is used to inflate the object when necessary /// </summary> /// <param name="parent">The media object to which this display object applies.</param> /// <param name="displayType">The type of the display object.</param> /// <param name="mimeType">Specifies the category to which this mime type belongs. This usually corresponds to the first portion of /// the full mime type description. (e.g. "image" if the full mime type is "image/jpeg").</param> /// <returns>Create a new display object instance with the specified properties.</returns> public static IDisplayObject CreateInstance(IGalleryObject parent, DisplayObjectType displayType, MimeTypeCategory mimeType) { if (displayType != DisplayObjectType.External) { throw new BusinessException(String.Format(CultureInfo.CurrentCulture, "This overload of DisplayObject.CreateInstance can only be called when the displayType parameter is DisplayObjectType.External. Instead, it was {0}.", displayType.ToString())); } return(new DisplayObject(parent, displayType, mimeType)); }
/// <summary> /// Initializes a new instance of the <see cref="MediaObjectHtmlBuilderOptions"/> class. /// </summary> /// <param name="galleryObject">The gallery object. May be null. If null, <see cref="MediaObjectHtmlBuilderOptions.GalleryObject" /> /// must be assigned before passing this instance to the <see cref="MediaObjectHtmlBuilder" /> constructor.</param> /// <param name="displayType">The display type. Optional. If not assigned or set to <see cref="DisplayObjectType.Unknown" />, /// <see cref="MediaObjectHtmlBuilderOptions.DisplayType" /> must be assigned before passing this instance to the /// <see cref="MediaObjectHtmlBuilder" /> constructor.</param> /// <param name="browsers">The browser IDs for current request.</param> /// <param name="destinationPageUrl">The URL, relative to the website root and optionally including any query string parameters, /// to the page any generated URLs should point to. Examples: "/dev/gs/gallery.aspx", /// "/dev/gs/gallery.aspx?g=admin_email&aid=2389"</param> /// <param name="hostUrl">The URI scheme, DNS host name or IP address, and port number for the current application. /// Examples: "http://www.site.com", "http://localhost", "http://127.0.0.1", "http://godzilla"</param> /// <param name="appRoot">The path, relative to the web site root, to the current web application. /// Example: "/dev/gallery".</param> /// <param name="galleryRoot">The path, relative to the web site root, to the directory containing the Gallery Server user /// controls and other resources. Example: "/dev/gallery/gs".</param> /// public MediaObjectHtmlBuilderOptions(IGalleryObject galleryObject, DisplayObjectType displayType, Array browsers, string destinationPageUrl, string hostUrl, string appRoot, string galleryRoot) { GalleryObject = galleryObject; DisplayType = displayType; Browsers = browsers; DestinationPageUrl = destinationPageUrl; HostUrl = hostUrl; AppRoot = appRoot; GalleryRoot = galleryRoot; }
/// <summary> /// Initializes a new instance of the <see cref="MediaObjectHtmlBuilder"/> class. /// </summary> /// <param name="mediaObjectId">The media object id.</param> /// <param name="albumId">The album id.</param> /// <param name="mimeType">The MIME type.</param> /// <param name="mediaObjectPhysicalPath">The media object physical path.</param> /// <param name="width">The width of the media object, in pixels.</param> /// <param name="height">The height of the media object, in pixels.</param> /// <param name="title">The title.</param> /// <param name="browsers">An <see cref="System.Array"/> of browser ids for the current browser. This /// is a list of strings that represent the various categories of browsers the current browser belongs /// to. This is typically populated by calling ToArray() on the Request.Browser.Browsers property.</param> /// <param name="displayType">The display type.</param> /// <param name="isPrivate">if set to <c>true</c> the media object is private.</param> /// <param name="galleryId">The value that uniquely identifies the current gallery.</param> public MediaObjectHtmlBuilder(int mediaObjectId, int albumId, IMimeType mimeType, string mediaObjectPhysicalPath, int width, int height, string title, Array browsers, DisplayObjectType displayType, bool isPrivate, int galleryId) { #region Validation if (mediaObjectId <= 0) { throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Resources.GalleryServerPro.MediaObjectHtmlBuilder_Ctor_InvalidMediaObjectId_Msg, mediaObjectId)); } if (albumId <= 0) { throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Resources.GalleryServerPro.MediaObjectHtmlBuilder_Ctor_InvalidAlbumId_Msg, albumId)); } if (mimeType == null) { throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Resources.GalleryServerPro.MediaObjectHtmlBuilder_Ctor_InvalidMimeType_Msg)); } if (width < 0) { throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Resources.GalleryServerPro.MediaObjectHtmlBuilder_Ctor_InvalidWidth_Msg, width)); } if (height < 0) { throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Resources.GalleryServerPro.MediaObjectHtmlBuilder_Ctor_InvalidHeight_Msg, height)); } if (title == null) { title = String.Empty; } if ((browsers == null) || (browsers.Length < 1)) { throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Resources.GalleryServerPro.MediaObjectHtmlBuilder_Ctor_InvalidBrowsers_Msg)); } #endregion this._mediaObjectId = mediaObjectId; this._albumId = albumId; this._mimeType = mimeType; this._mediaObjectPhysicalPath = mediaObjectPhysicalPath; this._width = width; this._height = height; this._title = title; this._browsers = browsers; this._displayType = displayType; this._cssClasses = new StringCollection(); this._isPrivate = isPrivate; this._galleryId = galleryId; }
public MediaObjectWebEntity GetMediaObjectHtml(int mediaObjectId, DisplayObjectType displayType) { try { return(GalleryPage.GetMediaObjectHtml(Factory.LoadMediaObjectInstance(mediaObjectId), displayType, true)); } catch (Exception ex) { AppErrorController.LogError(ex); throw; } }
/// <summary> /// Adds the media objects in the <paramref name="album"/> to the ZIP archive. Only media objects associated with a /// physical file are added (that is, external media objects are excluded). /// </summary> /// <param name="zos">The ZipOutputStream (ZIP archive) the media object file is to be added to.</param> /// <param name="album">The album to be added to the ZIP archive.</param> /// <param name="imageSize">Size of the image to add to the ZIP archive. This parameter applies only to <see cref="Image"/> /// media objects.</param> /// <param name="basePath">The full path to the directory containing the highest-level media file to be added /// to the ZIP archive. Must include trailing slash. Ex: C:\Inetpub\wwwroot\galleryserverpro\mediaobjects\Summer 2005\sunsets\</param> /// <param name="applyWatermark">Indicates whether to apply a watermark to images as they are added to the archive. /// Applies only for media objects in the <see cref="album"/> that are an <see cref="Image"/>.</param> private void AddZipEntry(ZipOutputStream zos, IAlbum album, DisplayObjectType imageSize, string basePath, bool applyWatermark) { foreach (IAlbum childAlbum in album.GetChildGalleryObjects(GalleryObjectType.Album, false, !this._isAuthenticated)) { AddZipEntry(zos, childAlbum, imageSize, basePath, applyWatermark); } foreach (IGalleryObject mediaObject in album.GetChildGalleryObjects(GalleryObjectType.MediaObject, false, !this._isAuthenticated)) { AddFileZipEntry(zos, mediaObject, imageSize, basePath, applyWatermark); } }
/// <summary> /// Return the requested display object from the specified media object. If Unknown is passed in the /// displayType parameter, and the object is an image, return the optimized object. If an optimized /// version does not exist, return the original object. If Unknown is passed in the displayType parameter, /// and the object is NOT an image, return the original object. If a thumbnail is requested, always /// return a thumbnail object. /// </summary> /// <param name="mediaObject">The media object containing the display object to return.</param> /// <param name="displayType">One of the DisplayObjectType enumeration values indicating which object to return.</param> /// <returns>Returns the requested display object from the specified media object.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="mediaObject" /> is null.</exception> public static IDisplayObject GetDisplayObject(IGalleryObject mediaObject, DisplayObjectType displayType) { if (mediaObject == null) { throw new ArgumentNullException("mediaObject"); } IDisplayObject displayObject; switch (displayType) { case DisplayObjectType.Thumbnail: { displayObject = mediaObject.Thumbnail; break; } case DisplayObjectType.Unknown: case DisplayObjectType.Optimized: { // Switch to original if it's not in the queue, there isn't an optimized file, or the opt file // is the same as the original file. bool isOptMissing = String.IsNullOrEmpty(mediaObject.Optimized.FileName); bool notInQueue = !MediaConversionQueue.Instance.IsWaitingInQueueOrProcessing(mediaObject.Id); bool isOptSameAsOriginal = (mediaObject.Optimized.FileName == mediaObject.Original.FileName); if (notInQueue && (isOptMissing || isOptSameAsOriginal)) { displayObject = mediaObject.Original; } else { displayObject = mediaObject.Optimized; } //displayObject = (mediaObject.Optimized.FileName == mediaObject.Original.FileName) ? mediaObject.Original : mediaObject.Optimized; break; } case DisplayObjectType.Original: { displayObject = mediaObject.Original; break; } default: { displayObject = (mediaObject.Optimized.FileName == mediaObject.Original.FileName) ? mediaObject.Original : mediaObject.Optimized; break; } } return(displayObject); }
private static string GetMediaObjectUrl(int galleryId, int mediaObjectId, DisplayObjectType displayType) { //string queryString = string.Format(CultureInfo.InvariantCulture, "moid={1}&aid={2}&mo={3}&mtc={4}&dt={5}&isp={6}", galleryId, mediaObjectId, albumId, Uri.EscapeDataString(mediaObjectPhysicalPath), (int)mimeType.TypeCategory, (int)displayType, isPrivate.ToString()); string queryString = string.Format(CultureInfo.InvariantCulture, "moid={0}&dt={1}&g={2}", mediaObjectId, (int)displayType, galleryId); // If necessary, encrypt, then URL encode the query string. if (AppSetting.Instance.EncryptMediaObjectUrlOnClient) { queryString = Util.UrlEncode(HelperFunctions.Encrypt(queryString)); } return(string.Concat(Util.GalleryRoot, "/handler/getmediaobject.ashx?", queryString)); }
/// <summary> /// If an optimized version is being requested, make sure a file name is specified for it. If not, switch to the /// original version. This switch will be necessary for most non-image media objects, since the client usually /// requests optimized versions for everything. /// </summary> /// <remarks>This function became necessary when switching to the ID-based request in 2.4 (rather than the /// file-based request). It was considered to change the requesting logic to ensure the correct display type /// is specified, and while that seems preferable from an architectural perspective, it was more complex to /// implement and potentially more fragile than this simple function.</remarks> private void ValidateDisplayType() { if ((_displayType == DisplayObjectType.Optimized) && (String.IsNullOrEmpty(MediaObjectFilePath))) { _displayType = DisplayObjectType.Original; _mediaObjectFilePath = null; // Comment out the exception, as it generates unnecessary errors when bots request deleted items //if (String.IsNullOrEmpty(MediaObjectFilePath)) //{ // throw new InvalidMediaObjectException(String.Format(CultureInfo.CurrentCulture, "A request was made to the Gallery Server Pro HTTP handler to serve the optimized image for media object ID {0}, but either the media object does not exist or neither the optimized nor the original has a filename stored in the database, and therefore cannot be served.", _mediaObjectId)); //} } }
/// <summary> /// Determines if the displayType parameter is one of the defined enumerations. This method is more efficient than using /// <see cref="Enum.IsDefined" />, since <see cref="Enum.IsDefined" /> uses reflection. /// </summary> /// <param name="displayType">A <see cref="DisplayObjectType" /> to test.</param> /// <returns>Returns true if displayType is one of the defined items in the enumeration; otherwise returns false.</returns> public static bool IsValidDisplayObjectType(DisplayObjectType displayType) { switch (displayType) { case DisplayObjectType.External: case DisplayObjectType.Optimized: case DisplayObjectType.Original: case DisplayObjectType.Thumbnail: case DisplayObjectType.Unknown: break; default: return false; } return true; }
/// <summary> /// Determines if the displayType parameter is one of the defined enumerations. This method is more efficient than using /// <see cref="Enum.IsDefined" />, since <see cref="Enum.IsDefined" /> uses reflection. /// </summary> /// <param name="displayType">A <see cref="DisplayObjectType" /> to test.</param> /// <returns>Returns true if displayType is one of the defined items in the enumeration; otherwise returns false.</returns> public static bool IsValidDisplayObjectType(DisplayObjectType displayType) { switch (displayType) { case DisplayObjectType.External: case DisplayObjectType.Optimized: case DisplayObjectType.Original: case DisplayObjectType.Thumbnail: case DisplayObjectType.Unknown: break; default: return(false); } return(true); }
public async Task <IActionResult> GetMediaFile(int id, DisplayObjectType dt) { // GET api/mediaitems/file/12?dt=2 // Get the optimized file for media # 12 _streamController.SetMedia(id, dt); return(File(await _streamController.GetStream(), _streamController.ContentType)); //FYI: Here is how ASP.NET Core calculates etag (https://andrewlock.net/adding-cache-control-headers-to-static-files-in-asp-net-core/) //_length = _fileInfo.Length; //DateTimeOffset last = _fileInfo.LastModified; //// Truncate to the second. //_lastModified = new DateTimeOffset(last.Year, last.Month, last.Day, last.Hour, last.Minute, last.Second, last.Offset).ToUniversalTime(); //long etagHash = _lastModified.ToFileTime() ^ _length; //_etag = new EntityTagHeaderValue('\"' + Convert.ToString(etagHash, 16) + '\"'); }
/// <summary> /// Gets the full path to the media object file, returning the thumbnail, compressed, or /// original file as specified in <paramref name="mediaSize"/>. /// If a media object does not have a physical file (for example, external media objects), then return <see cref="string.Empty" />. /// Ex: C:\Inetpub\wwwroot\galleryserverpro\mediaobjects\Summer 2005\sunsets\desert sunsets\sonorandesert.jpg /// </summary> /// <param name="mediaObject">The media object for which to return a path to the media file.</param> /// <param name="mediaSize">Size of the media file to return.</param> /// <returns>Returns the full path to the media object file or an empty string.</returns> private static string GetMediaFilePath(IGalleryObject mediaObject, DisplayObjectType mediaSize) { switch (mediaSize) { case DisplayObjectType.Thumbnail: return(mediaObject.Thumbnail.FileNamePhysicalPath); case DisplayObjectType.Optimized: return(mediaObject.Optimized.FileNamePhysicalPath); case DisplayObjectType.Original: return(mediaObject.Original.FileNamePhysicalPath); default: return(string.Empty); } }
/// <summary> /// Return the requested display object from the specified media object. If Unknown is passed in the /// displayType parameter, and the object is an image, return the optimized object. If an optimized /// version does not exist, return the original object. If Unknown is passed in the displayType parameter, /// and the object is NOT an image, return the original object. If a thumbnail is requested, always /// return a thumbnail object. /// </summary> /// <param name="mediaObject">The media object containing the display object to return.</param> /// <param name="displayType">One of the DisplayObjectType enumeration values indicating which object to return.</param> /// <returns>Returns the requested display object from the specified media object.</returns> public static IDisplayObject GetDisplayObject(IGalleryObject mediaObject, DisplayObjectType displayType) { IDisplayObject displayObject = null; if (displayType == DisplayObjectType.Thumbnail) { displayObject = mediaObject.Thumbnail; } else if (mediaObject is GalleryServerPro.Business.Image) { displayObject = GetDisplayObjectForImage(mediaObject, displayType); } else { displayObject = mediaObject.Original; } return(displayObject); }
/// <summary> /// Return the requested display object from the specified media object. If Unknown is passed in the /// displayType parameter, and the object is an image, return the optimized object. If an optimized /// version does not exist, return the original object. If Unknown is passed in the displayType parameter, /// and the object is NOT an image, return the original object. If a thumbnail is requested, always /// return a thumbnail object. /// </summary> /// <param name="mediaObject">The media object containing the display object to return.</param> /// <param name="displayType">One of the DisplayObjectType enumeration values indicating which object to return.</param> /// <returns>Returns the requested display object from the specified media object.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="mediaObject" /> is null.</exception> public static IDisplayObject GetDisplayObject(IGalleryObject mediaObject, DisplayObjectType displayType) { if (mediaObject == null) throw new ArgumentNullException("mediaObject"); IDisplayObject displayObject; switch (displayType) { case DisplayObjectType.Thumbnail: { displayObject = mediaObject.Thumbnail; break; } case DisplayObjectType.Unknown: case DisplayObjectType.Optimized: { // Switch to original if it's not in the queue, there isn't an optimized file, or the opt file // is the same as the original file. bool isOptMissing = String.IsNullOrEmpty(mediaObject.Optimized.FileName); bool notInQueue = !MediaConversionQueue.Instance.IsWaitingInQueueOrProcessing(mediaObject.Id); bool isOptSameAsOriginal = (mediaObject.Optimized.FileName == mediaObject.Original.FileName); if (notInQueue && (isOptMissing || isOptSameAsOriginal)) displayObject = mediaObject.Original; else displayObject = mediaObject.Optimized; //displayObject = (mediaObject.Optimized.FileName == mediaObject.Original.FileName) ? mediaObject.Original : mediaObject.Optimized; break; } case DisplayObjectType.Original: { displayObject = mediaObject.Original; break; } default: { displayObject = (mediaObject.Optimized.FileName == mediaObject.Original.FileName) ? mediaObject.Original : mediaObject.Optimized; break; } } return displayObject; }
/// <summary> /// Initializes a new instance of the <see cref="MediaObjectHtmlBuilder"/> class. /// </summary> /// <param name="mediaObjectId">The media object id.</param> /// <param name="albumId">The album id.</param> /// <param name="mimeType">The MIME type.</param> /// <param name="mediaObjectPhysicalPath">The media object physical path.</param> /// <param name="width">The width of the media object, in pixels.</param> /// <param name="height">The height of the media object, in pixels.</param> /// <param name="title">The title.</param> /// <param name="browsers">An <see cref="System.Array"/> of browser ids for the current browser. This /// is a list of strings that represent the various categories of browsers the current browser belongs /// to. This is typically populated by calling ToArray() on the Request.Browser.Browsers property.</param> /// <param name="displayType">The display type.</param> /// <param name="isPrivate">if set to <c>true</c> the media object is private.</param> /// <param name="galleryId">The value that uniquely identifies the current gallery.</param> public MediaObjectHtmlBuilder(int mediaObjectId, int albumId, IMimeType mimeType, string mediaObjectPhysicalPath, int width, int height, string title, Array browsers, DisplayObjectType displayType, bool isPrivate, int galleryId) { #region Validation if (mediaObjectId <= 0) throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Resources.GalleryServerPro.MediaObjectHtmlBuilder_Ctor_InvalidMediaObjectId_Msg, mediaObjectId)); if (albumId <= 0) throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Resources.GalleryServerPro.MediaObjectHtmlBuilder_Ctor_InvalidAlbumId_Msg, albumId)); if (mimeType == null) throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Resources.GalleryServerPro.MediaObjectHtmlBuilder_Ctor_InvalidMimeType_Msg)); if (width < 0) throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Resources.GalleryServerPro.MediaObjectHtmlBuilder_Ctor_InvalidWidth_Msg, width)); if (height < 0) throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Resources.GalleryServerPro.MediaObjectHtmlBuilder_Ctor_InvalidHeight_Msg, height)); if (title == null) title = String.Empty; if ((browsers == null) || (browsers.Length < 1)) throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Resources.GalleryServerPro.MediaObjectHtmlBuilder_Ctor_InvalidBrowsers_Msg)); #endregion this._mediaObjectId = mediaObjectId; this._albumId = albumId; this._mimeType = mimeType; this._mediaObjectPhysicalPath = mediaObjectPhysicalPath; this._width = width; this._height = height; this._title = title; this._browsers = browsers; this._displayType = displayType; this._cssClasses = new StringCollection(); this._isPrivate = isPrivate; this._galleryId = galleryId; }
/// <summary> /// Return the requested display object from the specified media object. If Unknown is passed in the /// displayType parameter, and the object is an image, return the optimized object. If an optimized /// version does not exist, return the original object. If Unknown is passed in the displayType parameter, /// and the object is NOT an image, return the original object. If a thumbnail is requested, always /// return a thumbnail object. /// </summary> /// <param name="mediaObject">The media object containing the display object to return.</param> /// <param name="displayType">One of the DisplayObjectType enumeration values indicating which object to return.</param> /// <returns>Returns the requested display object from the specified media object.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="mediaObject" /> is null.</exception> public static IDisplayObject GetDisplayObject(IGalleryObject mediaObject, DisplayObjectType displayType) { if (mediaObject == null) throw new ArgumentNullException("mediaObject"); IDisplayObject displayObject = null; if (displayType == DisplayObjectType.Thumbnail) { displayObject = mediaObject.Thumbnail; } else if (mediaObject is GalleryServerPro.Business.Image) { displayObject = GetDisplayObjectForImage(mediaObject, displayType); } else { displayObject = mediaObject.Original; } return displayObject; }
/// <summary> /// Initializes a new instance of the <see cref="DisplayObject"/> class. /// </summary> /// <param name="parent">The parent.</param> /// <param name="displayType">The display type.</param> /// <param name="mimeType">Specifies the category to which this mime type belongs. This usually corresponds to the first portion of /// the full mime type description. (e.g. "image" if the full mime type is "image/jpeg").</param> private DisplayObject(IGalleryObject parent, DisplayObjectType displayType, MimeTypeCategory mimeType) { if (displayType != DisplayObjectType.External) throw new BusinessException(String.Format(CultureInfo.CurrentCulture, "This overload of the DisplayObject constructor can only be called when the displayType parameter is DisplayObjectType.External. Instead, it was {0}.", displayType.ToString())); this._width = int.MinValue; this._height = int.MinValue; this._filename = String.Empty; this._mimeType = GalleryServerPro.Business.MimeType.CreateInstance(mimeType); this._externalType = this._mimeType.TypeCategory; this._parent = parent; this._displayType = displayType; this._displayObjectCreator = new NullObjects.NullDisplayObjectCreator { Parent = this }; if (this._parent is IAlbum) { this._mediaObjectId = int.MinValue; } else { this._mediaObjectId = parent.Id; } }
private DisplayObjectType GetImageSize() { DisplayObjectType displayType = DEFAULT_IMAGE_SIZE; try { displayType = (DisplayObjectType)Convert.ToInt32(this.ddlImageSize.SelectedValue, CultureInfo.InvariantCulture); } catch (FormatException) { } // Suppress any parse errors catch (OverflowException) { } // Suppress any parse errors catch (ArgumentOutOfRangeException) { } // Suppress any parse errors if (!DisplayObjectTypeEnumHelper.IsValidDisplayObjectType(displayType)) { displayType = DEFAULT_IMAGE_SIZE; } if ((displayType == DisplayObjectType.Original) && (!this.IsUserAuthorized(SecurityActions.ViewOriginalMediaObject))) { displayType = DEFAULT_IMAGE_SIZE; } return(displayType); }
/// <summary> /// Create a new display object instance with the specified properties. No data is retrieved from the /// data store. A lazy load is used to inflate the object when necessary /// </summary> /// <param name="parent">The media object to which this display object applies.</param> /// <param name="displayType">The type of the display object.</param> /// <param name="mimeType">Specifies the category to which this mime type belongs. This usually corresponds to the first portion of /// the full mime type description. (e.g. "image" if the full mime type is "image/jpeg").</param> /// <returns>Create a new display object instance with the specified properties.</returns> public static IDisplayObject CreateInstance(IGalleryObject parent, DisplayObjectType displayType, MimeTypeCategory mimeType) { if (displayType != DisplayObjectType.External) throw new BusinessException(String.Format("This overload of DisplayObject.CreateInstance can only be called when the displayType parameter is DisplayObjectType.External. Instead, it was {0}.", displayType.ToString())); return new DisplayObject(parent, displayType, mimeType); }
public MediaObjectWebEntity GetMediaObjectHtml(int mediaObjectId, DisplayObjectType displayType) { try { return GalleryPage.GetMediaObjectHtml(Factory.LoadMediaObjectInstance(mediaObjectId), displayType, true); } catch (Exception ex) { AppErrorController.LogError(ex); throw; } }
/// <overloads>Adds an object to the ZIP archive.</overloads> /// <summary> /// Adds the file associated with the <paramref name="mediaObject"/> to the ZIP archive. /// </summary> /// <param name="zos">The ZipOutputStream (ZIP archive) the media object file is to be added to.</param> /// <param name="mediaObject">The media object to be added to the ZIP archive.</param> /// <param name="mediaSize">Size of the media file to add to the ZIP archive.</param> /// <param name="basePath">The full path to the directory containing the highest-level media file to be added /// to the ZIP archive. Must include trailing slash. Ex: C:\Inetpub\wwwroot\galleryserverpro\mediaobjects\Summer 2005\sunsets\</param> /// <param name="applyWatermark">Indicates whether to apply a watermark to images as they are added to the archive. /// Applies only when <paramref name="mediaObject"/> is an <see cref="Image"/>.</param> private static void AddFileZipEntry(ZipOutputStream zos, IGalleryObject mediaObject, DisplayObjectType mediaSize, string basePath, bool applyWatermark) { // Get the path to the file we'll be adding to the zip file. string filePath = GetMediaFilePath(mediaObject, mediaSize); // Get the name we want to use for the file we are adding to the zip file. string fileNameForZip = GetMediaFileNameForZip(mediaObject, mediaSize); if ((!String.IsNullOrEmpty(filePath)) && (!String.IsNullOrEmpty(fileNameForZip))) { AddFileZipEntry(zos, filePath, fileNameForZip, basePath, (mediaObject is Image), applyWatermark, mediaObject.GalleryId); } }
/// <summary> /// Create a new display object instance with the specified properties. No data is retrieved from the /// data store. A lazy load is used to inflate the object when necessary /// </summary> /// <param name="parent">The media object to which this display object applies. This will typically be /// an Album object.</param> /// <param name="sourceMediaObjectId">The ID of the media object to use as the source for setting this /// object's properties.</param> /// <param name="displayType">The display object type of the source media object to use to set this object's /// properties. For example, if displayType=Thumbnail, then use the properties of the source media /// object's thumbnail object to assign to this display object's properties.</param> /// <returns>Create a new display object instance with the specified properties.</returns> /// <remarks>This overload of CreateInstance() is typically used when instantiating albums.</remarks> public static IDisplayObject CreateInstance(IGalleryObject parent, int sourceMediaObjectId, DisplayObjectType displayType) { IDisplayObject newDisObject = CreateInstance(parent, string.Empty, int.MinValue, int.MinValue, displayType, new NullObjects.NullDisplayObjectCreator()); newDisObject.MediaObjectId = sourceMediaObjectId; return(newDisObject); }
public MediaObjectWebEntity GetMediaObjectHtml(int mediaObjectId, DisplayObjectType displayType) { return GalleryPage.GetMediaObjectHtml(Factory.LoadMediaObjectInstance(mediaObjectId), displayType, true); }
/// <summary> /// Creates a ZIP archive, returned as a <see cref="ZipOutputStream"/>, containing the specified <paramref name="albumIds">albums /// </paramref> and <paramref name="mediaObjectIds">media objects</paramref>. Only media objects associated with a /// physical file are included (in other words, external media objects are excluded). The archive is created in memory /// and is not stored on disk. /// </summary> /// <param name="parentAlbumId">The ID of the album containing the <paramref name="albumIds"/> and <paramref name="mediaObjectIds"/>. /// When <paramref name="albumIds"/> or <paramref name="mediaObjectIds"/> belong to more than one album, such as when a user is /// downloading multiple albums contained within a virtual album, specify <see cref="Int32.MinValue"/>.</param> /// <param name="albumIds">The ID's of the albums to add to the ZIP archive. It's child albums and media objects are recursively /// added. Each album must exist within the parent album, but does not have to be an immediate child (it can be a grandchild, etc).</param> /// <param name="mediaObjectIds">The ID's of the media objects to add to the archive. Each media object must exist within the parent album, /// but does not have to be an immediate child (it can be a grandchild, etc).</param> /// <param name="imageSize">Size of the image to add to the ZIP archive. This parameter applies only to <see cref="Image"/> /// media objects.</param> /// <returns>Returns a <see cref="MemoryStream"/> of a ZIP archive that contains the specified albums and media objects.</returns> public Stream CreateZipStream(int parentAlbumId, List<int> albumIds, List<int> mediaObjectIds, DisplayObjectType imageSize) { string currentItemBasePath; string basePath = null; bool applyWatermark = true; // Will be overwritten later try { // Get the path to the parent album. This will fail when parentAlbumId does not refer to a valid album. basePath = String.Concat(Factory.LoadAlbumInstance(parentAlbumId, false).FullPhysicalPathOnDisk, Path.DirectorySeparatorChar); applyWatermark = this.DetermineIfWatermarkIsToBeApplied(parentAlbumId); } catch (ErrorHandler.CustomExceptions.InvalidAlbumException) { /* Ignore for now; we'll check basePath later */ } MemoryStream ms = new MemoryStream(); ZipOutputStream zos = new ZipOutputStream(ms); zos.SetLevel(ZIP_COMPRESSION_LEVEL); if (albumIds != null) { foreach (int albumId in albumIds) { IAlbum album = Factory.LoadAlbumInstance(albumId, true); if (String.IsNullOrEmpty(basePath)) { // The base path wasn't assigned because albumParentId does not refer to a valid album. Instead we will use the path // of the current album's parent. currentItemBasePath = String.Concat(album.Parent.FullPhysicalPathOnDisk, Path.DirectorySeparatorChar); applyWatermark = DetermineIfWatermarkIsToBeApplied(albumId); } else { currentItemBasePath = basePath; } AddZipEntry(zos, album, imageSize, currentItemBasePath, applyWatermark); } } if (mediaObjectIds != null) { foreach (int mediaObjectId in mediaObjectIds) { IGalleryObject mediaObject = Factory.LoadMediaObjectInstance(mediaObjectId); if (String.IsNullOrEmpty(basePath)) { // The base path wasn't assigned because albumParentId does not refer to a valid album. Instead we will use the path // of the current media object's album. currentItemBasePath = String.Concat(mediaObject.Parent.FullPhysicalPathOnDisk, Path.DirectorySeparatorChar); applyWatermark = DetermineIfWatermarkIsToBeApplied(mediaObject.Parent.Id); } else { currentItemBasePath = basePath; } AddFileZipEntry(zos, mediaObject, imageSize, currentItemBasePath, applyWatermark); } } zos.Finish(); return ms; }
/// <summary> /// Gets the name of the requested media file, without the prefix (e.g. "zThumb_", "zOpt_"). /// If a media object does not have a physical file (for example, external media objects), then return <see cref="String.Empty"/>. /// Ex: C:\Inetpub\wwwroot\galleryserverpro\mediaobjects\Summer 2005\sunsets\desert sunsets\sonorandesert.jpg /// </summary> /// <param name="mediaObject">The media object for which to return a path to the media file.</param> /// <param name="mediaSize">Size of the media file to return.</param> /// <returns>Returns the full path to the media object file.</returns> private static string GetMediaFileNameForZip(IGalleryObject mediaObject, DisplayObjectType mediaSize) { string fileName = String.Empty; IGallerySettings gallerySetting = Factory.LoadGallerySetting(mediaObject.GalleryId); switch (mediaSize) { case DisplayObjectType.Thumbnail: fileName = mediaObject.Thumbnail.FileName.Replace(gallerySetting.ThumbnailFileNamePrefix, String.Empty); break; case DisplayObjectType.Optimized: fileName = mediaObject.Optimized.FileName.Replace(gallerySetting.OptimizedFileNamePrefix, String.Empty); break; case DisplayObjectType.Original: fileName = mediaObject.Original.FileNamePhysicalPath; break; } if (String.IsNullOrEmpty(fileName)) { fileName = mediaObject.Original.FileName; } return fileName; }
/// <summary> /// Get the URL to the thumbnail, optimized, or original media object. Example: /// /dev/gs/handler/getmediaobject.ashx?moid=34&dt=1&g=1 /// The URL can be used to assign to the src attribute of an image tag (<img src='...' />). /// Not tested: It should be possible to pass an album and request the url to its thumbnail image. /// </summary> /// <param name="galleryObject">The gallery object for which an URL to the specified image is to be generated.</param> /// <param name="displayType">A DisplayObjectType enumeration value indicating the version of the /// object for which the URL should be generated. Possible values: Thumbnail, Optimized, Original. /// An exception is thrown if any other enumeration is passed.</param> /// <returns>Returns the URL to the thumbnail, optimized, or original version of the requested media object.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="galleryObject" /> is null.</exception> public static string GetMediaObjectUrl(IGalleryObject galleryObject, DisplayObjectType displayType) { if (galleryObject == null) throw new ArgumentNullException("galleryObject"); return MediaObjectHtmlBuilder.GenerateUrl(galleryObject.GalleryId, galleryObject.Id, displayType); }
/// <summary> /// Initializes a new instance of the <see cref="MediaObjectHtmlBuilderOptions"/> class. /// </summary> /// <param name="galleryObject">The gallery object. May be null. If null, <see cref="MediaObjectHtmlBuilderOptions.GalleryObject" /> /// must be assigned before passing this instance to the <see cref="MediaObjectHtmlBuilder" /> constructor.</param> /// <param name="displayType">The display type. Optional. If not assigned or set to <see cref="DisplayObjectType.Unknown" />, /// <see cref="MediaObjectHtmlBuilderOptions.DisplayType" /> must be assigned before passing this instance to the /// <see cref="MediaObjectHtmlBuilder" /> constructor.</param> /// <param name="browsers">The browser IDs for current request.</param> /// <param name="destinationPageUrl">The URL, relative to the website root and optionally including any query string parameters, /// to the page any generated URLs should point to. Examples: "/dev/gs/gallery.aspx", /// "/dev/gs/gallery.aspx?g=admin_email&aid=2389"</param> /// <param name="isAuthenticated">If set to <c>true</c> the current user is authenticated.</param> /// <param name="hostUrl">The URI scheme, DNS host name or IP address, and port number for the current application. /// Examples: "http://www.site.com", "http://localhost", "http://127.0.0.1", "http://godzilla"</param> /// <param name="appRoot">The path, relative to the web site root, to the current web application. /// Example: "/dev/gallery".</param> /// <param name="galleryRoot">The path, relative to the web site root, to the directory containing the Gallery Server Pro user /// controls and other resources. Example: "/dev/gallery/gs".</param> public MediaObjectHtmlBuilderOptions(IGalleryObject galleryObject, DisplayObjectType displayType, Array browsers, string destinationPageUrl, bool isAuthenticated, string hostUrl, string appRoot, string galleryRoot) { GalleryObject = galleryObject; DisplayType = displayType; Browsers = browsers; DestinationPageUrl = destinationPageUrl; IsAuthenticated = isAuthenticated; HostUrl = hostUrl; AppRoot = appRoot; GalleryRoot = galleryRoot; }
private static string GetMediaObjectUrl(int galleryId, int mediaObjectId, DisplayObjectType displayType) { //string queryString = String.Format(CultureInfo.InvariantCulture, "moid={1}&aid={2}&mo={3}&mtc={4}&dt={5}&isp={6}", galleryId, mediaObjectId, albumId, Uri.EscapeDataString(mediaObjectPhysicalPath), (int)mimeType.TypeCategory, (int)displayType, isPrivate.ToString()); string queryString = String.Format(CultureInfo.InvariantCulture, "moid={0}&dt={1}&g={2}", mediaObjectId, (int)displayType, galleryId); // If necessary, encrypt, then URL encode the query string. if (AppSetting.Instance.EncryptMediaObjectUrlOnClient) queryString = Utils.UrlEncode(HelperFunctions.Encrypt(queryString)); return string.Concat(Utils.GalleryRoot, "/handler/getmediaobject.ashx?", queryString); }
/// <summary> /// Generate the URL to the media object. For example, for images this url can be assigned to the src attribute of an img tag. /// (ex: /galleryserverpro/handler/getmediaobject.ashx?moid=34&dt=1&g=1) /// The query string parameter will be encrypted if that option is enabled. /// </summary> /// <param name="galleryId">The gallery ID.</param> /// <param name="mediaObjectId">The unique identifier for the media object.</param> /// <param name="displayType">The type of the display object.</param> /// <returns>Gets the URL to the media object.</returns> public static string GenerateUrl(int galleryId, int mediaObjectId, DisplayObjectType displayType) { return GetMediaObjectUrl(galleryId, mediaObjectId, displayType); }
public ActionResult RotateFlip(GalleryItem[] galleryItems, MediaAssetRotateFlip rotateFlip, DisplayObjectType viewSize) { try { return(GalleryObjectController.RotateFlip(galleryItems, rotateFlip, viewSize)); } catch (Exception ex) { AppEventController.LogError(ex); throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError) { Content = Utils.GetExStringContent(ex), ReasonPhrase = "Server Error" }); } }
/// <summary> /// Extract information from the query string and assign to our class level variables. Return false if /// something goes wrong and the variables cannot be set. This will happen when the query string is in /// an unexpected format. /// </summary> /// <param name="queryString">The query string for the current request. Can be populated with /// HttpContext.Request.Url.Query. Must start with a question mark (?).</param> /// <returns>Returns true if all relevant variables were assigned from the query string; returns false /// if there was a problem.</returns> private bool ExtractQueryStringParms(string queryString) { if (String.IsNullOrEmpty(queryString)) { return(false); } queryString = queryString.Remove(0, 1); // Strip off the ? bool filepathIsEncrypted = AppSetting.Instance.EncryptMediaObjectUrlOnClient; if (filepathIsEncrypted) { // Decode, then decrypt the query string. Note that we must replace spaces with a '+'. This is required when the the URL is // used in javascript to create the Silverlight media player. Apparently, Silverlight or the media player javascript decodes // the query string when it requests the URL, so that means any instances of '%2b' are decoded into '+' before it gets here. // Ideally, we wouldn't even call UrlDecode in this case, but we don't have a way of knowing that it has already been decoded. // So we decode anyway, which doesn't cause any harm *except* it converts '+' to a space, so we need to convert them back. queryString = HelperFunctions.Decrypt(HttpUtility.UrlDecode(queryString).Replace(" ", "+")); } //moid={0}&dt={1}g={2} foreach (string nameValuePair in queryString.Split(new[] { '&' })) { string[] nameOrValue = nameValuePair.Split(new[] { '=' }); switch (nameOrValue[0]) { case "g": { int gid; if (Int32.TryParse(nameOrValue[1], out gid)) { _galleryIdInQueryString = gid; } else { return(false); } break; } case "moid": { int moid; if (Int32.TryParse(nameOrValue[1], out moid)) { _mediaObjectId = moid; } else { return(false); } break; } case "dt": { int dtInt; if (Int32.TryParse(nameOrValue[1], out dtInt)) { if (DisplayObjectTypeEnumHelper.IsValidDisplayObjectType((DisplayObjectType)dtInt)) { _displayType = (DisplayObjectType)dtInt; break; } else { return(false); } } else { return(false); } } case "sa": { _sendAsAttachment = ((nameOrValue[1].Equals("1", StringComparison.Ordinal)) || (nameOrValue[1].Equals("TRUE", StringComparison.OrdinalIgnoreCase))); break; } default: return(false); // Unexpected query string parm. Return false so execution is aborted. } } ValidateDisplayType(); return(true); }
/// <summary> /// Create a new display object instance with the specified properties. No data is retrieved from the /// data store. A lazy load is used to inflate the object when necessary /// </summary> /// <param name="parent">The media object to which this display object applies.</param> /// <param name="fileName">The name of the file representing this object. Example: sonorandesert.jpg</param> /// <param name="width">The width of this object, in pixels.</param> /// <param name="height">The height of this object, in pixels.</param> /// <param name="displayType">The type of the display object.</param> /// <param name="displayObjectCreator">The object responsible for generating the file this display object points to.</param> /// <returns>Create a new display object instance with the specified properties.</returns> public static IDisplayObject CreateInstance(IGalleryObject parent, string fileName, int width, int height, DisplayObjectType displayType, IDisplayObjectCreator displayObjectCreator) { return new DisplayObject(width, height, fileName, parent, displayType, displayObjectCreator); }
/// <summary> /// Get information for the specified media object, including its previous and next media object. /// </summary> /// <param name="mediaObject">The media object.</param> /// <param name="displayType">The type of display object to receive (thumbnail, optimized, original).</param> /// <param name="isCallBack">Indicates whether the current invocation is caused by an AJAX callback.</param> /// <returns> /// Returns an instance of MediaObjectWebEntity containing information for the specified media object, /// including its previous and next media object. /// </returns> internal static MediaObjectWebEntity GetMediaObjectHtml(IGalleryObject mediaObject, DisplayObjectType displayType, bool isCallBack) { // Get the information about the specified media object, its previous one, next one, and the next one in a slide show. Array browsers = Utils.GetBrowserIdsForCurrentRequest(); if ((displayType == DisplayObjectType.Original) && (!Utils.IsUserAuthorized(SecurityActions.ViewOriginalImage, RoleController.GetGalleryServerRolesForUser(), mediaObject.Parent.Id, mediaObject.GalleryId, ((IAlbum)mediaObject.Parent).IsPrivate))) { displayType = DisplayObjectType.Optimized; } bool excludePrivateObjects = !Utils.IsAuthenticated; MediaObjectWebEntity mo = new MediaObjectWebEntity(); #region Step 1: Process current media object if (mediaObject.Id > 0) { // This section is enclosed in the above if statement to force all declared variables within it to be local so they are // not accidentally re-used in steps 2 or 3. In reality, mediaObject.Id should ALWAYS be greater than 0. IDisplayObject displayObject = GalleryObjectController.GetDisplayObject(mediaObject, displayType); string htmlOutput = String.Empty; string scriptOutput = String.Empty; if (!String.IsNullOrEmpty(mediaObject.Original.ExternalHtmlSource)) { IMediaObjectHtmlBuilder moBuilder = new MediaObjectHtmlBuilder(mediaObject.Original.ExternalHtmlSource, mediaObject.GalleryId); htmlOutput = moBuilder.GenerateHtml(); } else if ((displayObject.Width > 0) && (displayObject.Height > 0)) { IMediaObjectHtmlBuilder moBuilder = new MediaObjectHtmlBuilder(mediaObject.Id, mediaObject.Parent.Id, displayObject.MimeType, displayObject.FileNamePhysicalPath, displayObject.Width, displayObject.Height, mediaObject.Title, browsers, displayType, mediaObject.IsPrivate, mediaObject.GalleryId); htmlOutput = moBuilder.GenerateHtml(); scriptOutput = moBuilder.GenerateScript(); } if (String.IsNullOrEmpty(htmlOutput)) { // We'll get here when the user is trying to view a media object that cannot be displayed in the browser or the // config file does not have a definition for this MIME type. Default to a standard message noting that the user // can download the object via one of the toolbar commands. htmlOutput = String.Format(CultureInfo.CurrentCulture, "<p class='gsp_msgfriendly'>{0}</p>", Resources.GalleryServerPro.UC_MediaObjectView_Browser_Cannot_Display_Media_Object_Text); } // Get the siblings of this media object and the index that specifies its position within its siblings. //TODO: This technique for identifying the index is very expensive when there are a lot of objects in the album. IGalleryObjectCollection siblings = ((IAlbum)mediaObject.Parent).GetChildGalleryObjects(GalleryObjectType.MediaObject, true, excludePrivateObjects); int mediaObjectIndex = siblings.IndexOf(mediaObject); // Build up the entity object we'll be sending to the client. bool moIsImage = (mediaObject is GalleryServerPro.Business.Image); bool moIsExternalObject = (mediaObject is GalleryServerPro.Business.ExternalMediaObject); mo.Id = mediaObject.Id; mo.Index = mediaObjectIndex; mo.NumObjectsInAlbum = siblings.Count; mo.Title = mediaObject.Title; mo.PrevId = GetPreviousMediaObjectId(mediaObjectIndex, siblings); mo.NextId = GetNextMediaObjectId(mediaObjectIndex, siblings); mo.NextSSId = GetNextMediaObjectIdForSlideshow(mediaObjectIndex, siblings); mo.HtmlOutput = htmlOutput; mo.ScriptOutput = scriptOutput; mo.Width = displayObject.Width; mo.Height = displayObject.Height; mo.HiResAvailable = (moIsImage && (!String.IsNullOrEmpty(mediaObject.Optimized.FileName)) && (mediaObject.Original.FileName != mediaObject.Optimized.FileName)); mo.IsDownloadable = !moIsExternalObject; } #endregion #region Step 2: Process previous media object if (mo.PrevId > 0) { IGalleryObject prevMO = Factory.LoadMediaObjectInstance(mo.PrevId); IDisplayObject displayObject = GalleryObjectController.GetDisplayObject(prevMO, displayType); string htmlOutput = String.Empty; string scriptOutput = String.Empty; if (!String.IsNullOrEmpty(prevMO.Original.ExternalHtmlSource)) { IMediaObjectHtmlBuilder moBuilder = new MediaObjectHtmlBuilder(prevMO.Original.ExternalHtmlSource, prevMO.GalleryId); htmlOutput = moBuilder.GenerateHtml(); } else if ((displayObject.Width > 0) && (displayObject.Height > 0)) { IMediaObjectHtmlBuilder moBuilder = new MediaObjectHtmlBuilder(prevMO.Id, prevMO.Parent.Id, displayObject.MimeType, displayObject.FileNamePhysicalPath, displayObject.Width, displayObject.Height, prevMO.Title, browsers, displayType, prevMO.IsPrivate, prevMO.GalleryId); htmlOutput = moBuilder.GenerateHtml(); scriptOutput = moBuilder.GenerateScript(); } if (String.IsNullOrEmpty(htmlOutput)) { // We'll get here when the user is trying to view a media object that cannot be displayed in the browser or the // config file does not have a definition for this MIME type. Default to a standard message noting that the user // can download the object via one of the toolbar commands. htmlOutput = String.Format(CultureInfo.CurrentCulture, "<p class='gsp_msgfriendly'>{0}</p>", Resources.GalleryServerPro.UC_MediaObjectView_Browser_Cannot_Display_Media_Object_Text); } // Build up the entity object we'll be sending to the client. bool prevMoIsImage = (prevMO is GalleryServerPro.Business.Image); bool prevMoIsExternalObject = (prevMO is GalleryServerPro.Business.ExternalMediaObject); mo.PrevTitle = prevMO.Title; mo.PrevHtmlOutput = htmlOutput; mo.PrevScriptOutput = scriptOutput; mo.PrevWidth = displayObject.Width; mo.PrevHeight = displayObject.Height; mo.PrevHiResAvailable = (prevMoIsImage && (!String.IsNullOrEmpty(prevMO.Optimized.FileName)) && (prevMO.Original.FileName != prevMO.Optimized.FileName)); mo.PrevIsDownloadable = !prevMoIsExternalObject; } #endregion #region Step 3: Process next media object if (mo.NextId > 0) { IGalleryObject nextMO = Factory.LoadMediaObjectInstance(mo.NextId); IDisplayObject displayObject = GalleryObjectController.GetDisplayObject(nextMO, displayType); string htmlOutput = String.Empty; string scriptOutput = String.Empty; if (!String.IsNullOrEmpty(nextMO.Original.ExternalHtmlSource)) { IMediaObjectHtmlBuilder moBuilder = new MediaObjectHtmlBuilder(nextMO.Original.ExternalHtmlSource, nextMO.GalleryId); htmlOutput = moBuilder.GenerateHtml(); } else if ((displayObject.Width > 0) && (displayObject.Height > 0)) { IMediaObjectHtmlBuilder moBuilder = new MediaObjectHtmlBuilder(nextMO.Id, nextMO.Parent.Id, displayObject.MimeType, displayObject.FileNamePhysicalPath, displayObject.Width, displayObject.Height, nextMO.Title, browsers, displayType, nextMO.IsPrivate, nextMO.GalleryId); htmlOutput = moBuilder.GenerateHtml(); scriptOutput = moBuilder.GenerateScript(); } if (String.IsNullOrEmpty(htmlOutput)) { // We'll get here when the user is trying to view a media object that cannot be displayed in the browser or the // config file does not have a definition for this MIME type. Default to a standard message noting that the user // can download the object via one of the toolbar commands. htmlOutput = String.Format(CultureInfo.CurrentCulture, "<p class='gsp_msgfriendly'>{0}</p>", Resources.GalleryServerPro.UC_MediaObjectView_Browser_Cannot_Display_Media_Object_Text); } // Build up the entity object we'll be sending to the client. bool nextMoIsImage = (nextMO is GalleryServerPro.Business.Image); bool nextMoIsExternalObject = (nextMO is GalleryServerPro.Business.ExternalMediaObject); mo.NextTitle = nextMO.Title; mo.NextHtmlOutput = htmlOutput; mo.NextScriptOutput = scriptOutput; mo.NextWidth = displayObject.Width; mo.NextHeight = displayObject.Height; mo.NextHiResAvailable = (nextMoIsImage && (!String.IsNullOrEmpty(nextMO.Optimized.FileName)) && (nextMO.Original.FileName != nextMO.Optimized.FileName)); mo.NextIsDownloadable = !nextMoIsExternalObject; } #endregion #region Step 4: Process next slide show media object if (mo.NextSSId > 0) { IGalleryObject nextSSMO = Factory.LoadMediaObjectInstance(mo.NextSSId); IDisplayObject displayObject = GalleryObjectController.GetDisplayObject(nextSSMO, displayType); string htmlOutput = String.Empty; string scriptOutput = String.Empty; string url = String.Empty; if (!String.IsNullOrEmpty(nextSSMO.Original.ExternalHtmlSource)) { IMediaObjectHtmlBuilder moBuilder = new MediaObjectHtmlBuilder(nextSSMO.Original.ExternalHtmlSource, nextSSMO.GalleryId); htmlOutput = moBuilder.GenerateHtml(); } else if ((displayObject.Width > 0) && (displayObject.Height > 0)) { IMediaObjectHtmlBuilder moBuilder = new MediaObjectHtmlBuilder(nextSSMO.Id, nextSSMO.Parent.Id, displayObject.MimeType, displayObject.FileNamePhysicalPath, displayObject.Width, displayObject.Height, nextSSMO.Title, browsers, displayType, nextSSMO.IsPrivate, nextSSMO.GalleryId); htmlOutput = moBuilder.GenerateHtml(); scriptOutput = moBuilder.GenerateScript(); url = moBuilder.GenerateUrl(); } if (String.IsNullOrEmpty(htmlOutput)) { // We'll get here when the user is trying to view a media object that cannot be displayed in the browser or the // config file does not have a definition for this MIME type. Default to a standard message noting that the user // can download the object via one of the toolbar commands. htmlOutput = String.Format(CultureInfo.CurrentCulture, "<p class='gsp_msgfriendly'>{0}</p>", Resources.GalleryServerPro.UC_MediaObjectView_Browser_Cannot_Display_Media_Object_Text); } // Get the siblings of this media object and the index that specifies its position within its siblings. //TODO: This technique for identifying the index is very expensive when there are a lot of objects in the album. IGalleryObjectCollection siblings = ((IAlbum)nextSSMO.Parent).GetChildGalleryObjects(GalleryObjectType.MediaObject, true, excludePrivateObjects); int mediaObjectIndex = siblings.IndexOf(nextSSMO); // Build up the entity object we'll be sending to the client. bool nextSSMoIsImage = (nextSSMO is GalleryServerPro.Business.Image); mo.NextSSIndex = mediaObjectIndex; mo.NextSSTitle = nextSSMO.Title; mo.NextSSUrl = url; mo.NextSSHtmlOutput = htmlOutput; mo.NextSSScriptOutput = scriptOutput; mo.NextSSWidth = displayObject.Width; mo.NextSSHeight = displayObject.Height; mo.NextSSHiResAvailable = (nextSSMoIsImage && (!String.IsNullOrEmpty(nextSSMO.Optimized.FileName)) && (nextSSMO.Original.FileName != nextSSMO.Optimized.FileName)); mo.NextSSIsDownloadable = true; // Slide show objects are always locally stored images and are therefore always downloadable } #endregion #region Step 5: Update Previous Uri variable if (HttpContext.Current.Session != null) { Uri backURL = Utils.PreviousUri; if (isCallBack && (backURL != null)) { // We are in a callback. Even though the page hasn't changed, the user is probably viewing a different media object, // so update the moid query string parameter so that the referring url points to the current media object. backURL = UpdateUriQueryString(backURL, "moid", mediaObject.Id.ToString(CultureInfo.InvariantCulture)); } else { backURL = Utils.GetCurrentPageUri(); } Utils.PreviousUri = backURL; } #endregion return mo; }
/// <summary> /// Create a new display object instance with the specified properties. No data is retrieved from the /// data store. A lazy load is used to inflate the object when necessary /// </summary> /// <param name="parent">The media object to which this display object applies. This will typically be /// an Album object.</param> /// <param name="sourceMediaObjectId">The ID of the media object to use as the source for setting this /// object's properties.</param> /// <param name="displayType">The display object type of the source media object to use to set this object's /// properties. For example, if displayType=Thumbnail, then use the properties of the source media /// object's thumbnail object to assign to this display object's properties.</param> /// <returns>Create a new display object instance with the specified properties.</returns> /// <remarks>This overload of CreateInstance() is typically used when instantiating albums.</remarks> public static IDisplayObject CreateInstance(IGalleryObject parent, int sourceMediaObjectId, DisplayObjectType displayType) { IDisplayObject newDisObject = CreateInstance(parent, string.Empty, int.MinValue, int.MinValue, displayType, new NullObjects.NullDisplayObjectCreator()); newDisObject.MediaObjectId = sourceMediaObjectId; return newDisObject; }
/// <summary> /// Gets an instance of <see cref="MediaObjectHtmlBuilderOptions" /> that can be supplied to the /// <see cref="MediaObjectHtmlBuilder" /> constructor. This method requires access to <see cref="HttpContext.Current" />. /// </summary> /// <param name="galleryObject">The gallery object. May be null. If null, <see cref="MediaObjectHtmlBuilderOptions.GalleryObject" /> /// must be assigned before passing this instance to the <see cref="MediaObjectHtmlBuilder" /> constructor.</param> /// <param name="displayType">The display type. Optional. If not assigned or set to <see cref="DisplayObjectType.Unknown" />, /// <see cref="MediaObjectHtmlBuilderOptions.DisplayType" /> must be assigned before passing this instance to the /// <see cref="MediaObjectHtmlBuilder" /> constructor.</param> /// <returns>An instance of <see cref="MediaObjectHtmlBuilderOptions" />.</returns> public static MediaObjectHtmlBuilderOptions GetMediaObjectHtmlBuilderOptions(IGalleryObject galleryObject, DisplayObjectType displayType = DisplayObjectType.Unknown) { return new MediaObjectHtmlBuilderOptions(galleryObject, displayType, Utils.GetBrowserIdsForCurrentRequest(), Utils.GetCurrentPageUrl(), Utils.IsAuthenticated, Utils.GetHostUrl(), Utils.AppRoot, Utils.GalleryRoot); }
/// <summary> /// Gets the full path to the media object file. If <paramref name="mediaObject"/> /// is an <see cref="Image"/>, then return the thumbnail, compressed, or original file as specified in <paramref name="imageSize"/>. /// If a media object does not have a physical file (for example, external media objects), then return <see cref="String.Empty"/>. /// Ex: C:\Inetpub\wwwroot\galleryserverpro\mediaobjects\Summer 2005\sunsets\desert sunsets\sonorandesert.jpg /// </summary> /// <param name="mediaObject">The media object for which to return a path to the media file.</param> /// <param name="imageSize">Size of the image to return. This parameter applies only to <see cref="Image"/> media objects.</param> /// <returns>Returns the full path to the media object file.</returns> private static string GetMediaFilePath(IGalleryObject mediaObject, DisplayObjectType imageSize) { string filePath = String.Empty; if (mediaObject is Image) { switch (imageSize) { case DisplayObjectType.Thumbnail: filePath = mediaObject.Thumbnail.FileNamePhysicalPath; break; case DisplayObjectType.Optimized: filePath = mediaObject.Optimized.FileNamePhysicalPath; break; case DisplayObjectType.Original: filePath = mediaObject.Original.FileNamePhysicalPath; break; } } if (String.IsNullOrEmpty(filePath)) { filePath = mediaObject.Original.FileNamePhysicalPath; } return filePath; }
/// <summary> /// Creates a ZIP archive, returned as a <see cref="ZipOutputStream"/>, containing the specified <paramref name="albumIds">albums /// </paramref> and <paramref name="mediaObjectIds">media objects</paramref>. Only media objects associated with a /// physical file are included (in other words, external media objects are excluded). The archive is created in memory /// and is not stored on disk. /// </summary> /// <param name="parentAlbumId">The ID of the album containing the <paramref name="albumIds"/> and <paramref name="mediaObjectIds"/>. /// When <paramref name="albumIds"/> or <paramref name="mediaObjectIds"/> belong to more than one album, such as when a user is /// downloading multiple albums contained within a virtual album, specify <see cref="Int32.MinValue"/>.</param> /// <param name="albumIds">The ID's of the albums to add to the ZIP archive. It's child albums and media objects are recursively /// added. Each album must exist within the parent album, but does not have to be an immediate child (it can be a grandchild, etc).</param> /// <param name="mediaObjectIds">The ID's of the media objects to add to the archive. Each media object must exist within the parent album, /// but does not have to be an immediate child (it can be a grandchild, etc).</param> /// <param name="imageSize">Size of the image to add to the ZIP archive. This parameter applies only to <see cref="Image"/> /// media objects.</param> /// <returns>Returns a <see cref="MemoryStream"/> of a ZIP archive that contains the specified albums and media objects.</returns> public Stream CreateZipStream(int parentAlbumId, List <int> albumIds, List <int> mediaObjectIds, DisplayObjectType imageSize) { string currentItemBasePath; string basePath = null; bool applyWatermark = true; // Will be overwritten later try { // Get the path to the parent album. This will fail when parentAlbumId does not refer to a valid album. IAlbum album = Factory.LoadAlbumInstance(parentAlbumId, false); basePath = String.Concat(album.FullPhysicalPathOnDisk, Path.DirectorySeparatorChar); applyWatermark = this.DetermineIfWatermarkIsToBeApplied(album); } catch (ErrorHandler.CustomExceptions.InvalidAlbumException) { /* Ignore for now; we'll check basePath later */ } MemoryStream ms = new MemoryStream(); ZipOutputStream zos = new ZipOutputStream(ms); zos.SetLevel(ZIP_COMPRESSION_LEVEL); if (albumIds != null) { foreach (int albumId in albumIds) { IAlbum album; try { album = Factory.LoadAlbumInstance(albumId, true); } catch (ErrorHandler.CustomExceptions.InvalidAlbumException ex) { ErrorHandler.Error.Record(ex); continue; // Gallery object may have been deleted by someone else, so just skip it. } if (String.IsNullOrEmpty(basePath)) { // The base path wasn't assigned because albumParentId does not refer to a valid album. Instead we will use the path // of the current album's parent. currentItemBasePath = String.Concat(album.Parent.FullPhysicalPathOnDisk, Path.DirectorySeparatorChar); applyWatermark = DetermineIfWatermarkIsToBeApplied(album); } else { currentItemBasePath = basePath; } AddZipEntry(zos, album, imageSize, currentItemBasePath, applyWatermark); } } if (mediaObjectIds != null) { foreach (int mediaObjectId in mediaObjectIds) { IGalleryObject mediaObject; try { mediaObject = Factory.LoadMediaObjectInstance(mediaObjectId); } catch (ArgumentException ex) { ErrorHandler.Error.Record(ex); continue; // Gallery object may have been deleted by someone else, so just skip it. } catch (InvalidMediaObjectException ex) { ErrorHandler.Error.Record(ex); continue; // Gallery object may have been deleted by someone else, so just skip it. } if (String.IsNullOrEmpty(basePath)) { // The base path wasn't assigned because albumParentId does not refer to a valid album. Instead we will use the path // of the current media object's album. currentItemBasePath = String.Concat(mediaObject.Parent.FullPhysicalPathOnDisk, Path.DirectorySeparatorChar); applyWatermark = DetermineIfWatermarkIsToBeApplied((IAlbum)mediaObject.Parent); } else { currentItemBasePath = basePath; } AddFileZipEntry(zos, mediaObject, imageSize, currentItemBasePath, applyWatermark); } } zos.Finish(); return(ms); }
/// <summary> /// Adds the file associated with the <paramref name="mediaObject"/> to the ZIP archive. /// </summary> /// <param name="zos">The ZipOutputStream (ZIP archive) the media object file is to be added to.</param> /// <param name="mediaObject">The media object to be added to the ZIP archive.</param> /// <param name="imageSize">Size of the image to add to the ZIP archive. This parameter applies only to <see cref="Image"/> /// media objects.</param> /// <param name="basePath">The full path to the directory containing the highest-level media file to be added /// to the ZIP archive. Must include trailing slash. Ex: C:\Inetpub\wwwroot\galleryserverpro\mediaobjects\Summer 2005\sunsets\</param> /// <param name="applyWatermark">Indicates whether to apply a watermark to images as they are added to the archive. /// Applies only when <paramref name="mediaObject"/> is an <see cref="Image"/>.</param> private static void AddFileZipEntry(ZipOutputStream zos, IGalleryObject mediaObject, DisplayObjectType imageSize, string basePath, bool applyWatermark) { // Get the path to the file we'll be adding to the zip file. string filePath = GetMediaFilePath(mediaObject, imageSize); // Always use the file name of the original for naming the entry in the zip file. string fileNameForZip = mediaObject.Original.FileNamePhysicalPath; if ((!String.IsNullOrEmpty(filePath)) && (!String.IsNullOrEmpty(fileNameForZip))) { AddFileZipEntry(zos, filePath, fileNameForZip, basePath, (mediaObject is Image), applyWatermark); } }
/// <summary> /// Get an absolute URL to the thumbnail, optimized, or original media object. /// Ex: "http://site.com/gallery/gs/handler/getmedia.ashx?moid=34&dt=1&g=1" /// The URL can be used to assign to the src attribute of an image tag (<img src='...' />). /// Not tested: It should be possible to pass an album and request the url to its thumbnail image. /// </summary> /// <param name="galleryObject">The gallery object for which an URL to the specified image is to be generated.</param> /// <param name="displayType">A DisplayObjectType enumeration value indicating the version of the /// object for which the URL should be generated. Possible values: Thumbnail, Optimized, Original. /// An exception is thrown if any other enumeration is passed.</param> /// <returns>Returns the URL to the thumbnail, optimized, or original version of the requested media object.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="galleryObject" /> is null.</exception> public static string GetGalleryObjectUrl(IGalleryObject galleryObject, DisplayObjectType displayType) { if (galleryObject == null) { throw new ArgumentNullException("galleryObject"); } if (galleryObject is Album && (displayType != DisplayObjectType.Thumbnail)) { throw new ArgumentException(String.Format("It is invalid to request an URL for an album display type '{0}'.", displayType)); } var moBuilder = new MediaObjectHtmlBuilder(MediaObjectHtmlBuilder.GetMediaObjectHtmlBuilderOptions(galleryObject, displayType)); return moBuilder.GetMediaObjectUrl(); }
/// <summary> /// Create a new display object instance with the specified properties. No data is retrieved from the /// data store. A lazy load is used to inflate the object when necessary /// </summary> /// <param name="parent">The media object to which this display object applies.</param> /// <param name="fileName">The name of the file representing this object. Example: sonorandesert.jpg</param> /// <param name="width">The width of this object, in pixels.</param> /// <param name="height">The height of this object, in pixels.</param> /// <param name="displayType">The type of the display object.</param> /// <param name="displayObjectCreator">The object responsible for generating the file this display object points to.</param> /// <returns>Create a new display object instance with the specified properties.</returns> public static IDisplayObject CreateInstance(IGalleryObject parent, string fileName, int width, int height, DisplayObjectType displayType, IDisplayObjectCreator displayObjectCreator) { return(new DisplayObject(width, height, fileName, parent, displayType, displayObjectCreator)); }
/// <summary> /// Generate the URL to the media object. For example, for images this url can be assigned to the src attribute of an img tag. /// (ex: /galleryserverpro/handler/getmediaobject.ashx?moid=34&dt=1&g=1) /// The query string parameter will be encrypted if that option is enabled. /// </summary> /// <param name="galleryId">The gallery ID.</param> /// <param name="mediaObjectId">The unique identifier for the media object.</param> /// <param name="displayType">The type of the display object.</param> /// <returns>Gets the URL to the media object.</returns> public static string GenerateUrl(int galleryId, int mediaObjectId, DisplayObjectType displayType) { return(GetMediaObjectUrl(galleryId, mediaObjectId, displayType)); }
/// <summary> /// Verifies the <paramref name="fullPathToTest" /> is valid and the logged-on user has the necessary permission to specify it. /// </summary> /// <param name="item">The binding item representing the control being tested.</param> /// <param name="fullPathToTest">The full file path the user wishes to use to store media objects, whether they are /// the original media object files, thumbnails, or optimized image files. /// Examples: "C:\inetpub\wwwroot\galleryserverpro\myimages\", "C:/inetpub/wwwroot/galleryserverpro/myimages"</param> /// <param name="pathDisplayControl">The Label control used to display the full, calculated path.</param> /// <param name="displayType">Indicates whether the <paramref name="fullPathToTest" /> is the path for the original, thumbnail, /// or optimized media object files.</param> /// <returns> /// Returns <c>true</c> if the path is valid; otherwise returns <c>false</c>. /// </returns> private bool ValidatePath(wwDataBindingItem item, string fullPathToTest, Label pathDisplayControl, DisplayObjectType displayType) { if (_validatePathFailed) { // To help prevent repeated error messages (one each for original, thumbnail, and optimized), if a previous execution of // this test has failed, then let's just return true, thus allowing the user to focus on a single message. return(true); } bool isValid; if (this.chkPathIsReadOnly.Checked) { if (displayType == DisplayObjectType.Original) { isValid = ValidateReadOnlyGallery(item) && ValidatePathIsReadable(item, fullPathToTest, pathDisplayControl); } else { isValid = ValidateReadOnlyGallery(item) && ValidatePathIsWritable(item, fullPathToTest); } } else { isValid = ValidatePathIsWritable(item, fullPathToTest); } isValid = isValid && ValidateUserHasPermissionToSpecifyPath(item, fullPathToTest); if (isValid) { pathDisplayControl.Text = fullPathToTest; pathDisplayControl.CssClass = "gsp_msgfriendly"; } else { if (!this.GallerySettings.FullMediaObjectPath.Equals(fullPathToTest, StringComparison.OrdinalIgnoreCase)) { pathDisplayControl.Text = String.Concat("<", Resources.GalleryServerPro.Admin_MediaObjects_InvalidPath, ">"); pathDisplayControl.CssClass = "gsp_msgwarning"; } _validatePathFailed = true; } return(isValid); }
/// <summary> /// Verifies the <paramref name="fullPathToTest" /> is valid and the logged-on user has the necessary permission to specify it. /// </summary> /// <param name="item">The binding item representing the control being tested.</param> /// <param name="fullPathToTest">The full file path the user wishes to use to store media objects, whether they are /// the original media object files, thumbnails, or optimized image files. /// Examples: "C:\inetpub\wwwroot\galleryserverpro\myimages\", "C:/inetpub/wwwroot/galleryserverpro/myimages"</param> /// <param name="pathDisplayControl">The Label control used to display the full, calculated path.</param> /// <param name="displayType">Indicates whether the <paramref name="fullPathToTest" /> is the path for the original, thumbnail, /// or optimized media object files.</param> /// <returns> /// Returns <c>true</c> if the path is valid; otherwise returns <c>false</c>. /// </returns> private bool ValidatePath(wwDataBindingItem item, string fullPathToTest, Label pathDisplayControl, DisplayObjectType displayType) { if (_validatePathFailed) { // To help prevent repeated error messages (one each for original, thumbnail, and optimized), if a previous execution of // this test has failed, then let's just return true, thus allowing the user to focus on a single message. return true; } bool isValid; if (this.chkPathIsReadOnly.Checked) { if (displayType == DisplayObjectType.Original) { isValid = ValidateReadOnlyGallery(item) && ValidatePathIsReadable(item, fullPathToTest, pathDisplayControl); } else { isValid = ValidateReadOnlyGallery(item) && ValidatePathIsWritable(item, fullPathToTest); } } else isValid = ValidatePathIsWritable(item, fullPathToTest); isValid = isValid && ValidateUserHasPermissionToSpecifyPath(item, fullPathToTest); if (isValid) { pathDisplayControl.Text = fullPathToTest; pathDisplayControl.CssClass = "gsp_msgfriendly"; } else { if (!this.GallerySettings.FullMediaObjectPath.Equals(fullPathToTest, StringComparison.OrdinalIgnoreCase)) { pathDisplayControl.Text = String.Concat("<", Resources.GalleryServerPro.Admin_MediaObjects_InvalidPath, ">"); pathDisplayControl.CssClass = "gsp_msgwarning"; } _validatePathFailed = true; } return isValid; }
/// <summary> /// Extract information from the query string and assign to our class level variables. Return false if something goes wrong /// and the variables cannot be set. This will happen when the query string is in an unexpected format. /// </summary> /// <param name="queryString">The query string for the current request. Can be populated with HttpContext.Request.Url.Query. /// Must start with a question mark (?).</param> /// <returns>Returns true if all relevant variables were assigned from the query string; returns false if there was a problem.</returns> private bool ExtractQueryStringParms(string queryString) { if (String.IsNullOrEmpty(queryString)) return false; queryString = queryString.Remove(0, 1); // Strip off the ? bool filepathIsEncrypted = AppSetting.Instance.EncryptMediaObjectUrlOnClient; if (filepathIsEncrypted) { // Decode, then decrypt the query string. Note that we must replace spaces with a '+'. This is required when the the URL is // used in javascript to create the Silverlight media player. Apparently, Silverlight or the media player javascript decodes // the query string when it requests the URL, so that means any instances of '%2b' are decoded into '+' before it gets here. // Ideally, we wouldn't even call UrlDecode in this case, but we don't have a way of knowing that it has already been decoded. // So we decode anyway, which doesn't cause any harm *except* it converts '+' to a space, so we need to convert them back. queryString = HelperFunctions.Decrypt(HttpUtility.UrlDecode(queryString).Replace(" ", "+")); } //moid={0}&dt={1}g={2} foreach (string nameValuePair in queryString.Split(new char[] { '&' })) { string[] nameOrValue = nameValuePair.Split(new char[] { '=' }); switch (nameOrValue[0]) { case "g": { int gid; if (Int32.TryParse(nameOrValue[1], out gid)) _galleryIdInQueryString = gid; else return false; break; } case "moid": { int moid; if (Int32.TryParse(nameOrValue[1], out moid)) _mediaObjectId = moid; else return false; break; } case "dt": { int dtInt; if (Int32.TryParse(nameOrValue[1], out dtInt)) { if (DisplayObjectTypeEnumHelper.IsValidDisplayObjectType((DisplayObjectType)dtInt)) { _displayType = (DisplayObjectType)dtInt; break; } else return false; } else return false; } case "sa": { _sendAsAttachment = ((nameOrValue[1].Equals("1", StringComparison.Ordinal)) || (nameOrValue[1].Equals("TRUE", StringComparison.OrdinalIgnoreCase))); break; } default: return false; // Unexpected query string parm. Return false so execution is aborted. } } ValidateDisplayType(); return true; }
/// <summary> /// If an optimized version is being requested, make sure a file name is specified for it. If not, switch to the original version. /// This switch will be necessary for most non-image media objects, since the client usually requests optimized versions for everything. /// </summary> /// <remarks>This function became necessary when switching to the ID-based request in 2.4 (rather than the file-based request). It was /// considered to change the requesting logic to ensure the correct display type is specified, and while that seems preferable from an /// architectural perspective, it was more complex to implement and potentially more fragile than this simple function.</remarks> private void ValidateDisplayType() { if ((_displayType == DisplayObjectType.Optimized) && (String.IsNullOrEmpty(MediaObjectFilePath))) { _displayType = DisplayObjectType.Original; _mediaObjectFilePath = null; // Comment out the exception, as it generates unnecessary errors when bots request deleted items //if (String.IsNullOrEmpty(MediaObjectFilePath)) //{ // throw new InvalidMediaObjectException(String.Format(CultureInfo.CurrentCulture, "A request was made to the Gallery Server Pro HTTP handler to serve the optimized image for media object ID {0}, but either the media object does not exist or neither the optimized nor the original has a filename stored in the database, and therefore cannot be served.", _mediaObjectId)); //} } }
/// <summary> /// Extract information from the query string and assign to our class level variables. Return false if something goes wrong /// and the variables cannot be set. This will happen when the query string is in an unexpected format. /// </summary> /// <param name="queryString">The query string for the current request. Can be populated with HttpContext.Request.Url.Query. /// Must start with a question mark (?).</param> /// <returns>Returns true if all relevant variables were assigned from the query string; returns false if there was a problem.</returns> private bool ExtractQueryStringParms(string queryString) { if (String.IsNullOrEmpty(queryString)) return false; queryString = queryString.Remove(0, 1); // Strip off the ? bool filepathIsEncrypted = WebsiteController.GetGalleryServerProConfigSection().Core.EncryptMediaObjectUrlOnClient; if (filepathIsEncrypted) { // Decode, then decrypt the query string. Note that we must replace spaces with a '+'. This is required when the the URL is // used in javascript to create the Silverlight media player. Apparently, Silverlight or the media player javascript decodes // the query string when it requests the URL, so that means any instances of '%2b' are decoded into '+' before it gets here. // Ideally, we wouldn't even call UrlDecode in this case, but we don't have a way of knowing that it has already been decoded. // So we decode anyway, which doesn't cause any harm *except* it converts '+' to a space, so we need to convert them back. queryString = HelperFunctions.Decrypt(HttpUtility.UrlDecode(queryString).Replace(" ", "+")); } //moid={0}&aid={1}&mo={2}&mtc={3}&dt={4}&isp={5} foreach (string nameValuePair in queryString.Split(new char[] { '&' })) { string[] nameOrValue = nameValuePair.Split(new char[] { '=' }); switch (nameOrValue[0]) { case "moid": { int moid; if (Int32.TryParse(nameOrValue[1], out moid)) _mediaObjectId = moid; else return false; break; } case "aid": { int aid; if (Int32.TryParse(nameOrValue[1], out aid)) _albumId = aid; else return false; break; } case "mo": _filepath = Uri.UnescapeDataString(nameOrValue[1]); break; case "mtc": { int mtcInt; if (Int32.TryParse(nameOrValue[1], out mtcInt)) { if (MimeTypeEnumHelper.IsValidMimeTypeCategory((MimeTypeCategory)mtcInt)) { _mimeTypeCategory = (MimeTypeCategory)mtcInt; break; } else return false; } else return false; } case "dt": { int dtInt; if (Int32.TryParse(nameOrValue[1], out dtInt)) { if (DisplayObjectTypeEnumHelper.IsValidDisplayObjectType((DisplayObjectType)dtInt)) { _displayType = (DisplayObjectType)dtInt; break; } else return false; } else return false; } case "isp": { bool isPrivate; if (Boolean.TryParse(nameOrValue[1], out isPrivate)) _isPrivate = isPrivate; else _isPrivate = true; break; } default: return false; // Unexpected query string parm. Return false so execution is aborted. } } return true; }
/// <summary> /// Get the URL to the thumbnail, optimized, or original media object. Example: /// /dev/gs/handler/getmediaobject.ashx?moid=34&aid=8&mo=C%3A%5Cgs%5Cmypics%5Cbirthday.jpeg&mtc=1&dt=1&isp=false /// The URL can be used to assign to the src attribute of an image tag (<img src='...' />). /// Not tested: It should be possible to pass an album and request the url to its thumbnail image. /// </summary> /// <param name="galleryObject">The gallery object for which an URL to the specified image is to be generated.</param> /// <param name="displayType">A DisplayObjectType enumeration value indicating the version of the /// object for which the URL should be generated. Possible values: Thumbnail, Optimized, Original. /// An exception is thrown if any other enumeration is passed.</param> /// <returns>Returns the URL to the thumbnail, optimized, or original version of the requested media object.</returns> public static string GetMediaObjectUrl(IGalleryObject galleryObject, DisplayObjectType displayType) { string filenamePhysicalPath = null; switch (displayType) { case DisplayObjectType.Thumbnail: filenamePhysicalPath = galleryObject.Thumbnail.FileNamePhysicalPath; break; case DisplayObjectType.Optimized: filenamePhysicalPath = galleryObject.Optimized.FileNamePhysicalPath; break; case DisplayObjectType.Original: filenamePhysicalPath = galleryObject.Original.FileNamePhysicalPath; break; default: throw new ArgumentOutOfRangeException(String.Format(CultureInfo.CurrentCulture, Resources.GalleryServerPro.Error_GetMediaObjectUrl_Ex_Msg1, displayType.ToString())); } return MediaObjectHtmlBuilder.GenerateUrl(galleryObject.Id, galleryObject.Parent.Id, galleryObject.MimeType, filenamePhysicalPath, displayType, galleryObject.IsPrivate); }
/// <overloads>Adds an object to the ZIP archive.</overloads> /// <summary> /// Adds the file associated with the <paramref name="mediaObject"/> to the ZIP archive. /// </summary> /// <param name="zos">The ZipOutputStream (ZIP archive) the media object file is to be added to.</param> /// <param name="mediaObject">The media object to be added to the ZIP archive.</param> /// <param name="imageSize">Size of the image to add to the ZIP archive. This parameter applies only to <see cref="Image"/> /// media objects.</param> /// <param name="basePath">The full path to the directory containing the highest-level media file to be added /// to the ZIP archive. Must include trailing slash. Ex: C:\Inetpub\wwwroot\galleryserverpro\mediaobjects\Summer 2005\sunsets\</param> /// <param name="applyWatermark">Indicates whether to apply a watermark to images as they are added to the archive. /// Applies only when <paramref name="mediaObject"/> is an <see cref="Image"/>.</param> private static void AddFileZipEntry(ZipOutputStream zos, IGalleryObject mediaObject, DisplayObjectType imageSize, string basePath, bool applyWatermark) { // Get the path to the file we'll be adding to the zip file. string filePath = GetMediaFilePath(mediaObject, imageSize); // Always use the file name of the original for naming the entry in the zip file. string fileNameForZip = mediaObject.Original.FileNamePhysicalPath; if ((!String.IsNullOrEmpty(filePath)) && (!String.IsNullOrEmpty(fileNameForZip))) { AddFileZipEntry(zos, filePath, fileNameForZip, basePath, (mediaObject is Image), applyWatermark, mediaObject.GalleryId); } }
public async Task <IActionResult> RotateFlip(GalleryItem[] galleryItems, MediaAssetRotateFlip rotateFlip, DisplayObjectType viewSize) { try { return(new JsonResult(await _galleryObjectController.RotateFlip(galleryItems, rotateFlip, viewSize))); } catch (Exception ex) { AppEventController.LogError(ex); return(StatusCode(500, _exController.GetExString(ex))); } }