/// <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>
/// Persist the specified media object to the data store. Return the ID of the media object.
/// </summary>
/// <param name="mediaObject">An instance of <see cref="IGalleryObject" /> to persist to the data store.</param>
/// <returns>Return the ID of the media object. If this is a new media object and a new ID has been
/// assigned, then this value has also been assigned to the ID property of the object.</returns>
public static int Save(IGalleryObject mediaObject)
{
int mediaObjectId = mediaObject.Id;
if (mediaObject.IsNew)
{
// Insert new record into MediaObject table.
SqlCommand cmd = GetCommandMediaObjectInsert(mediaObject);
cmd.Connection.Open();
cmd.ExecuteNonQuery();
cmd.Connection.Close();
mediaObjectId = Convert.ToInt32(cmd.Parameters["@Identity"].Value, System.Globalization.NumberFormatInfo.InvariantInfo);
if (mediaObject.Id != mediaObjectId)
{
mediaObject.Id = mediaObjectId;
}
// Insert metadata items, if any, into MediaObjectMetadata table.
InsertMetadataItems(mediaObject);
}
else
{
SqlCommand cmd = GetCommandMediaObjectUpdate(mediaObject);
cmd.Connection.Open();
cmd.ExecuteNonQuery();
cmd.Connection.Close();
// Update metadata items, if necessary, in MediaObjectMetadata table.
UpdateMetadataItems(mediaObject);
}
return mediaObjectId;
}
protected static int GetImageHeight(IGalleryObject galleryObject)
{
if (galleryObject.Optimized.Height > int.MinValue)
return galleryObject.Optimized.Height;
else
return galleryObject.Thumbnail.Height;
}
/// <summary>
/// Adds the specified gallery object.
/// </summary>
/// <param name="item">The gallery object.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="item" /> is null.</exception>
public void Add(IGalleryObject item)
{
if (item == null)
throw new ArgumentNullException("item", "Cannot add null to an existing GalleryObjectCollection. Items.Count = " + Items.Count);
Items.TryAdd(GetKey(item), item);
}
protected static int GetImageWidth(IGalleryObject galleryObject)
{
if (galleryObject.Optimized.Width > int.MinValue)
return galleryObject.Optimized.Width;
else
return galleryObject.Thumbnail.Width;
}
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;
}
}
protected string GetImageUrl(IGalleryObject galleryObject)
{
if ((galleryObject.Optimized.Width > int.MinValue) || (galleryObject.Optimized.Height > int.MinValue))
return GetOptimizedUrl(galleryObject);
else
return GetThumbnailUrl(galleryObject);
}
/// <summary>
/// Copy the specified object and place it in the specified destination album. This method creates a completely separate copy
/// of the original, including copying the physical files associated with this object. The copy is persisted to the data
/// store and then returned to the caller. When copying albums, all the album's children, grandchildren, etc are also copied.
/// The audit fields of the copied objects are automatically updated before saving.
/// </summary>
/// <param name="galleryObjectToCopy">The gallery object to copy.</param>
/// <param name="destinationAlbum">The album to which the current object should be copied.</param>
/// <returns>
/// Returns a new gallery object that is an exact copy of the original, except that it resides in the specified
/// destination album, and of course has a new ID. Child objects are recursively copied.
/// </returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="galleryObjectToCopy" /> is null.</exception>
public static IGalleryObject CopyGalleryObject(IGalleryObject galleryObjectToCopy, IAlbum destinationAlbum)
{
if (galleryObjectToCopy == null)
throw new ArgumentNullException("galleryObjectToCopy");
string currentUser = Utils.UserName;
return galleryObjectToCopy.CopyTo(destinationAlbum, currentUser);
}
/// <summary>
/// Gets a value that uniquely identifies the specified <paramref name="galleryObject" /> (ex: "a25", "m223").
/// </summary>
/// <param name="galleryObject">The gallery object.</param>
/// <returns>Returns an ID.</returns>
protected static string GetId(IGalleryObject galleryObject)
{
// Prepend an 'a' (for album) or 'm' (for media object) to the ID to indicate whether it is
// an album ID or media object ID.
if (galleryObject is Album)
return "a" + galleryObject.Id.ToString(CultureInfo.InvariantCulture);
else
return "m" + galleryObject.Id.ToString(CultureInfo.InvariantCulture);
}
/// <summary>
/// Gets the URL to the specified <paramref name="galleryObject" />.
/// </summary>
/// <param name="galleryObject">The gallery object.</param>
/// <returns>Returns a string.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="galleryObject" /> is null.</exception>
protected string GetImageUrl(IGalleryObject galleryObject)
{
if (galleryObject == null)
throw new ArgumentNullException("galleryObject");
if ((galleryObject.Optimized.Width > int.MinValue) || (galleryObject.Optimized.Height > int.MinValue))
return GetOptimizedUrl(galleryObject);
else
return GetThumbnailUrl(galleryObject);
}
/// <summary>
/// Gets the width of the specified <paramref name="galleryObject" />.
/// </summary>
/// <param name="galleryObject">The gallery object.</param>
/// <returns>The width.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="galleryObject" /> is null.</exception>
protected static int GetImageWidth(IGalleryObject galleryObject)
{
if (galleryObject == null)
throw new ArgumentNullException("galleryObject");
if (galleryObject.Optimized.Width > int.MinValue)
return galleryObject.Optimized.Width;
else
return galleryObject.Thumbnail.Width;
}
/// <summary>
/// Gets the CSS class to apply to the thumbnail object.
/// </summary>
/// <param name="galleryObject">The gallery object.</param>
/// <returns>Returns a CSS class.</returns>
protected static string GetThumbnailCssClass(IGalleryObject galleryObject)
{
// If it's an album then specify the appropriate CSS class so that the "Album"
// header appears over the thumbnail. This is to indicate to the user that the
// thumbnail represents an album.
if (galleryObject is Album)
return "thmb album";
else
return "thmb";
}
/// <summary>
/// Calculate the potential hard drive savings, in KB, if all original files were deleted from <paramref name="galleryObject"/>.
/// If <paramref name="galleryObject"/> is an Album, then the value includes the sum of the size of all original files
/// within the album.
/// </summary>
/// <param name="galleryObject">The gallery object.</param>
/// <returns>Returns the potential hard drive savings, in KB, if all original files were deleted from <paramref name="galleryObject"/>.</returns>
protected static string GetSavings(IGalleryObject galleryObject)
{
if (galleryObject == null)
throw new ArgumentNullException("galleryObject");
if (galleryObject.GetType() == typeof(Album))
return String.Format(CultureInfo.CurrentCulture, "({0} KB)", GetFileSizeKbAllOriginalFilesInAlbum((IAlbum)galleryObject));
else
return String.Format(CultureInfo.CurrentCulture, "({0} KB)", galleryObject.Original.FileSizeKB);
}
private bool _hasBeenDisposed; // Used by Dispose() methods
#endregion
#region Constructors
/// <summary>
/// Initializes a new instance of the <see cref="GalleryObject"/> class.
/// </summary>
protected GalleryObject()
{
this._parent = new NullObjects.NullGalleryObject();
this._thumbnail = new NullObjects.NullDisplayObject();
this._optimized = new NullObjects.NullDisplayObject();
this._original = new NullObjects.NullDisplayObject();
// Default IsSynchronized to true. It is set to false during a synchronization.
this.IsSynchronized = true;
}
protected string GetMediaObjectUrl(IGalleryObject mediaObject)
{
switch (mediaObject.GalleryObjectType)
{
case GalleryObjectType.Image: return GetOptimizedUrl(mediaObject);
case GalleryObjectType.Video: return GetThumbnailUrl(mediaObject);
}
return null;
}
/// <summary>
/// Move the specified object to the specified destination album. This method moves the physical files associated with this
/// object to the destination album's physical directory. The object's Save() method is invoked to persist the changes to the
/// data store. When moving albums, all the album's children, grandchildren, etc are also moved.
/// The audit fields are automatically updated before saving.
/// </summary>
/// <param name="galleryObjectToMove">The gallery object to move.</param>
/// <param name="destinationAlbum">The album to which the current object should be moved.</param>
public static void MoveGalleryObject(IGalleryObject galleryObjectToMove, IAlbum destinationAlbum)
{
string currentUser = Util.UserName;
DateTime currentTimestamp = DateTime.Now;
galleryObjectToMove.LastModifiedByUserName = currentUser;
galleryObjectToMove.DateLastModified = currentTimestamp;
galleryObjectToMove.MoveTo(destinationAlbum);
}
/// <summary>
/// Gets a value that uniquely identifies the specified <paramref name="galleryObject" /> (ex: "a25", "m223").
/// </summary>
/// <param name="galleryObject">The gallery object.</param>
/// <returns>Returns an ID.</returns>
protected static string GetId(IGalleryObject galleryObject)
{
if (galleryObject == null)
throw new ArgumentNullException("galleryObject");
// Prepend an 'a' (for album) or 'm' (for media object) to the ID to indicate whether it is
// an album ID or media object ID.
if (galleryObject is Album)
return "a" + galleryObject.Id.ToString(CultureInfo.InvariantCulture);
else
return "m" + galleryObject.Id.ToString(CultureInfo.InvariantCulture);
}
/// <summary>
/// Initializes a new instance of the <see cref="GalleryObject"/> class.
/// </summary>
protected GalleryObject()
{
this._parent = new NullObjects.NullGalleryObject();
this._thumbnail = new NullObjects.NullDisplayObject();
this._optimized = new NullObjects.NullDisplayObject();
this._original = new NullObjects.NullDisplayObject();
// Default IsSynchronized to false. It is set to true during a synchronization.
this.IsSynchronized = false;
this.IsWritable = true;
this.BeforeAddMetaItem += OnBeforeAddMetaItem;
}
/// <summary>
/// Initializes a new instance of the <see cref="GalleryObjectMetadataItem" /> class.
/// </summary>
/// <param name="mediaObjectMetadataId">The value that uniquely indentifies this metadata item.</param>
/// <param name="galleryObject">The gallery object this metadata item applies to.</param>
/// <param name="rawValue">The raw value of the metadata item. Typically this is the value extracted from
/// the metadata of the media file.</param>
/// <param name="value">The value of the metadata item (e.g. "F5.7", "1/500 sec.").</param>
/// <param name="hasChanges">if set to <c>true</c> this object has changes that have not been persisted to the database.</param>
/// <param name="metaDef">The meta definition.</param>
public GalleryObjectMetadataItem(int mediaObjectMetadataId, IGalleryObject galleryObject, string rawValue, string value, bool hasChanges, IMetadataDefinition metaDef)
{
_mediaObjectMetadataId = mediaObjectMetadataId;
GalleryObject = galleryObject;
_metadataItemName = metaDef.MetadataItem;
_description = metaDef.DisplayName;
_rawValue = rawValue;
_value = value;
_hasChanges = hasChanges;
MetaDefinition = metaDef;
_isVisible = false;
IsDeleted = false;
}
protected static string GetWidthAndHeightStyle(IGalleryObject mediaObject)
{
var width = mediaObject.Optimized.Width;
var height = mediaObject.Optimized.Height;
if (mediaObject.GalleryObjectType == GalleryObjectType.Video)
{
width = mediaObject.Thumbnail.Width;
height = mediaObject.Thumbnail.Height;
}
return String.Format(CultureInfo.InvariantCulture, "width:{0}px;height:{1}px;", width, height);
}
/// <summary>
/// Move the specified object to the specified destination album. This method moves the physical files associated with this
/// object to the destination album's physical directory. The object's Save() method is invoked to persist the changes to the
/// data store. When moving albums, all the album's children, grandchildren, etc are also moved.
/// The audit fields are automatically updated before saving.
/// </summary>
/// <param name="galleryObjectToMove">The gallery object to move.</param>
/// <param name="destinationAlbum">The album to which the current object should be moved.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="galleryObjectToMove" /> is null.</exception>
public static void MoveGalleryObject(IGalleryObject galleryObjectToMove, IAlbum destinationAlbum)
{
if (galleryObjectToMove == null)
throw new ArgumentNullException("galleryObjectToMove");
string currentUser = Utils.UserName;
DateTime currentTimestamp = DateTime.Now;
galleryObjectToMove.LastModifiedByUserName = currentUser;
galleryObjectToMove.DateLastModified = currentTimestamp;
galleryObjectToMove.MoveTo(destinationAlbum);
}
/// <summary>
/// Permanently delete the specified media object from the data store. This action cannot
/// be undone. This action also deletes the related metadata items.
/// </summary>
/// <param name="mediaObject">The <see cref="IGalleryObject" /> to delete from the data store.</param>
public static void Delete(IGalleryObject mediaObject)
{
// Related metadata items in the MediaObjectMetadataItem table are deleted
// via a cascade delete rule configured between this table and the MediaObject table.
using (SqlConnection cn = SqlDataProvider.GetDbConnection())
{
using (SqlCommand cmd = GetCommandMediaObjectDelete(mediaObject.Id, cn))
{
cn.Open();
cmd.ExecuteNonQuery();
}
}
}
/// <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 void DeleteFromFileSystem(IGalleryObject galleryObject)
{
// Delete thumbnail file.
if (System.IO.File.Exists(galleryObject.Thumbnail.FileNamePhysicalPath))
{
System.IO.File.Delete(galleryObject.Thumbnail.FileNamePhysicalPath);
}
// Delete optimized file.
if (System.IO.File.Exists(galleryObject.Optimized.FileNamePhysicalPath))
{
System.IO.File.Delete(galleryObject.Optimized.FileNamePhysicalPath);
}
// Delete original file.
if (System.IO.File.Exists(galleryObject.Original.FileNamePhysicalPath))
{
System.IO.File.Delete(galleryObject.Original.FileNamePhysicalPath);
}
}
/// <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>
/// Persist the gallery object to the data store. This method updates the audit fields before saving. All gallery objects should be
/// saved through this method rather than directly invoking the gallery object's Save method, unless you want to
/// manually update the audit fields yourself.
/// </summary>
/// <param name="galleryObject">The gallery object to persist to the data store.</param>
/// <param name="userName">The user name to be associated with the modifications. This name is stored in the internal
/// audit fields associated with this gallery object.</param>
public static void SaveGalleryObject(IGalleryObject galleryObject, string userName)
{
DateTime currentTimestamp = DateTime.Now;
if (galleryObject.IsNew)
{
galleryObject.CreatedByUserName = userName;
galleryObject.DateAdded = currentTimestamp;
}
if (galleryObject.HasChanges)
{
galleryObject.LastModifiedByUserName = userName;
galleryObject.DateLastModified = currentTimestamp;
}
// Verify that any role needed for album ownership exists and is properly configured.
RoleController.ValidateRoleExistsForAlbumOwner(galleryObject as IAlbum);
// Persist to data store.
galleryObject.Save();
}
private void ConfigureControls()
{
this.TaskHeaderText = Resources.GalleryServerPro.Task_Rotate_Image_Header_Text;
this.TaskBodyText = Resources.GalleryServerPro.Task_Rotate_Image_Body_Text;
this.OkButtonText = Resources.GalleryServerPro.Task_Rotate_Image_Ok_Button_Text;
this.OkButtonToolTip = Resources.GalleryServerPro.Task_Rotate_Image_Ok_Button_Tooltip;
this.PageTitle = Resources.GalleryServerPro.Task_Rotate_Image_Page_Title;
IGalleryObjectCollection images = new GalleryObjectCollection();
IGalleryObject image = this.GetMediaObject();
if (image is GalleryServerPro.Business.Image)
{
images.Add(image);
rptr.DataSource = images;
rptr.DataBind();
}
else
{
Util.Redirect(Web.PageId.mediaobject, "moid={0}&msg={1}", image.Id, ((int)Message.CannotRotateObjectNotRotatable).ToString(CultureInfo.InvariantCulture));
}
}
private static void DeleteFromFileSystem(IGalleryObject galleryObject, bool deleteAllFromFileSystem)
{
// Delete thumbnail file.
if (System.IO.File.Exists(galleryObject.Thumbnail.FileNamePhysicalPath))
{
System.IO.File.Delete(galleryObject.Thumbnail.FileNamePhysicalPath);
}
// Delete optimized file.
if (!galleryObject.Optimized.FileName.Equals(galleryObject.Original.FileName))
{
if (System.IO.File.Exists(galleryObject.Optimized.FileNamePhysicalPath))
{
System.IO.File.Delete(galleryObject.Optimized.FileNamePhysicalPath);
}
}
// Delete original file.
if (deleteAllFromFileSystem && System.IO.File.Exists(galleryObject.Original.FileNamePhysicalPath))
{
System.IO.File.Delete(galleryObject.Original.FileNamePhysicalPath);
}
}
/// <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 void BindData()
{
//Get the data associated with the album and display
if (this.GalleryObjectsDataSource == null)
{
// Sueetie Modified - Retrieve Recent Photos
if (DataHelper.GetIntFromQueryString("aid", 1) == -1)
{
List <SueetieMediaObject> sueetieMediaObjects = SueetieMedia.GetSueetieMediaObjectList(this.GalleryPage.CurrentSueetieGalleryID, true);
sueetieMediaObjects.Sort(delegate(SueetieMediaObject x, SueetieMediaObject y) { return(DateTime.Compare(y.DateAdded, x.DateAdded)); });
int _photoCount = SueetieConfiguration.Get().Media.RecentPhotoCount;
if (_photoCount > sueetieMediaObjects.Count)
{
_photoCount = sueetieMediaObjects.Count;
}
IGalleryObjectCollection _galleryObjects = new GalleryObjectCollection();
for (int i = 0; i < _photoCount; i++)
{
IGalleryObject _galleryObject = Factory.LoadMediaObjectInstance(sueetieMediaObjects[i].MediaObjectID);
_galleryObjects.Add(_galleryObject);
}
_galleryObjects.Sort();
DisplayThumbnails(_galleryObjects, true);
}
else
{
DisplayThumbnails(this.GalleryPage.GetAlbum().GetChildGalleryObjects(true, this.GalleryPage.IsAnonymousUser), true);
}
}
else
{
DisplayThumbnails(this.GalleryObjectsDataSource, false);
}
}
/// <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:
if (string.IsNullOrWhiteSpace(mediaObject.Optimized.FileNamePhysicalPath))
{
return(mediaObject.Original.FileNamePhysicalPath);
}
else
{
return(mediaObject.Optimized.FileNamePhysicalPath);
}
case DisplayObjectType.Original:
return(mediaObject.Original.FileNamePhysicalPath);
default:
return(string.Empty);
}
}
private IGalleryObject GetDefaultGalleryAlbum(IGalleryControlSettings gcs)
{
if (!gcs.AlbumId.HasValue)
{
return(null); // We should never get here because the calling method should have already verified there is a value, but we'll be extra safe.
}
IGalleryObject defaultGalleryAlbum = null;
try
{
defaultGalleryAlbum = Factory.LoadAlbumInstance(gcs.AlbumId.Value);
}
catch (InvalidAlbumException ex)
{
// Album doesn't exist. This won't prevent us from deleting the album but we should note the issue, since
// it can cause problems to specify an album that doesn't exist for the default gallery object.
string galleryDescription = Factory.LoadGallery(_albumToDelete.GalleryId).Description;
string msg = String.Format(CultureInfo.CurrentCulture, Resources.Error_Default_Gallery_Object_Album_Invalid_Ex_Msg, galleryDescription, _albumToDelete.Id);
EventController.RecordError(new BusinessException(msg, ex), AppSetting.Instance, _albumToDelete.GalleryId, Factory.LoadGallerySettings());
}
return(defaultGalleryAlbum);
}
private void CreateNewMediaObject(IAlbum album, FileInfo file)
{
try
{
IGalleryObject mediaObject = Factory.CreateMediaObjectInstance(file, album);
HelperFunctions.UpdateAuditFields(mediaObject, this._userName);
mediaObject.Save();
Core core = ConfigManager.GetGalleryServerProConfigSection().Core;
if (!core.MediaObjectPathIsReadOnly && (core.DiscardOriginalImageDuringImport) && (mediaObject is Business.Image))
{
((Business.Image)mediaObject).DeleteHiResImage();
mediaObject.Save();
}
mediaObject.IsSynchronized = true;
System.Diagnostics.Debug.Assert(!String.IsNullOrEmpty(mediaObject.Hashkey));
}
catch (GalleryServerPro.ErrorHandler.CustomExceptions.UnsupportedMediaObjectTypeException)
{
this._synchStatus.SkippedMediaObjects.Add(new KeyValuePair <string, string>(file.FullName.Remove(0, _mediaObjectPhysicalPathLength + 1), Resources.SynchronizationStatus_Disabled_File_Type_Msg));
}
}
private IGalleryObject GetDefaultGalleryAlbum(IGalleryControlSettings gcs)
{
if (!gcs.AlbumId.HasValue)
{
return(null); // We should never get here because the calling method should have already verified there is a value, but we'll be extra safe.
}
IGalleryObject defaultGalleryAlbum = null;
try
{
defaultGalleryAlbum = Factory.LoadAlbumInstance(gcs.AlbumId.Value);
}
catch (InvalidAlbumException ex)
{
// Album doesn't exist. This won't prevent us from deleting the album but we should note the issue, since
// it can cause problems to specify an album that doesn't exist for the default gallery object.
string galleryDescription = Factory.LoadGallery(_albumToDelete.GalleryId).Description;
string msg = $"Default Gallery Asset Album Invalid: The gallery '{galleryDescription}' has an album ID specified ({_albumToDelete.Id}) as the default gallery asset and it does not match an existing album. Review this setting in the administration area.";
EventController.RecordError(new BusinessException(msg, ex), AppSetting.Instance, _albumToDelete.GalleryId, Factory.LoadGallerySettings());
}
return(defaultGalleryAlbum);
}
private int rotateImages()
{
// Rotate any images on the hard drive according to the user's wish.
int returnValue = int.MinValue;
Dictionary <int, RotateFlipType> imagesToRotate = retrieveUserSelections();
try
{
HelperFunctions.BeginTransaction();
foreach (KeyValuePair <int, RotateFlipType> kvp in imagesToRotate)
{
IGalleryObject image = Factory.LoadImageInstance(kvp.Key);
image.Rotation = kvp.Value;
try
{
GalleryObjectController.SaveGalleryObject(image);
}
catch (UnsupportedImageTypeException)
{
returnValue = (int)Message.CannotRotateInvalidImage;
}
}
HelperFunctions.CommitTransaction();
}
catch
{
HelperFunctions.RollbackTransaction();
throw;
}
HelperFunctions.PurgeCache();
return(returnValue);
}
private static ActionResult CreateMediaObject(string filePath, IAlbum album, AddMediaObjectSettings options)
{
var result = new ActionResult()
{
Title = Path.GetFileName(filePath)
};
try
{
using (IGalleryObject go = Factory.CreateMediaObjectInstance(filePath, album))
{
SaveGalleryObject(go);
if (options.DiscardOriginalFile)
{
go.DeleteOriginalFile();
GalleryObjectController.SaveGalleryObject(go);
}
result.Status = ActionResultStatus.Success;
}
}
catch (UnsupportedMediaObjectTypeException ex)
{
try
{
File.Delete(filePath);
}
catch (UnauthorizedAccessException) { } // Ignore an error; the file will continue to exist in the destination album directory
result.Status = ActionResultStatus.Error;
result.Message = ex.Message;
}
return(result);
}
/// <summary>
/// Adds the <paramref name="zipContentFile"/> as a media object to the <paramref name="album"/>.
/// </summary>
/// <param name="zipContentFile">A reference to a file in a ZIP archive.</param>
/// <param name="album">The album to which the file should be added as a media object.</param>
private void AddMediaObjectToGallery(ZipEntry zipContentFile, IAlbum album)
{
string zipFileName = Path.GetFileName(zipContentFile.Name).Trim();
if (zipFileName.Length == 0)
{
return;
}
string uniqueFilename = HelperFunctions.ValidateFileName(album.FullPhysicalPathOnDisk, zipFileName);
string uniqueFilepath = Path.Combine(album.FullPhysicalPathOnDisk, uniqueFilename);
// Extract the file from the zip stream and save as the specified filename.
ExtractFileFromZipStream(uniqueFilepath);
// Get the file we just saved to disk.
FileInfo mediaObjectFile = new FileInfo(uniqueFilepath);
try
{
IGalleryObject mediaObject = Factory.CreateMediaObjectInstance(mediaObjectFile, album);
HelperFunctions.UpdateAuditFields(mediaObject, this._userName);
mediaObject.Save();
if ((_discardOriginalImage) && (mediaObject is Business.Image))
{
((Business.Image)mediaObject).DeleteHiResImage();
mediaObject.Save();
}
}
catch (ErrorHandler.CustomExceptions.UnsupportedMediaObjectTypeException ex)
{
this._skippedFiles.Add(new KeyValuePair <string, string>(mediaObjectFile.Name, ex.Message));
File.Delete(mediaObjectFile.FullName);
}
}
private bool DoesOriginalExceedOptimizedTriggers(IGalleryObject mediaObject)
{
// Note: This function also exists in the ImageOptimizedCreator class.
// Test 1: Is the file size of the original greater than OptimizedImageTriggerSizeKB?
bool isOriginalFileSizeGreaterThanTriggerSize = false;
if (mediaObject.Original.FileSizeKB > _optimizedTriggerSizeKb)
{
isOriginalFileSizeGreaterThanTriggerSize = true;
}
// Test 2: Is the width or length of the original greater than the MaxOptimizedLength?
bool isOriginalLengthGreaterThanMaxAllowedLength = false;
double originalWidth = 0;
double originalHeight = 0;
try
{
var size = mediaObject.Original.GetSize();
originalWidth = size.Width;
originalHeight = size.Height;
}
catch (UnsupportedImageTypeException ex)
{
EventController.RecordError(ex, AppSetting.Instance, _galleryId, Factory.LoadGallerySettings());
}
if ((originalWidth > _optimizedMaxLength) || (originalHeight > _optimizedMaxLength))
{
isOriginalLengthGreaterThanMaxAllowedLength = true;
}
return(isOriginalFileSizeGreaterThanTriggerSize | isOriginalLengthGreaterThanMaxAllowedLength);
}
/// <summary>
/// Converts the <paramref name="mediaObject"/> to an instance of <see cref="Entity.MediaItem" />.
/// The returned object DOES have the <see cref="Entity.MediaItem.MetaItems" /> property assigned.
/// The instance can be JSON-serialized and sent to the browser. Do not pass an
/// <see cref="IAlbum" /> to this function.
/// </summary>
/// <param name="mediaObject">The media object to convert to an instance of
/// <see cref="Entity.MediaItem"/>.</param>
/// <param name="indexInAlbum">The one-based index of this media object within its album. This value is assigned to
/// <see cref="Entity.MediaItem.Index" />.</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.
/// If set to null, the property is automatically populated.</param>
/// <returns>
/// Returns an <see cref="Entity.MediaItem"/> object containing information
/// about the requested media object.
/// </returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="mediaObject" /> or
/// <paramref name="browsers" /> is null.</exception>
/// <exception cref="System.ArgumentOutOfRangeException">Thrown when <paramref name="browsers" /> does
/// not contain any elements.</exception>
public static MediaItem ToMediaItem(IGalleryObject mediaObject, int indexInAlbum, Array browsers)
{
if (mediaObject == null)
{
throw new ArgumentNullException("mediaObject");
}
if (browsers == null)
{
throw new ArgumentNullException("browsers");
}
if (browsers.Length == 0)
{
throw new ArgumentOutOfRangeException("browsers", "The browsers array parameter must have at least one element.");
}
var isBeingProcessed = MediaConversionQueue.Instance.IsWaitingInQueueOrProcessing(mediaObject.Id, MediaQueueItemConversionType.CreateOptimized);
var moEntity = new MediaItem
{
Id = mediaObject.Id,
AlbumId = mediaObject.Parent.Id,
AlbumTitle = mediaObject.Parent.Title,
Index = indexInAlbum,
Title = mediaObject.Title,
Views = GetViews(mediaObject, browsers).ToArray(),
HighResAvailable = isBeingProcessed || (!String.IsNullOrEmpty(mediaObject.Optimized.FileName)) && (mediaObject.Original.FileName != mediaObject.Optimized.FileName),
IsDownloadable = !(mediaObject is ExternalMediaObject),
MimeType = (int)mediaObject.MimeType.TypeCategory,
ItemType = (int)mediaObject.GalleryObjectType,
MetaItems = ToMetaItems(mediaObject.MetadataItems.GetVisibleItems(), mediaObject)
};
return(moEntity);
}
/// <summary>
/// Initializes a new instance of the <see cref="ImageOptimizedCreator"/> class.
/// </summary>
/// <param name="galleryObject">The media object.</param>
public ImageOptimizedCreator(IGalleryObject galleryObject)
{
GalleryObject = galleryObject;
}
/// <summary>
/// Adds the uploaded files to the gallery. This method is called when the application is operating under full trust. In this case,
/// the ComponentArt Upload control is used. The logic is nearly identical to that in AddUploadedFilesLessThanFullTrust - the only
/// differences are syntax differences arising from the different file upload control.
/// </summary>
/// <param name="files">The files to add to the gallery.</param>
private void AddUploadedFilesForFullTrust(UploadedFileInfoCollection files)
{
// Clear the list of hash keys so we're starting with a fresh load from the data store.
try
{
MediaObjectHashKeys.Clear();
string albumPhysicalPath = this.GetAlbum().FullPhysicalPathOnDisk;
HelperFunctions.BeginTransaction();
UploadedFileInfo[] fileInfos = new UploadedFileInfo[files.Count];
files.CopyTo(fileInfos, 0);
Array.Reverse(fileInfos);
foreach (UploadedFileInfo file in fileInfos)
{
if (String.IsNullOrEmpty(file.FileName))
{
continue;
}
if ((System.IO.Path.GetExtension(file.FileName).Equals(".zip", StringComparison.OrdinalIgnoreCase)) && (!chkDoNotExtractZipFile.Checked))
{
#region Extract the files from the zipped file.
lock (file)
{
if (File.Exists(file.TempFileName))
{
using (ZipUtility zip = new ZipUtility(Util.UserName, RoleController.GetGalleryServerRolesForUser()))
{
this._skippedFiles.AddRange(zip.ExtractZipFile(file.GetStream(), this.GetAlbum(), chkDiscardOriginalImage.Checked));
}
}
else
{
// When one of the files causes an OutOfMemoryException, this can cause the other files to disappear from the
// temp upload directory. This seems to be an issue with the ComponentArt Upload control, since this does not
// seem to happen with the ASP.NET FileUpload control. If the file doesn't exist, make a note of it and move on
// to the next one.
this._skippedFiles.Add(new KeyValuePair <string, string>(file.FileName, Resources.GalleryServerPro.Task_Add_Objects_Uploaded_File_Does_Not_Exist_Msg));
continue; // Skip to the next file.
}
}
#endregion
}
else
{
#region Add the file
string filename = HelperFunctions.ValidateFileName(albumPhysicalPath, file.FileName);
string filepath = Path.Combine(albumPhysicalPath, filename);
#if DEBUG
TechInfoSystems.TracingTools.Tools.MarkSpot(string.Format(CultureInfo.CurrentCulture, "Attempting to move file {0} to {1}...", file.FileName, filepath));
#endif
lock (file)
{
if (File.Exists(file.TempFileName))
{
file.SaveAs(filepath);
}
else
{
// When one of the files causes an OutOfMemoryException, this can cause the other files to disappear from the
// temp upload directory. This seems to be an issue with the ComponentArt Upload control, since this does not
// seem to happen with the ASP.NET FileUpload control. If the file doesn't exist, make a note of it and move on
// to the next one.
this._skippedFiles.Add(new KeyValuePair <string, string>(file.FileName, Resources.GalleryServerPro.Task_Add_Objects_Uploaded_File_Does_Not_Exist_Msg));
continue; // Skip to the next file.
}
}
try
{
IGalleryObject go = Factory.CreateMediaObjectInstance(filepath, this.GetAlbum());
GalleryObjectController.SaveGalleryObject(go);
if ((chkDiscardOriginalImage.Checked) && (go is Business.Image))
{
((Business.Image)go).DeleteHiResImage();
GalleryObjectController.SaveGalleryObject(go);
}
}
catch (UnsupportedMediaObjectTypeException ex)
{
try
{
File.Delete(filepath);
}
catch (UnauthorizedAccessException) { } // Ignore an error; the file will end up getting deleted during cleanup maintenance
this._skippedFiles.Add(new KeyValuePair <string, string>(filename, ex.Message));
}
#endregion
}
}
HelperFunctions.CommitTransaction();
}
catch
{
HelperFunctions.RollbackTransaction();
throw;
}
finally
{
// Delete the uploaded temporary files, as by this time they have been saved to the destination directory.
foreach (UploadedFileInfo file in files)
{
try
{
System.IO.File.Delete(file.TempFileName);
}
catch (UnauthorizedAccessException) { } // Ignore an error; the file will end up getting deleted during cleanup maintenance
}
// Clear the list of hash keys to free up memory.
MediaObjectHashKeys.Clear();
HelperFunctions.PurgeCache();
}
}
/// <summary>
/// Gets an HTML string representing the content of the <paramref name="galleryObject" />. For example,
/// albums contain the title and caption while images contain a hyperlinked img tag pointing to
/// <paramref name="pageUrl" />. Other media objects contain the HTML generated by <paramref name="moBuilder" />.
/// </summary>
/// <param name="galleryObject">The gallery object.</param>
/// <param name="pageUrl">An URL pointing to a gallery page for the <paramref name="galleryObject" />
/// Images use this value to create a hyperlink that is wrapped around the img tag.</param>
/// <param name="moBuilder">An instance of <see cref="MediaObjectHtmlBuilder" />.</param>
/// <returns><see cref="System.String" />.</returns>
private static string GetGalleryObjectContent(IGalleryObject galleryObject, string pageUrl, MediaObjectHtmlBuilder moBuilder)
{
switch (galleryObject.GalleryObjectType)
{
case GalleryObjectType.Image:
return String.Format("<div><a href='{0}'>{1}</a></div><p>{2}</p><p>{3}</p>", pageUrl, moBuilder.GenerateHtml(), galleryObject.Title, galleryObject.Caption);
case GalleryObjectType.Album:
return String.Format("<p>{0}</p><p>{1}</p>", galleryObject.Title, galleryObject.Caption);
default:
// Don't include the hyperlink around the MO HTML because that interferes with audio/video controls.
return String.Format("<div>{0}</div><p>{1}</p><p>{2}</p>", moBuilder.GenerateHtml(), galleryObject.Title, galleryObject.Caption);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MediaObjectMetadataReadWriter" /> class.
/// </summary>
/// <param name="mediaObject">The media object.</param>
protected MediaObjectMetadataReadWriter(IGalleryObject mediaObject)
: base(mediaObject)
{
}
/// <summary>
/// Gets a value to be initially used to set the width of the title below the thumbnail. This is later removed via jQuery
/// after the equalSize() function standardizes all the thumbnail boxes. Without this setting the titles will push the
/// width of the thumbnails to be as wide as the title.
/// </summary>
/// <param name="galleryObject">The gallery object.</param>
/// <returns>An instance of <see cref="Unit" />.</returns>
protected Unit GetTitleWidth(IGalleryObject galleryObject)
{
return(new Unit(galleryObject.Thumbnail.Width + 40, UnitType.Pixel));
}
/// <summary>
/// Initializes a new instance of the <see cref="MediaObjectSaveBehavior"/> class.
/// </summary>
/// <param name="galleryObject">The gallery object.</param>
public MediaObjectSaveBehavior(IGalleryObject galleryObject)
{
this._galleryObject = galleryObject;
}
/// <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>
/// <returns>Returns an instance representing a new display object with default properties.</returns>
public static IDisplayObject CreateInstance(IGalleryObject parent)
{
return(CreateInstance(parent, string.Empty, int.MinValue, int.MinValue, DisplayObjectType.Unknown, new NullObjects.NullDisplayObjectCreator()));
}
public void DoAddGalleryObject(IGalleryObject galleryObject)
{
}
/// <summary>
/// Create a sample album and media object. This method is intended to be invoked once just after the application has been
/// installed.
/// </summary>
/// <param name="galleryId">The ID for the gallery where the sample objects are to be created.</param>
public static void CreateSampleObjects(int galleryId)
{
if (Factory.LoadGallerySetting(galleryId).MediaObjectPathIsReadOnly)
{
return;
}
DateTime currentTimestamp = DateTime.Now;
IAlbum sampleAlbum = null;
foreach (IAlbum album in Factory.LoadRootAlbumInstance(galleryId).GetChildGalleryObjects(GalleryObjectType.Album))
{
if (album.DirectoryName == "Samples")
{
sampleAlbum = album;
break;
}
}
if (sampleAlbum == null)
{
// Create sample album.
sampleAlbum = Factory.CreateEmptyAlbumInstance(galleryId);
sampleAlbum.Parent = Factory.LoadRootAlbumInstance(galleryId);
sampleAlbum.Title = "Samples";
sampleAlbum.DirectoryName = "Samples";
sampleAlbum.Summary = "Welcome to Gallery Server Pro!";
sampleAlbum.CreatedByUserName = "******";
sampleAlbum.DateAdded = currentTimestamp;
sampleAlbum.LastModifiedByUserName = "******";
sampleAlbum.DateLastModified = currentTimestamp;
sampleAlbum.Save();
}
// Look for sample image in sample album.
IGalleryObject sampleImage = null;
foreach (IGalleryObject image in sampleAlbum.GetChildGalleryObjects(GalleryObjectType.Image))
{
if (image.Original.FileName == Constants.SAMPLE_IMAGE_FILENAME)
{
sampleImage = image;
break;
}
}
if (sampleImage == null)
{
// Sample image not found. Pull image from assembly and save to disk (if needed), then create a media object from it.
string sampleDirPath = Path.Combine(Factory.LoadGallerySetting(galleryId).FullMediaObjectPath, sampleAlbum.DirectoryName);
string sampleImageFilepath = Path.Combine(sampleDirPath, Constants.SAMPLE_IMAGE_FILENAME);
if (!File.Exists(sampleImageFilepath))
{
Assembly asm = Assembly.GetExecutingAssembly();
using (Stream stream = asm.GetManifestResourceStream(String.Concat("GalleryServerPro.Web.gs.images.", Constants.SAMPLE_IMAGE_FILENAME)))
{
if (stream != null)
{
BinaryWriter bw = new BinaryWriter(File.Create(sampleImageFilepath));
byte[] buffer = new byte[stream.Length];
stream.Read(buffer, 0, (int)stream.Length);
bw.Write(buffer);
bw.Flush();
bw.Close();
}
}
}
if (File.Exists(sampleImageFilepath))
{
// Temporarily change a couple settings so that the thumbnail and compressed images are high quality.
IGallerySettings gallerySettings = Factory.LoadGallerySetting(galleryId);
int optTriggerSizeKb = gallerySettings.OptimizedImageTriggerSizeKb;
int thumbImageJpegQuality = gallerySettings.ThumbnailImageJpegQuality;
gallerySettings.ThumbnailImageJpegQuality = 95;
gallerySettings.OptimizedImageTriggerSizeKb = 200;
// Create the media object from the file.
IGalleryObject image = Factory.CreateImageInstance(new FileInfo(sampleImageFilepath), sampleAlbum);
image.Title = "Margaret, Skyler and Roger Martin (July 2010)";
image.CreatedByUserName = "******";
image.DateAdded = currentTimestamp;
image.LastModifiedByUserName = "******";
image.DateLastModified = currentTimestamp;
image.Save();
// Restore the default settings.
gallerySettings.OptimizedImageTriggerSizeKb = optTriggerSizeKb;
gallerySettings.ThumbnailImageJpegQuality = thumbImageJpegQuality;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="VideoThumbnailCreator"/> class.
/// </summary>
/// <param name="galleryObject">The gallery object.</param>
public VideoThumbnailCreator(IGalleryObject galleryObject)
{
GalleryObject = galleryObject;
}
/// <summary>
/// Initializes a new instance of the <see cref="VideoMetadataReadWriter" /> class.
/// </summary>
/// <param name="galleryObject">The gallery object.</param>
public VideoMetadataReadWriter(IGalleryObject galleryObject)
: base(galleryObject)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="GenericThumbnailCreator"/> class.
/// </summary>
/// <param name="galleryObject">The gallery object.</param>
public GenericThumbnailCreator(IGalleryObject galleryObject)
{
GalleryObject = galleryObject;
}
/// <summary>
/// Creates an instance of <see cref="CacheItemMedia" /> from <paramref name="go" />. This instance is suitable for storing in cache.
/// </summary>
/// <param name="go">The media object.</param>
/// <returns>An instance of <see cref="CacheItemMedia" />.</returns>
public static CacheItemMedia CreateFrom(IGalleryObject go)
{
return(new CacheItemMedia(go.Id, go.GalleryId, go.Parent.Id, CacheItemDisplayObject.CreateFrom(go.Thumbnail, go.Optimized, go.Original), go.GalleryObjectType, go.Sequence, go.DateAdded, CacheItemMetaItem.FromMetaItems(go.MetadataItems, go.Id, go.GalleryObjectType), go.CreatedByUserName, go.LastModifiedByUserName, go.DateLastModified, go.IsPrivate));
}
/// <summary>
/// Adds the uploaded files to the gallery. This method is called when the application is operating at lesss than full trust. In this case,
/// the ASP.NET FileUpload control is used. The logic is nearly identical to that in AddUploadedFilesForFullTrust - the only
/// differences are syntax differences arising from the different file upload control.
/// </summary>
private void AddUploadedFilesLessThanFullTrust()
{
// Clear the list of hash keys so we're starting with a fresh load from the data store.
try
{
MediaObjectHashKeys.Clear();
string albumPhysicalPath = this.GetAlbum().FullPhysicalPathOnDisk;
HelperFunctions.BeginTransaction();
for (int i = 0; i < 5; i++)
{
FileUpload file = (FileUpload)phUpload.FindControl("fuUpload" + i);
if (!file.HasFile)
{
continue;
}
if ((System.IO.Path.GetExtension(file.FileName).Equals(".zip", StringComparison.OrdinalIgnoreCase)) && (!chkDoNotExtractZipFile.Checked))
{
#region Extract the files from the zipped file.
// Extract the files from the zipped file.
using (ZipUtility zip = new ZipUtility(Util.UserName, RoleController.GetGalleryServerRolesForUser()))
{
this._skippedFiles.AddRange(zip.ExtractZipFile(file.FileContent, this.GetAlbum(), chkDiscardOriginalImage.Checked));
}
#endregion
}
else
{
#region Add the file
string filename = HelperFunctions.ValidateFileName(albumPhysicalPath, file.FileName);
string filepath = Path.Combine(albumPhysicalPath, filename);
#if DEBUG
TechInfoSystems.TracingTools.Tools.MarkSpot(string.Format(CultureInfo.CurrentCulture, "Attempting to move file {0} to {1}...", file.FileName, filepath));
#endif
file.SaveAs(filepath);
try
{
IGalleryObject go = Factory.CreateMediaObjectInstance(filepath, this.GetAlbum());
GalleryObjectController.SaveGalleryObject(go);
if ((chkDiscardOriginalImage.Checked) && (go is Business.Image))
{
((Business.Image)go).DeleteHiResImage();
GalleryObjectController.SaveGalleryObject(go);
}
}
catch (UnsupportedMediaObjectTypeException ex)
{
try
{
File.Delete(filepath);
}
catch (UnauthorizedAccessException) { } // Ignore an error; the file will end up getting deleted during cleanup maintenance
this._skippedFiles.Add(new KeyValuePair <string, string>(filename, ex.Message));
}
#endregion
}
}
HelperFunctions.CommitTransaction();
}
catch
{
HelperFunctions.RollbackTransaction();
throw;
}
finally
{
// Clear the list of hash keys to free up memory.
MediaObjectHashKeys.Clear();
HelperFunctions.PurgeCache();
}
}
/// <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));
}
private void SynchronizeMediaObjectFiles(DirectoryInfo directory, IAlbum album)
{
#region Parameter validation
if (album == null)
{
throw new ArgumentNullException("album");
}
if (directory.FullName != album.FullPhysicalPath)
{
throw new ArgumentException("Error in SynchronizeMediaObjectFiles().");
}
#endregion
//Update the media object table in the database with the file attributes of all
//files in the directory passed to this function. Skip any hidden files.
FileInfo[] files = directory.GetFiles();
// First sort by the filename.
Array.Sort <FileInfo>(files, delegate(FileInfo a, FileInfo b)
{
return(a.Name.CompareTo(b.Name));
});
foreach (FileInfo file in files)
{
if ((file.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden)
{
this._synchStatus.SkippedMediaObjects.Add(new KeyValuePair <string, string>(file.FullName.Remove(0, _mediaObjectPhysicalPathLength + 1), Resources.SynchronizationStatus_Hidden_File_Msg));
continue;
}
#region Process thumbnail or optimized image
if (file.Name.StartsWith(_thumbnailPrefix, StringComparison.OrdinalIgnoreCase))
{
// We have a thumbnail image. If we are storing thumbnails in a different directory, delete the file. The user may have just
// specified a new thumbnail path, and we need to delete all the previous thumbnails from their original location.
if (_thumbnailRootPath != AppSetting.Instance.MediaObjectPhysicalPath)
{
File.Delete(file.FullName);
}
continue;
}
if (file.Name.StartsWith(_optimizedPrefix, StringComparison.OrdinalIgnoreCase))
{
// We have an optimized image. If we are storing optimized images in a different directory, delete the file. The user may have
// just specified a new optimized path, and we need to delete all the previous optimized images from their original location.
if (_optimizedRootPath != AppSetting.Instance.MediaObjectPhysicalPath)
{
File.Delete(file.FullName);
}
continue;
}
#endregion
IGalleryObject mediaObject = null;
// See if this file is an existing media object. First look in the album's children. If not there, search the hash
// keys - maybe it was moved from another directory.
foreach (IGalleryObject existingMO in album.GetChildGalleryObjects(GalleryObjectType.MediaObject))
{
if (existingMO.Original.FileNamePhysicalPath == file.FullName)
{
mediaObject = existingMO;
break;
}
}
if ((mediaObject != null) || ((mediaObject == null) && this._mediaObjectsFromDataStore.TryGetValue(HelperFunctions.GetHashKey(file), out mediaObject)))
{
// Found an existing media object matching the file on disk. Update properties, but only if its file extension
// is enabled. (If this is a media object that had been added to Gallery Server but its file type was
// subsequently disabled, we do not want to synchronize it - we want its info in the data store to be deleted.)
if (HelperFunctions.IsFileAuthorizedForAddingToGallery(file.Name))
{
UpdateExistingMediaObject(album, mediaObject);
}
}
else
{
// No media object exists for this file. Create a new one.
CreateNewMediaObject(album, file);
}
int newFileIndex = this._synchStatus.CurrentFileIndex + 1;
if (newFileIndex < this._synchStatus.TotalFileCount)
{
UpdateStatus(newFileIndex, file.DirectoryName, file.Name);
}
if (this._synchStatus.ShouldTerminate)
{
this._synchStatus.ShouldTerminate = false;
throw new GalleryServerPro.ErrorHandler.CustomExceptions.SynchronizationTerminationRequestedException();
}
}
}
private void UpdateExistingMediaObject(IAlbum album, IGalleryObject mediaObject)
{
if (mediaObject.Parent.Id != album.Id)
{
mediaObject.Parent = album;
}
// If the generated hash key is the same as the one already assigned, then do nothing. Otherwise,
// generate a guaranteed unique hash key with the GetHashKeyUnique function.
if (mediaObject.Hashkey != HelperFunctions.GetHashKey(mediaObject.Original.FileInfo))
{
mediaObject.Hashkey = HelperFunctions.GetHashKeyUnique(mediaObject.Original.FileInfo);
}
// Check for existence of thumbnail.
if (!File.Exists(mediaObject.Thumbnail.FileNamePhysicalPath))
{
mediaObject.RegenerateThumbnailOnSave = true;
}
Image image = mediaObject as Image;
if (image != null)
{
EvaluateOriginalImage(image);
EvaluateOptimizedImage(image);
}
else
{
UpdateNonImageWidthAndHeight(mediaObject);
}
HelperFunctions.UpdateAuditFields(mediaObject, this._userName);
mediaObject.Save();
mediaObject.IsSynchronized = true;
}
public void RemoveGalleryObject(IGalleryObject galleryObject)
{
}
/// <summary>
/// Builds the syndication item from the <paramref name="galleryObject" /> and having the properties specified
/// in <paramref name="options" />.
/// </summary>
/// <param name="galleryObject">The gallery object.</param>
/// <param name="options">The options that direct the creation of HTML and URLs for a media object.</param>
/// <returns>An instance of <see cref="SyndicationItem" />.</returns>
private static SyndicationItem BuildSyndicationItem(IGalleryObject galleryObject, MediaObjectHtmlBuilderOptions options)
{
options.GalleryObject = galleryObject;
options.DisplayType = (galleryObject.GalleryObjectType == GalleryObjectType.External ? DisplayObjectType.External : DisplayObjectType.Optimized);
var moBuilder = new MediaObjectHtmlBuilder(options);
var pageUrl = moBuilder.GetPageUrl();
var content = GetGalleryObjectContent(galleryObject, pageUrl, moBuilder);
var item = new SyndicationItem(
RssEncode(HtmlValidator.RemoveHtml(galleryObject.Title, false)),
SyndicationContent.CreateHtmlContent(content),
new Uri(pageUrl),
galleryObject.Id.ToString(CultureInfo.InvariantCulture),
galleryObject.DateLastModified);
item.PublishDate = galleryObject.DateAdded;
item.Authors.Add(new SyndicationPerson() { Name = galleryObject.CreatedByUserName });
item.Categories.Add(new SyndicationCategory(galleryObject.GalleryObjectType.ToString()));
return item;
}
/// <summary>
/// Adds the <paramref name="zipContentFile"/> as a media object to the <paramref name="album"/>.
/// </summary>
/// <param name="zipContentFile">A reference to a file in a ZIP archive.</param>
/// <param name="album">The album to which the file should be added as a media object.</param>
/// // Sueetie Modified - passing i for single logging of action
private void AddMediaObjectToGallery(ZipEntry zipContentFile, IAlbum album, int i)
{
string zipFileName = Path.GetFileName(zipContentFile.Name).Trim();
if (zipFileName.Length == 0)
{
return;
}
string uniqueFilename = HelperFunctions.ValidateFileName(album.FullPhysicalPathOnDisk, zipFileName);
string uniqueFilepath = Path.Combine(album.FullPhysicalPathOnDisk, uniqueFilename);
// Extract the file from the zip stream and save as the specified filename.
ExtractFileFromZipStream(uniqueFilepath);
// Get the file we just saved to disk.
FileInfo mediaObjectFile = new FileInfo(uniqueFilepath);
try
{
IGalleryObject mediaObject = Factory.CreateMediaObjectInstance(mediaObjectFile, album);
HelperFunctions.UpdateAuditFields(mediaObject, this._userName);
// Sueetie Modified - Fixes a weird bug where zipped Image file titles are empty when zipped from my machine
if (mediaObject.Title.Trim().Length == 0)
{
mediaObject.Title = mediaObjectFile.Name;
}
mediaObject.Save();
if ((_discardOriginalImage) && (mediaObject is Business.Image))
{
((Business.Image)mediaObject).DeleteHiResImage();
mediaObject.Save();
}
// Sueetie Modified - Add mediaobject to Sueetie_Content - Single File
SueetieContent sueetieContent = new SueetieContent
{
SourceID = mediaObject.Id,
ContentTypeID = SueetieMedia.ConvertContentType((int)mediaObject.MimeType.TypeCategory),
ApplicationID = (int)SueetieApplications.Current.ApplicationID,
UserID = SueetieContext.Current.User.UserID,
IsRestricted = ((Album)mediaObject.Parent).IsPrivate,
Permalink = SueetieMedia.SueetieMediaObjectUrl(mediaObject.Id, mediaObject.GalleryId)
};
SueetieCommon.AddSueetieContent(sueetieContent);
// Add Sueetie-specific data to Sueetie_gs_MediaObject
SueetieMediaObject _sueetieMediaObject = new SueetieMediaObject();
_sueetieMediaObject.MediaObjectID = mediaObject.Id;
_sueetieMediaObject.ContentTypeID = SueetieMedia.ConvertContentType((int)mediaObject.MimeType.TypeCategory);
_sueetieMediaObject.AlbumID = mediaObject.Parent.Id;
_sueetieMediaObject.InDownloadReport = false;
SueetieMedia.CreateSueetieMediaObject(_sueetieMediaObject);
SueetieMediaAlbum sueetieAlbum = SueetieMedia.GetSueetieMediaAlbum(mediaObject.Parent.Id);
SueetieMediaGallery sueetieGallery = SueetieMedia.GetSueetieMediaGallery(((Album)mediaObject.Parent).GalleryId);
if (i == 0 && sueetieGallery.IsLogged)
{
SueetieLogs.LogUserEntry((UserLogCategoryType)sueetieAlbum.AlbumMediaCategoryID, sueetieAlbum.ContentID, SueetieContext.Current.User.UserID);
}
SueetieMedia.ClearMediaPhotoListCache(0);
SueetieMedia.ClearSueetieMediaObjectListCache(mediaObject.GalleryId);
}
catch (ErrorHandler.CustomExceptions.UnsupportedMediaObjectTypeException ex)
{
this._skippedFiles.Add(new KeyValuePair <string, string>(mediaObjectFile.Name, ex.Message));
File.Delete(mediaObjectFile.FullName);
}
}
public void Save(IGalleryObject mediaObject)
{
if (mediaObject == null)
{
throw new ArgumentNullException("mediaObject");
}
if (mediaObject.IsNew)
{
var moDto = new MediaObjectDto
{
FKAlbumId = mediaObject.Parent.Id,
ThumbnailFilename = mediaObject.Thumbnail.FileName,
ThumbnailWidth = mediaObject.Thumbnail.Width,
ThumbnailHeight = mediaObject.Thumbnail.Height,
ThumbnailSizeKB = mediaObject.Thumbnail.FileSizeKB,
OptimizedFilename = mediaObject.Optimized.FileName,
OptimizedWidth = mediaObject.Optimized.Width,
OptimizedHeight = mediaObject.Optimized.Height,
OptimizedSizeKB = mediaObject.Optimized.FileSizeKB,
OriginalFilename = mediaObject.Original.FileName,
OriginalWidth = mediaObject.Original.Width,
OriginalHeight = mediaObject.Original.Height,
OriginalSizeKB = mediaObject.Original.FileSizeKB,
ExternalHtmlSource = mediaObject.Original.ExternalHtmlSource,
ExternalType = (mediaObject.Original.ExternalType == MimeTypeCategory.NotSet ? String.Empty : mediaObject.Original.ExternalType.ToString()),
Seq = mediaObject.Sequence,
CreatedBy = mediaObject.CreatedByUserName,
DateAdded = mediaObject.DateAdded,
LastModifiedBy = mediaObject.LastModifiedByUserName,
DateLastModified = mediaObject.DateLastModified,
IsPrivate = mediaObject.IsPrivate
};
Add(moDto);
Save(); // Save now so we can get at the ID
if (mediaObject.Id != moDto.MediaObjectId)
{
mediaObject.Id = moDto.MediaObjectId;
}
// Insert metadata items, if any, into metadata table.
var repo = new MetadataRepository(Context); // Don't put in using construct because we don't want our Context disposed
repo.Save(mediaObject.MetadataItems);
}
else
{
MediaObjectDto moDto = Find(mediaObject.Id);
if (moDto != null)
{
moDto.FKAlbumId = mediaObject.Parent.Id;
moDto.ThumbnailFilename = mediaObject.Thumbnail.FileName;
moDto.ThumbnailWidth = mediaObject.Thumbnail.Width;
moDto.ThumbnailHeight = mediaObject.Thumbnail.Height;
moDto.ThumbnailSizeKB = mediaObject.Thumbnail.FileSizeKB;
moDto.OptimizedFilename = mediaObject.Optimized.FileName;
moDto.OptimizedWidth = mediaObject.Optimized.Width;
moDto.OptimizedHeight = mediaObject.Optimized.Height;
moDto.OptimizedSizeKB = mediaObject.Optimized.FileSizeKB;
moDto.OriginalFilename = mediaObject.Original.FileName;
moDto.OriginalWidth = mediaObject.Original.Width;
moDto.OriginalHeight = mediaObject.Original.Height;
moDto.OriginalSizeKB = mediaObject.Original.FileSizeKB;
moDto.ExternalHtmlSource = mediaObject.Original.ExternalHtmlSource;
moDto.ExternalType = (mediaObject.Original.ExternalType == MimeTypeCategory.NotSet ? String.Empty : mediaObject.Original.ExternalType.ToString());
moDto.Seq = mediaObject.Sequence;
moDto.CreatedBy = mediaObject.CreatedByUserName;
moDto.DateAdded = mediaObject.DateAdded;
moDto.LastModifiedBy = mediaObject.LastModifiedByUserName;
moDto.DateLastModified = mediaObject.DateLastModified;
moDto.IsPrivate = mediaObject.IsPrivate;
Save();
// Update metadata items, if necessary, in metadata table.
var repo = new MetadataRepository(Context); // Don't put in using construct because we don't want our Context disposed
repo.Save(mediaObject.MetadataItems);
}
}
}
