private int rotateImage()
{
// Rotate any images on the hard drive according to the user's wish.
int returnValue = int.MinValue;
Dictionary <int, RotateFlipType> imagesToRotate = retrieveUserSelections();
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.PurgeCache();
return(returnValue);
}
private bool AddExternalHtmlContent()
{
string externalHtmlSource = txtExternalHtmlSource.Text.Trim();
if (!this.ValidateExternalHtmlSource(externalHtmlSource))
{
return(false);
}
MimeTypeCategory mimeTypeCategory = MimeTypeCategory.Other;
string mimeTypeCategoryString = ddlMediaTypes.SelectedValue;
try
{
mimeTypeCategory = (MimeTypeCategory)Enum.Parse(typeof(MimeTypeCategory), mimeTypeCategoryString, true);
}
catch { } // Suppress any parse errors so that category remains the default value 'Other'.
string title = txtTitle.Text.Trim();
if (String.IsNullOrEmpty(title))
{
// If user didn't enter a title, use the media category (e.g. Video, Audio, Image, Other).
title = mimeTypeCategory.ToString();
}
IGalleryObject mediaObject = Factory.CreateExternalMediaObjectInstance(externalHtmlSource, mimeTypeCategory, this.GetAlbum());
mediaObject.Title = Utils.CleanHtmlTags(title, GalleryId);
GalleryObjectController.SaveGalleryObject(mediaObject);
HelperFunctions.PurgeCache();
return(true);
}
private bool btnOkClicked()
{
//User clicked 'Delete images'. Delete the hi-res images for the selected albums and images.
string[] selectedItems = RetrieveUserSelections();
if (selectedItems.Length == 0)
{
// No images were selected. Inform user and exit function.
string msg = String.Format(CultureInfo.CurrentCulture, "<p class='gsp_msgwarning'><span class='gsp_bold'>{0} </span>{1}</p>", Resources.GalleryServerPro.Task_No_Objects_Selected_Hdr, Resources.GalleryServerPro.Task_No_Objects_Selected_Dtl);
phMsg.Controls.Clear();
phMsg.Controls.Add(new System.Web.UI.LiteralControl(msg));
return(false);
}
try
{
HelperFunctions.BeginTransaction();
// Convert the string array of IDs to integers. Also assign whether each is an album or media object.
// (Determined by the first character of each id's string: a=album; m=media object)
foreach (string selectedItem in selectedItems)
{
int id = Convert.ToInt32(selectedItem.Substring(1), CultureInfo.InvariantCulture);
char idType = Convert.ToChar(selectedItem.Substring(0, 1), CultureInfo.InvariantCulture); // 'a' or 'm'
if (idType == 'm')
{
Image image;
try
{
image = (Image)Factory.LoadMediaObjectInstance(id, GalleryObjectType.Image, true);
}
catch (InvalidMediaObjectException)
{
continue; // Image may have been deleted by someone else, so just skip it.
}
image.DeleteHiResImage();
GalleryObjectController.SaveGalleryObject(image);
}
if (idType == 'a')
{
DeleteHiResImagesFromAlbum(Factory.LoadAlbumInstance(id, true, true));
}
}
HelperFunctions.CommitTransaction();
}
catch
{
HelperFunctions.RollbackTransaction();
throw;
}
HelperFunctions.PurgeCache();
return(true);
}
public string UpdateMediaObjectTitle(int mediaObjectId, string title)
{
try
{
IGalleryObject mo = Factory.LoadMediaObjectInstance(mediaObjectId);
if (GalleryPage.IsUserAuthorized(SecurityActions.EditMediaObject, mo.Parent.Id))
{
string previousTitle = mo.Title;
mo.Title = Util.CleanHtmlTags(title);
if (mo.Title != previousTitle)
{
GalleryObjectController.SaveGalleryObject(mo);
}
HelperFunctions.PurgeCache();
}
return(mo.Title);
}
catch (Exception ex)
{
AppErrorController.LogError(ex);
throw;
}
}
private int btnOkClicked()
{
//User clicked 'Create album'. Create the new album and return the new album ID.
var parentAlbum = Factory.LoadAlbumInstance(tvUC.SelectedAlbum.Id, true, true);
this.CheckUserSecurity(SecurityActions.AddChildAlbum, parentAlbum);
int newAlbumId;
if (parentAlbum.Id > 0)
{
IAlbum newAlbum = Factory.CreateEmptyAlbumInstance(parentAlbum.GalleryId);
newAlbum.Title = Utils.CleanHtmlTags(txtTitle.Text.Trim(), GalleryId);
//newAlbum.ThumbnailMediaObjectId = 0; // not needed
newAlbum.Parent = parentAlbum;
newAlbum.IsPrivate = parentAlbum.IsPrivate;
GalleryObjectController.SaveGalleryObject(newAlbum);
newAlbumId = newAlbum.Id;
// Re-sort the items in the album. This will put the media object in the right position relative to its neighbors.
((IAlbum)newAlbum.Parent).Sort(true, Utils.UserName);
HelperFunctions.PurgeCache();
}
else
{
throw new GalleryServerPro.Events.CustomExceptions.InvalidAlbumException(parentAlbum.Id);
}
return(newAlbumId);
}
private int btnOkClicked()
{
//User clicked 'Create album'. Create the new album and return the new album ID.
TreeViewNode selectedNode = tvUC.SelectedNode;
int parentAlbumID = Int32.Parse(selectedNode.Value, CultureInfo.InvariantCulture);
IAlbum parentAlbum = Factory.LoadAlbumInstance(parentAlbumID, false);
this.CheckUserSecurity(SecurityActions.AddChildAlbum, parentAlbum);
int newAlbumID;
if (parentAlbumID > 0)
{
IAlbum newAlbum = Factory.CreateAlbumInstance();
newAlbum.Title = GetAlbumTitle();
//newAlbum.ThumbnailMediaObjectId = 0; // not needed
newAlbum.Parent = parentAlbum;
newAlbum.IsPrivate = (parentAlbum.IsPrivate ? true : chkIsPrivate.Checked);
GalleryObjectController.SaveGalleryObject(newAlbum);
newAlbumID = newAlbum.Id;
HelperFunctions.PurgeCache();
}
else
{
throw new GalleryServerPro.ErrorHandler.CustomExceptions.InvalidAlbumException(parentAlbumID);
}
return(newAlbumID);
}
private int RotateImage()
{
// Rotate any images on the hard drive according to the user's wish.
int returnValue = int.MinValue;
var imagesToRotate = RetrieveUserSelections();
foreach (var kvp in imagesToRotate)
{
var mo = Factory.LoadMediaObjectInstance(kvp.Key, true);
IGalleryObjectMetadataItem metaOrientation;
if (kvp.Value == MediaObjectRotation.Rotate0 && !mo.MetadataItems.TryGetMetadataItem(MetadataItemName.Orientation, out metaOrientation))
{
continue;
}
mo.Rotation = kvp.Value;
try
{
GalleryObjectController.SaveGalleryObject(mo);
}
catch (UnsupportedImageTypeException)
{
returnValue = (int)MessageType.CannotRotateInvalidImage;
}
}
HelperFunctions.PurgeCache();
return(returnValue);
}
/// <summary>
/// Updates the root album title so that it no longer contains the message about creating an admin account.
/// </summary>
private void UpdateRootAlbumTitleAfterAdminCreation()
{
var album = Factory.LoadRootAlbumInstance(GalleryId, true, true);
album.Caption = Resources.GalleryServerPro.Site_Welcome_Msg;
GalleryObjectController.SaveGalleryObject(album);
}
private Message saveCaptions()
{
// Iterate through all the textboxes, saving any captions that have changed.
// The media object IDs are stored in a hidden input tag.
HtmlTextArea ta;
HtmlInputHidden gc;
IGalleryObject mo;
string newTitle, previousTitle;
Message msg = Message.None;
int maxTitleLength = GalleryServerPro.Configuration.ConfigManager.GetGalleryServerProConfigSection().DataStore.MediaObjectTitleLength;
if (!IsUserAuthorized(SecurityActions.EditMediaObject))
{
return(msg);
}
try
{
HelperFunctions.BeginTransaction();
// Loop through each item in the repeater control. If an item is checked, extract the ID.
foreach (RepeaterItem rptrItem in rptr.Items)
{
ta = (HtmlTextArea)rptrItem.Controls[1]; // The <TEXTAREA> tag
gc = (HtmlInputHidden)rptrItem.Controls[3]; // The hidden <input> tag
// Retrieve new title. Since the Value property of <TEXTAREA> HTML ENCODEs the text,
// and we want to store the actual text, we must decode to get back to the original.
newTitle = Util.HtmlDecode(ta.Value);
mo = Factory.LoadMediaObjectInstance(Convert.ToInt32(gc.Value, CultureInfo.InvariantCulture));
previousTitle = mo.Title;
mo.Title = Util.CleanHtmlTags(newTitle);
if (mo.Title.Length > maxTitleLength)
{
// This caption exceeds the maximum allowed length. Set message ID so that user
// can be notified. This caption will be truncated when saved to the databse.
msg = Message.OneOrMoreCaptionsExceededMaxLength;
}
if (mo.Title != previousTitle)
{
GalleryObjectController.SaveGalleryObject(mo);
}
}
HelperFunctions.CommitTransaction();
}
catch
{
HelperFunctions.RollbackTransaction();
throw;
}
HelperFunctions.PurgeCache();
return(msg);
}
private void SaveCaptions()
{
// Iterate through all the textboxes, saving any captions that have changed.
// The media object IDs are stored in a hidden input tag.
HtmlTextArea ta;
HtmlInputHidden gc;
IGalleryObject mo;
if (!IsUserAuthorized(SecurityActions.EditMediaObject))
{
return;
}
try
{
HelperFunctions.BeginTransaction();
// Loop through each item in the repeater control. If an item is checked, extract the ID.
foreach (RepeaterItem rptrItem in rptr.Items)
{
ta = (HtmlTextArea)rptrItem.Controls[1]; // The <TEXTAREA> tag
gc = (HtmlInputHidden)rptrItem.Controls[3]; // The hidden <input> tag
// Retrieve new title. Since the Value property of <TEXTAREA> HTML ENCODEs the text,
// and we want to store the actual text, we must decode to get back to the original.
string newTitle = Utils.HtmlDecode(ta.Value);
try
{
mo = Factory.LoadMediaObjectInstance(Convert.ToInt32(gc.Value, CultureInfo.InvariantCulture), true);
}
catch (InvalidMediaObjectException)
{
continue; // Gallery object may have been deleted by someone else, so just skip it.
}
string previousTitle = mo.Title;
mo.Title = Utils.CleanHtmlTags(newTitle, GalleryId);
if (mo.Title != previousTitle)
{
GalleryObjectController.SaveGalleryObject(mo);
}
}
HelperFunctions.CommitTransaction();
}
catch
{
HelperFunctions.RollbackTransaction();
throw;
}
HelperFunctions.PurgeCache();
}
/// <summary>
/// Updates the root album title so that it no longer contains the message about creating an admin account.
/// </summary>
private void UpdateRootAlbumTitleAfterAdminCreation()
{
var rootAlbum = Factory.LoadRootAlbumInstance(GalleryId, true);
var updateableRootAlbum = Factory.LoadAlbumInstance(new AlbumLoadOptions(rootAlbum.Id)
{
IsWritable = true
});
updateableRootAlbum.Caption = Resources.GalleryServer.Site_Welcome_Msg;
GalleryObjectController.SaveGalleryObject(updateableRootAlbum);
}
private void btnOkClicked()
{
//User clicked 'Assign thumbnail'. Assign the specified thumbnail to this album.
int moid = getSelectedMediaObjectID();
IAlbum album = this.GetAlbum();
album.ThumbnailMediaObjectId = moid;
GalleryObjectController.SaveGalleryObject(album);
HelperFunctions.PurgeCache();
}
private int RotateImages()
{
// Rotate any images on the hard drive according to the user's wish.
var returnValue = int.MinValue;
var imagesToRotate = RetrieveUserSelections();
try
{
HelperFunctions.BeginTransaction();
foreach (var kvp in imagesToRotate)
{
IGalleryObject mo;
try
{
mo = Factory.LoadMediaObjectInstance(kvp.Key, true);
}
catch (InvalidMediaObjectException)
{
continue; // Image may have been deleted by someone else, so just skip it.
}
IGalleryObjectMetadataItem metaOrientation;
if (kvp.Value == MediaObjectRotation.Rotate0 && !mo.MetadataItems.TryGetMetadataItem(MetadataItemName.Orientation, out metaOrientation))
{
continue;
}
mo.Rotation = kvp.Value;
try
{
GalleryObjectController.SaveGalleryObject(mo);
}
catch (UnsupportedImageTypeException)
{
returnValue = (int)MessageType.CannotRotateInvalidImage;
}
}
HelperFunctions.CommitTransaction();
}
catch
{
HelperFunctions.RollbackTransaction();
throw;
}
HelperFunctions.PurgeCache();
return(returnValue);
}
private void btnOkClicked()
{
object formFieldGalleryObjectIds = Request.Form["goIds"];
if ((formFieldGalleryObjectIds == null) || (String.IsNullOrEmpty(formFieldGalleryObjectIds.ToString())))
{
// The hidden field will be empty when no changes have been made. Just return.
return;
}
string strGoIds = formFieldGalleryObjectIds.ToString();
string[] goIds = strGoIds.Split(new char[] { ',' });
// User wants to persist the reordering changes to the data store. As the user has been dragging and dropping objects
// in their new locations, server-side code has been keeping the CurrentSequences property synchronized with the order
// of the objects in the user's browser. Now we want to loop through those objects and update the Sequence property
// of each one according to it's position within the list.
IGalleryObjectCollection galleryObjects = this.GetAlbum().GetChildGalleryObjects(true);
int newSequence = 0;
try
{
HelperFunctions.BeginTransaction();
foreach (string galleryObjectIdentifier in goIds)
{
// Parse the string into its 2 parts: (a) The first character is either "a" (for album) or "m" (for media object);
// (b) The rest of the string is the ID for the album of media object. Ex: "a132" is an album with ID=132.
GalleryObjectType galleryObjectType = (galleryObjectIdentifier.Substring(0, 1) == "a" ? GalleryObjectType.Album : GalleryObjectType.MediaObject);
int galleryObjectId = Convert.ToInt32(galleryObjectIdentifier.Substring(1), CultureInfo.InvariantCulture);
IGalleryObject matchingGalleryObject = galleryObjects.FindById(galleryObjectId, galleryObjectType);
if ((matchingGalleryObject != null) && (matchingGalleryObject.Sequence != newSequence))
{
matchingGalleryObject.Sequence = newSequence;
GalleryObjectController.SaveGalleryObject(matchingGalleryObject);
}
newSequence++;
}
HelperFunctions.CommitTransaction();
}
catch
{
HelperFunctions.RollbackTransaction();
throw;
}
HelperFunctions.PurgeCache();
}
/// <summary>
/// Persists the media item to the data store. The current implementation requires that
/// an existing item exist in the data store.
/// </summary>
/// <param name="mediaItem">An instance of <see cref="Entity.MediaItem"/> to persist to the data
/// store.</param>
/// <exception cref="System.Web.Http.HttpResponseException"></exception>
public ActionResult PutMediaItem(Entity.MediaItem mediaItem)
{
try
{
var mo = Factory.LoadMediaObjectInstance(mediaItem.Id, true);
var isUserAuthorized = Utils.IsUserAuthorized(SecurityActions.EditMediaObject, mo.Parent.Id, mo.GalleryId, mo.IsPrivate, ((IAlbum)mo.Parent).IsVirtualAlbum);
if (!isUserAuthorized)
{
AppEventController.LogEvent(String.Format(CultureInfo.InvariantCulture, "Unauthorized access detected. The security system prevented a user from editing media object {0}.", mo.Id), mo.GalleryId, EventType.Warning);
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Forbidden));
}
mo.Title = mediaItem.Title;
GalleryObjectController.SaveGalleryObject(mo);
HelperFunctions.PurgeCache();
return(new ActionResult
{
Status = ActionResultStatus.Success.ToString(),
Title = String.Empty,
Message = String.Empty,
ActionTarget = mediaItem
});
}
catch (InvalidMediaObjectException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotFound)
{
Content = new StringContent(String.Format("Could not find media item with ID = {0}", mediaItem.Id)),
ReasonPhrase = "Media Object Not Found"
});
}
catch (HttpResponseException)
{
throw; // Rethrow, since we've already logged it above
}
catch (Exception ex)
{
AppEventController.LogError(ex);
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = Utils.GetExStringContent(ex),
ReasonPhrase = "Server Error"
});
}
}
private static void DeleteOriginalFilesFromAlbum(IAlbum album)
{
// Delete the original file for each item in the album. Then recursively do the same thing to all child albums.
foreach (IGalleryObject mediaObject in album.GetChildGalleryObjects(GalleryObjectType.MediaObject))
{
mediaObject.DeleteOriginalFile();
GalleryObjectController.SaveGalleryObject(mediaObject);
}
foreach (IAlbum childAlbum in album.GetChildGalleryObjects(GalleryObjectType.Album))
{
DeleteOriginalFilesFromAlbum(childAlbum);
}
}
private void UpdateSortOnExistingAlbumsAsync()
{
var rootAlbumId = Factory.LoadRootAlbumInstance(GalleryId).Id;
var rootAlbum = Factory.LoadAlbumInstance(new AlbumLoadOptions(rootAlbumId)
{
IsWritable = true
});
rootAlbum.SortByMetaName = GallerySettingsUpdateable.DefaultAlbumSortMetaName;
rootAlbum.SortAscending = GallerySettingsUpdateable.DefaultAlbumSortAscending;
GalleryObjectController.SaveGalleryObject(rootAlbum);
rootAlbum.SortAsync(true, Utils.UserName, true, true);
}
private static void DeleteHiResImagesFromAlbum(IAlbum album)
{
// Delete the hi-res image for each image in the album. Then recursively do the same thing to all child albums.
foreach (GalleryServerPro.Business.Image image in album.GetChildGalleryObjects(GalleryObjectType.Image))
{
image.DeleteHiResImage();
GalleryObjectController.SaveGalleryObject(image);
}
foreach (IAlbum childAlbum in album.GetChildGalleryObjects(GalleryObjectType.Album))
{
DeleteHiResImagesFromAlbum(childAlbum);
}
}
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;
try
{
image = Factory.LoadMediaObjectInstance(kvp.Key, GalleryObjectType.Image, true);
}
catch (InvalidMediaObjectException)
{
continue; // Image may have been deleted by someone else, so just skip it.
}
image.Rotation = kvp.Value;
try
{
GalleryObjectController.SaveGalleryObject(image);
}
catch (UnsupportedImageTypeException)
{
returnValue = (int)Message.CannotRotateInvalidImage;
}
}
HelperFunctions.CommitTransaction();
}
catch
{
HelperFunctions.RollbackTransaction();
throw;
}
HelperFunctions.PurgeCache();
return(returnValue);
}
/// <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, 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);
file.SaveAs(filepath);
try
{
IGalleryObject go = Factory.CreateMediaObjectInstance(filepath, this.GetAlbum());
// Sueetie Modified - Fix Blank Title on individual uploads
if (go.Title.Trim().Length == 0)
{
go.Title = go.Original.FileName;
}
GalleryObjectController.SaveGalleryObject(go);
if ((chkDiscardOriginalImage.Checked) && (go is Business.Image))
{
((Business.Image)go).DeleteHiResImage();
GalleryObjectController.SaveGalleryObject(go);
}
// Sueetie Modified - Add mediaobject to Sueetie_Content - Single File
SueetieContent sueetieContent = new SueetieContent
{
SourceID = go.Id,
ContentTypeID = MediaHelper.ConvertContentType(go.MimeType.TypeCategory),
ApplicationID = (int)SueetieApplications.Current.ApplicationID,
UserID = CurrentSueetieUserID,
IsRestricted = this.GetAlbum().IsPrivate,
Permalink = MediaHelper.SueetieMediaObjectUrl(go.Id, this.GalleryId)
};
SueetieCommon.AddSueetieContent(sueetieContent);
// Add Sueetie-specific data to Sueetie_gs_MediaObject
SueetieMediaObject _sueetieMediaObject = new SueetieMediaObject();
_sueetieMediaObject.MediaObjectID = go.Id;
_sueetieMediaObject.ContentTypeID = MediaHelper.ConvertContentType(go.MimeType.TypeCategory);
_sueetieMediaObject.AlbumID = this.GetAlbum().Id;
_sueetieMediaObject.InDownloadReport = false;
SueetieMedia.CreateSueetieMediaObject(_sueetieMediaObject);
SueetieMediaAlbum sueetieAlbum = SueetieMedia.GetSueetieMediaAlbum(this.GetAlbum().Id);
if (CurrentSueetieGallery.IsLogged)
{
SueetieLogs.LogUserEntry((UserLogCategoryType)sueetieAlbum.AlbumMediaCategoryID, sueetieAlbum.ContentID, CurrentSueetieUserID);
}
SueetieMedia.ClearMediaPhotoListCache(0);
SueetieMedia.ClearSueetieMediaObjectListCache(this.CurrentSueetieGalleryID);
}
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();
}
}
private Message saveCaptions()
{
// Iterate through all the textboxes, saving any captions that have changed.
// The media object IDs are stored in a hidden input tag.
HtmlInputText ta;
HtmlTextArea tdesc;
HtmlInputHidden gc;
IGalleryObject mo;
string newTitle, previousTitle, previousTags, previousDescription;
Message msg = Message.None;
if (!IsUserAuthorized(SecurityActions.EditMediaObject))
{
return(msg);
}
try
{
HelperFunctions.BeginTransaction();
// Loop through each item in the repeater control. If an item is checked, extract the ID.
foreach (RepeaterItem rptrItem in rptr.Items)
{
ta = (HtmlInputText)rptrItem.Controls[1]; // The <input TEXT> tag
tdesc = (HtmlTextArea)rptrItem.Controls[3]; // The <TEXTAREA> tag
gc = (HtmlInputHidden)rptrItem.Controls[5]; // The hidden <input> tag
// Retrieve new title. Since the Value property of <TEXTAREA> HTML ENCODEs the text,
// and we want to store the actual text, we must decode to get back to the original.
newTitle = Util.HtmlDecode(ta.Value);
mo = Factory.LoadMediaObjectInstance(Convert.ToInt32(gc.Value, CultureInfo.InvariantCulture), true);
previousTitle = mo.Title;
mo.Title = Util.RemoveHtmlTags(newTitle);
if (mo.Title != previousTitle)
{
GalleryObjectController.SaveGalleryObject(mo);
}
SueetieMediaObject _sueetieMediaObject = SueetieMedia.GetSueetieMediaObject(CurrentSueetieGalleryID, mo.Id);
previousDescription = _sueetieMediaObject.MediaObjectDescription;
_sueetieMediaObject.MediaObjectDescription = tdesc.Value;
if (_sueetieMediaObject.MediaObjectTitle != newTitle || _sueetieMediaObject.MediaObjectDescription != previousDescription)
{
SueetieMedia.UpdateSueetieMediaObject(_sueetieMediaObject);
}
}
HelperFunctions.CommitTransaction();
}
catch
{
HelperFunctions.RollbackTransaction();
throw;
}
HelperFunctions.PurgeCache();
SueetieMedia.ClearSueetieMediaObjectListCache(CurrentSueetieGalleryID);
return(msg);
}
/// <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>
/// 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();
}
}
private int btnOkClicked()
{
//User clicked 'Create album'. Create the new album and return the new album ID.
TreeViewNode selectedNode = tvUC.SelectedNode;
int parentAlbumID = Int32.Parse(selectedNode.Value, CultureInfo.InvariantCulture);
IAlbum parentAlbum = Factory.LoadAlbumInstance(parentAlbumID, false);
this.CheckUserSecurity(SecurityActions.AddChildAlbum, parentAlbum);
int newAlbumID;
if (parentAlbumID > 0)
{
IAlbum newAlbum = Factory.CreateEmptyAlbumInstance(parentAlbum.GalleryId);
newAlbum.Title = GetAlbumTitle();
//newAlbum.ThumbnailMediaObjectId = 0; // not needed
newAlbum.Parent = parentAlbum;
newAlbum.IsPrivate = (parentAlbum.IsPrivate ? true : chkIsPrivate.Checked);
GalleryObjectController.SaveGalleryObject(newAlbum);
newAlbumID = newAlbum.Id;
// Sueetie Modified - Save New Album to Sueetie_Content, Sueetie_gs_Album and log it in User Activity Log
string grpString = string.Empty;
if (SueetieApplications.Current.IsGroup)
{
grpString = "/" + SueetieApplications.Current.GroupKey;
}
string albumUrl = grpString + "/" + SueetieApplications.Current.ApplicationKey + "/" + CurrentSueetieGallery.GalleryKey + ".aspx?aid=" + newAlbumID.ToString();
SueetieContent sueetieContent = new SueetieContent
{
SourceID = newAlbumID,
ContentTypeID = int.Parse(ddSueetieAlbumType.SelectedValue),
ApplicationID = (int)SueetieApplications.Current.ApplicationID,
UserID = CurrentSueetieUserID,
IsRestricted = newAlbum.IsPrivate,
Permalink = albumUrl,
};
int contentID = SueetieCommon.AddSueetieContent(sueetieContent);
var albumLogCategory = SueetieMedia.GetAlbumContentTypeDescriptionList().Single(contentDescription => contentDescription.ContentTypeID.Equals(sueetieContent.ContentTypeID));
UserLogEntry entry = new UserLogEntry
{
UserLogCategoryID = albumLogCategory.UserLogCategoryID,
ItemID = contentID,
UserID = CurrentSueetieUserID,
};
if (CurrentSueetieGallery.IsLogged)
{
SueetieLogs.LogUserEntry(entry);
}
string albumPath = SueetieMedia.CreateSueetieAlbumPath(newAlbum.FullPhysicalPath);
SueetieMedia.CreateSueetieAlbum(newAlbumID, albumPath, sueetieContent.ContentTypeID);
SueetieMedia.ClearSueetieMediaAlbumListCache(CurrentSueetieGalleryID);
SueetieMedia.ClearSueetieMediaGalleryListCache();
HelperFunctions.PurgeCache();
}
else
{
throw new GalleryServerPro.ErrorHandler.CustomExceptions.InvalidAlbumException(parentAlbumID);
}
return(newAlbumID);
}
/// <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, 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.
}
}
// Sueetie Modified - Add contents of ZIP file - All
List <SueetieMediaObject> sueetieMediaObjects = SueetieMedia.GetSueetieMediaUpdateList(this.GetAlbumId());
int i = 0;
foreach (SueetieMediaObject _sueetieMediaObject in sueetieMediaObjects)
{
int _moid = _sueetieMediaObject.MediaObjectID;
IGalleryObject mo = Factory.LoadMediaObjectInstance(_moid);
SueetieContent sueetieContent = new SueetieContent
{
SourceID = _sueetieMediaObject.MediaObjectID,
ContentTypeID = MediaHelper.ConvertContentType(mo.MimeType.TypeCategory),
ApplicationID = (int)SueetieApplications.Current.ApplicationID,
UserID = _sueetieMediaObject.SueetieUserID,
DateTimeCreated = mo.DateAdded,
IsRestricted = mo.IsPrivate,
Permalink = MediaHelper.SueetieMediaObjectUrl(_moid, this.GalleryId)
};
// Add Sueetie-specific data to Sueetie_gs_MediaObject
_sueetieMediaObject.ContentTypeID = MediaHelper.ConvertContentType(mo.MimeType.TypeCategory);
_sueetieMediaObject.AlbumID = this.GetAlbum().Id;
_sueetieMediaObject.InDownloadReport = false;
SueetieMedia.CreateSueetieMediaObject(_sueetieMediaObject);
SueetieCommon.AddSueetieContent(sueetieContent);
i++;
}
#endregion
}
else
{
#region Add the file
string filename = HelperFunctions.ValidateFileName(albumPhysicalPath, file.FileName);
string filepath = Path.Combine(albumPhysicalPath, filename);
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);
}
// Sueetie Modified - Add mediaobject to Sueetie_Content - Single File
SueetieContent sueetieContent = new SueetieContent
{
SourceID = go.Id,
ContentTypeID = MediaHelper.ConvertContentType(go.MimeType.TypeCategory),
ApplicationID = (int)SueetieApplications.Current.ApplicationID,
UserID = CurrentSueetieUserID,
IsRestricted = this.GetAlbum().IsPrivate,
Permalink = MediaHelper.SueetieMediaObjectUrl(go.Id, this.GalleryId)
};
SueetieCommon.AddSueetieContent(sueetieContent);
// Add Sueetie-specific data to Sueetie_gs_MediaObject
SueetieMediaObject _sueetieMediaObject = new SueetieMediaObject();
_sueetieMediaObject.MediaObjectID = go.Id;
_sueetieMediaObject.ContentTypeID = MediaHelper.ConvertContentType(go.MimeType.TypeCategory);
_sueetieMediaObject.AlbumID = this.GetAlbum().Id;
_sueetieMediaObject.InDownloadReport = false;
SueetieMedia.CreateSueetieMediaObject(_sueetieMediaObject);
SueetieMediaAlbum sueetieAlbum = SueetieMedia.GetSueetieMediaAlbum(this.GetAlbum().Id);
if (CurrentSueetieGallery.IsLogged)
{
SueetieLogs.LogUserEntry((UserLogCategoryType)sueetieAlbum.AlbumMediaCategoryID, sueetieAlbum.ContentID, CurrentSueetieUserID);
}
}
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
}
}
SueetieMedia.ClearMediaPhotoListCache(0);
SueetieMedia.ClearSueetieMediaObjectListCache(this.CurrentSueetieGalleryID);
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();
}
}