public HttpResponseMessage Delete(string userName)
{
// DELETE /api/users
try
{
// Don't need to check security here because we'll do that in RoleController.DeleteGalleryServerProRole.
UserController.DeleteGalleryServerProUser(userName, true);
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(String.Format(CultureInfo.CurrentCulture, "User '{0}' has been deleted", Utils.HtmlEncode(userName)))
});
}
catch (GallerySecurityException ex)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Forbidden)
{
Content = new StringContent(ex.Message),
ReasonPhrase = "Action Forbidden"
});
}
catch (Exception ex)
{
AppEventController.LogError(ex);
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = Utils.GetExStringContent(ex),
ReasonPhrase = "Server Error"
});
}
}
public async Task <IActionResult> Delete(int id)
{
try
{
await _albumController.DeleteAlbum(id);
return(Ok($"Album {id} deleted..."));
}
catch (InvalidAlbumException)
{
// HTTP specification says the DELETE method must be idempotent, so deleting a nonexistent item must have
// the same effect as deleting an existing one. So we simply return HttpStatusCode.OK.
return(Ok($"Album with ID {id} does not exist."));
}
catch (GallerySecurityException ex)
{
AppEventController.LogError(ex);
return(Forbid());
}
catch (CannotDeleteAlbumException ex)
{
AppEventController.LogError(ex);
return(Forbid());
}
catch (Exception ex)
{
AppEventController.LogError(ex);
return(StatusCode(500, _exController.GetExString(ex)));
}
}
public Entity.User Get(string userName, int galleryId)
{
// GET /api/users/getbyusername?userName=Admin&galleryId=1
try
{
return(UserController.GetUserEntity(userName, galleryId));
}
catch (GallerySecurityException)
{
// This is thrown when the current user does not have view and edit permission to the requested user.
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Forbidden));
}
catch (InvalidUserException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotFound)
{
Content = new StringContent(String.Format("User '{0}' does not exist", userName)),
ReasonPhrase = "User Not Found"
});
}
catch (Exception ex)
{
AppEventController.LogError(ex);
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = Utils.GetExStringContent(ex),
ReasonPhrase = "Server Error"
});
}
}
/// <summary>
/// Initializes the request.
/// </summary>
/// <param name="context">The HTTP context.</param>
/// <returns>
/// Returns <c>true</c> when the method succeeds; otherwise <c>false</c>.
/// </returns>
public override bool InitializeRequest(HttpContext context)
{
bool isSuccessfullyInitialized = false;
try
{
if (!GalleryController.IsInitialized)
{
GalleryController.InitializeGspApplication();
}
if (InitializeVariables(context))
{
isSuccessfullyInitialized = true;
}
else
{
_context.Response.StatusCode = 404;
}
return(base.InitializeRequest(context) & isSuccessfullyInitialized);
}
catch (System.Threading.ThreadAbortException)
{
throw; // We don't want these to fall into the generic catch because we don't want them logged.
}
catch (Exception ex)
{
AppEventController.LogError(ex);
}
return(isSuccessfullyInitialized);
}
/// <summary>
/// Enables processing of HTTP Web requests by a custom HttpHandler that implements the <see cref="T:System.Web.IHttpHandler"/> interface.
/// </summary>
/// <param name="context">An <see cref="T:System.Web.HttpContext"/> object that provides references to the intrinsic server objects (for example, Request, Response, Session, and Server) used to service HTTP requests.</param>
public void ProcessRequest(HttpContext context)
{
try
{
if (!GalleryController.IsInitialized)
{
GalleryController.InitializeGspApplication();
}
if (InitializeVariables(context))
{
string tvXml = GenerateTreeviewJson();
context.Response.ContentType = "text/json";
context.Response.Cache.SetCacheability(HttpCacheability.NoCache); // Needed for IE 7
context.Response.Write(tvXml);
}
else
{
context.Response.End();
}
}
catch (System.Threading.ThreadAbortException)
{
throw; // We don't want these to fall into the generic catch because we don't want them logged.
}
catch (Exception ex)
{
AppEventController.LogError(ex);
throw;
}
}
public IQueryable <Entity.MediaItem> GetMediaItemsForAlbumId(int id, int sortByMetaNameId = int.MinValue, bool sortAscending = true)
{
// GET /api/albums/12/mediaitems - Gets media items for album #12
try
{
return(Controller.GalleryObjectController.GetMediaItemsInAlbum(id, (MetadataItemName)sortByMetaNameId, sortAscending));
}
catch (InvalidAlbumException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotFound)
{
Content = new StringContent(String.Format("Could not find album with ID = {0}", id)),
ReasonPhrase = "Album Not Found"
});
}
catch (GallerySecurityException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Forbidden));
}
catch (Exception ex)
{
AppEventController.LogError(ex);
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = Utils.GetExStringContent(ex),
ReasonPhrase = "Server Error"
});
}
}
/// <summary>
/// Gets the album with the specified <paramref name="id" />. The properties
/// <see cref="Entity.Album.GalleryItems" /> and <see cref="Entity.Album.MediaItems" />
/// are set to null to keep the instance small. Example: api/albums/4/
/// </summary>
/// <param name="id">The album ID.</param>
/// <returns>An instance of <see cref="Entity.Album" />.</returns>
/// <exception cref="System.Web.Http.HttpResponseException"></exception>
public Entity.Album Get(int id)
{
IAlbum album = null;
try
{
album = AlbumController.LoadAlbumInstance(id, true);
SecurityManager.ThrowIfUserNotAuthorized(SecurityActions.ViewAlbumOrMediaObject, RoleController.GetGalleryServerRolesForUser(), album.Id, album.GalleryId, Utils.IsAuthenticated, album.IsPrivate, album.IsVirtualAlbum);
var permissionsEntity = new Entity.Permissions();
return(AlbumController.ToAlbumEntity(album, permissionsEntity, new Entity.GalleryDataLoadOptions()));
}
catch (InvalidAlbumException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotFound)
{
Content = new StringContent(String.Format("Could not find album with ID = {0}", id)),
ReasonPhrase = "Album Not Found"
});
}
catch (GallerySecurityException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Forbidden));
}
catch (Exception ex)
{
AppEventController.LogError(ex, (album != null ? album.GalleryId : new int?()));
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = Utils.GetExStringContent(ex),
ReasonPhrase = "Server Error"
});
}
}
public ActionResult PrepareZipDownload(Entity.GalleryItem[] galleryItems, DisplayObjectType mediaSize)
{
try
{
return(AlbumController.PrepareZipDownload(galleryItems, mediaSize));
}
catch (GallerySecurityException ex)
{
AppEventController.LogError(ex);
return(new ActionResult
{
Title = "Cannot Download",
Status = ActionResultStatus.Warning.ToString(),
Message = ex.Message
});
}
catch (Exception ex)
{
AppEventController.LogError(ex);
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = Utils.GetExStringContent(ex),
ReasonPhrase = "Server Error"
});
}
}
/// <summary>
/// Gets a JSON string representing the tags used in the specified gallery. The JSON can be used as the
/// data source for the jsTree jQuery widget. Only tags the current user has permission to view are
/// included. The tag tree has a root node containing a single level of tags. Throws an exception when
/// the application is not running an Enterprise License.
/// </summary>
/// <param name="galleryId">The gallery ID.</param>
/// <param name="top">The number of tags to return. Values less than zero are treated the same as zero,
/// meaning no tags will be returned. Specify <see cref="int.MaxValue" /> to return all tags.</param>
/// <param name="sortBy">The property to sort the tags by. Specify "count" to sort by tag frequency or
/// "value" to sort by tag name. When not specified, defaults to "count".</param>
/// <param name="sortAscending">Specifies whether to sort the tags in ascending order. Specify <c>true</c>
/// for ascending order or <c>false</c> for descending order. When not specified, defaults to <c>false</c>.</param>
/// <param name="expanded">if set to <c>true</c> the tree is configured to display in an expanded form.</param>
/// <returns>System.String.</returns>
/// <exception cref="System.Web.Http.HttpResponseException">Thrown when an error occurs.</exception>
public string GetTagTreeAsJson(int galleryId, int top = int.MaxValue, string sortBy = "count", bool sortAscending = false, bool expanded = false)
{
try
{
ValidateEnterpriseLicense();
TagSearchOptions.TagProperty sortProperty;
if (!Enum.TryParse(sortBy, true, out sortProperty))
{
sortProperty = TagSearchOptions.TagProperty.NotSpecified;
}
return(MetadataController.GetTagTreeAsJson(TagSearchType.TagsUserCanView, galleryId, top, sortProperty, sortAscending, expanded));
}
catch (GallerySecurityException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Forbidden));
}
catch (Exception ex)
{
AppEventController.LogError(ex);
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = Utils.GetExStringContent(ex),
ReasonPhrase = "Server Error"
});
}
}
public Entity.GalleryData GetInflatedMediaObject(int id)
{
try
{
IGalleryObject mediaObject = Factory.LoadMediaObjectInstance(id);
return(GalleryController.GetGalleryDataForMediaObject(mediaObject, (IAlbum)mediaObject.Parent, new Entity.GalleryDataLoadOptions {
LoadMediaItems = true
}));
}
catch (InvalidMediaObjectException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotFound)
{
Content = new StringContent(String.Format("Could not find media object with ID = {0}", id)),
ReasonPhrase = "Media Object Not Found"
});
}
catch (GallerySecurityException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Forbidden));
}
catch (Exception ex)
{
AppEventController.LogError(ex);
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = Utils.GetExStringContent(ex),
ReasonPhrase = "Server Error"
});
}
}
/// <summary>
/// Gets the media object with the specified <paramref name="id" />.
/// Example: api/mediaitems/4/get
/// </summary>
/// <param name="id">The media object ID.</param>
/// <returns>An instance of <see cref="Entity.MediaItem" />.</returns>
/// <exception cref="System.Web.Http.HttpResponseException">Thrown when the media object is not found, the user
/// doesn't have permission to view it, or some other error occurs.</exception>
public Entity.MediaItem Get(int id)
{
try
{
IGalleryObject mediaObject = Factory.LoadMediaObjectInstance(id);
SecurityManager.ThrowIfUserNotAuthorized(SecurityActions.ViewAlbumOrMediaObject, RoleController.GetGalleryServerRolesForUser(), mediaObject.Parent.Id, mediaObject.GalleryId, Utils.IsAuthenticated, mediaObject.Parent.IsPrivate, ((IAlbum)mediaObject.Parent).IsVirtualAlbum);
var siblings = mediaObject.Parent.GetChildGalleryObjects(GalleryObjectType.MediaObject, !Utils.IsAuthenticated).ToSortedList();
int mediaObjectIndex = siblings.IndexOf(mediaObject);
return(GalleryObjectController.ToMediaItem(mediaObject, mediaObjectIndex + 1, MediaObjectHtmlBuilder.GetMediaObjectHtmlBuilderOptions(mediaObject)));
}
catch (InvalidMediaObjectException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotFound)
{
Content = new StringContent(String.Format("Could not find media object with ID = {0}", id)),
ReasonPhrase = "Media Object Not Found"
});
}
catch (GallerySecurityException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Forbidden));
}
catch (Exception ex)
{
AppEventController.LogError(ex);
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = Utils.GetExStringContent(ex),
ReasonPhrase = "Server Error"
});
}
}
public async Task <IActionResult> ReplaceMediaAssetFile(int mediaAssetId, string fileNameOnServer, string fileName)
{
try
{
var filePath = Path.Combine(AppSetting.Instance.ContentRootPath, GlobalConstants.TempUploadDirectory, fileNameOnServer);
return(new JsonResult(await _galleryObjectController.ReplaceMediaAssetFile(mediaAssetId, filePath, fileName)));
}
catch (InvalidMediaObjectException ex)
{
return(new JsonResult(new Business.ActionResult()
{
Status = ActionResultStatus.Error.ToString(),
Title = "Cannot Edit Media Asset",
Message = ex.Message
}));
}
catch (GallerySecurityException ex)
{
return(new JsonResult(new Business.ActionResult()
{
Status = ActionResultStatus.Error.ToString(),
Title = "Cannot Replace Media Asset",
Message = ex.Message
}));
}
catch (Exception ex)
{
AppEventController.LogError(ex);
return(StatusCode(500, _exController.GetExString(ex)));
}
}
public IAlbum GetByPeople(string q, int sortByMetaNameId = int.MinValue, bool sortAscending = true, string destinationUrl = null, string filter = "all", int galleryId = int.MinValue)
{
IAlbum album = null;
try
{
album = GalleryObjectController.GetGalleryObjectsHavingTags(null, Utils.ToArray(q), GalleryObjectTypeEnumHelper.Parse(filter, GalleryObjectType.All), ValidateGallery(galleryId));
album.FeedFormatterOptions = new FeedFormatterOptions()
{
SortByMetaName = (MetadataItemName)sortByMetaNameId,
SortAscending = sortAscending,
DestinationUrl = String.IsNullOrWhiteSpace(destinationUrl) ? String.Concat(Utils.AppRoot, "/") : destinationUrl
};
return(album);
}
catch (GallerySecurityException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Forbidden));
}
catch (Exception ex)
{
AppEventController.LogError(ex, (album != null ? album.GalleryId : new int?()));
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = Utils.GetExStringContent(ex),
ReasonPhrase = "Server Error"
});
}
}
public IActionResult PutGalleryItemMeta(Entity.GalleryItemMeta galleryItemMeta)
{
// PUT /api/galleryitemmeta
try
{
_metadataController.SaveGalleryItemMeta(galleryItemMeta);
if (galleryItemMeta.ActionResult == null)
{
galleryItemMeta.ActionResult = new Business.ActionResult()
{
Status = ActionResultStatus.Success.ToString(),
Title = "Save successful"
};
}
}
catch (GallerySecurityException)
{
return(Forbid());
}
catch (Exception ex)
{
AppEventController.LogError(ex);
return(StatusCode(500, _exController.GetExString(ex)));
}
return(Ok(galleryItemMeta));
}
public IActionResult GetInflatedMediaObject(int id)
{
try
{
var mediaObject = Factory.LoadMediaObjectInstance(id);
return(new JsonResult(_galleryController.GetGalleryDataForMediaObject(mediaObject, (IAlbum)mediaObject.Parent, new Entity.GalleryDataLoadOptions {
LoadMediaItems = true
})));
}
catch (InvalidMediaObjectException)
{
return(NotFound("Media Asset Not Found: Could not find media object with ID {id}."));
}
catch (GallerySecurityException)
{
return(Forbid());
}
catch (Exception ex)
{
AppEventController.LogError(ex);
return(StatusCode(500, _exController.GetExString(ex)));
}
}
public async Task <IActionResult> DeleteGalleryItemMeta(Entity.GalleryItemMeta galleryItemMeta)
{
// DELETE /api/galleryitemmeta
try
{
var mType = (MetadataItemName)galleryItemMeta.MetaItem.MTypeId;
if (mType == MetadataItemName.Tags || mType == MetadataItemName.People)
{
await _metadataController.DeleteTag(galleryItemMeta);
}
else
{
await _metadataController.Delete(galleryItemMeta);
}
return(Ok("Meta item deleted..."));
}
catch (GallerySecurityException)
{
return(Forbid());
}
catch (Exception ex)
{
AppEventController.LogError(ex);
return(StatusCode(500, _exController.GetExString(ex)));
}
}
/// <summary>
/// Updates the gallery items with the specified metadata value. <see cref="Entity.GalleryItemMeta.ActionResult" />
/// contains details about the success or failure of the operation.
/// </summary>
/// <param name="galleryItemMeta">An instance of <see cref="Entity.GalleryItemMeta" /> that defines
/// the tag value to be added and the gallery items it is to be added to. It is expected that only
/// the MTypeId and Value properties of <see cref="Entity.GalleryItemMeta.MetaItem" /> are populated.</param>
/// <returns>An instance of <see cref="Entity.GalleryItemMeta" />.</returns>
/// <exception cref="System.Web.Http.HttpResponseException">Thrown when the current user does not have permission
/// to carry out the operation or an internal server error occurs.</exception>
public Entity.GalleryItemMeta PutGalleryItemMeta(Entity.GalleryItemMeta galleryItemMeta)
{
// /api/galleryitemmeta
try
{
MetadataController.SaveGalleryItemMeta(galleryItemMeta);
if (galleryItemMeta.ActionResult == null)
{
galleryItemMeta.ActionResult = new ActionResult()
{
Status = ActionResultStatus.Success.ToString(),
Title = "Save successful"
};
}
}
catch (GallerySecurityException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Forbidden));
}
catch (Exception ex)
{
AppEventController.LogError(ex);
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = Utils.GetExStringContent(ex),
ReasonPhrase = "Server Error"
});
}
return(galleryItemMeta);
}
/// <summary>
/// Deletes the meta tag value from the specified gallery items.
/// </summary>
/// <param name="galleryItemMeta">An instance of <see cref="Entity.GalleryItemMeta" /> that defines
/// the tag value to be added and the gallery items it is to be added to.</param>
/// <returns><see cref="HttpResponseMessage" />.</returns>
/// <exception cref="System.Web.Http.HttpResponseException"></exception>
public HttpResponseMessage DeleteGalleryItemMeta(Entity.GalleryItemMeta galleryItemMeta)
{
// /api/galleryitemmeta
try
{
var mType = (MetadataItemName)galleryItemMeta.MetaItem.MTypeId;
if (mType == MetadataItemName.Tags || mType == MetadataItemName.People)
{
MetadataController.DeleteTag(galleryItemMeta);
}
else
{
MetadataController.Delete(galleryItemMeta);
}
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("Meta item deleted...")
});
}
catch (GallerySecurityException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Forbidden));
}
catch (Exception ex)
{
AppEventController.LogError(ex);
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = Utils.GetExStringContent(ex),
ReasonPhrase = "Server Error"
});
}
}
public void Sort(int id, int sortByMetaNameId, bool sortAscending)
{
try
{
AlbumController.Sort(id, sortByMetaNameId, sortAscending);
}
catch (InvalidAlbumException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotFound)
{
Content = new StringContent(String.Format("Could not find album with ID = {0}", id)),
ReasonPhrase = "Album Not Found"
});
}
catch (GallerySecurityException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Forbidden));
}
catch (Exception ex)
{
AppEventController.LogError(ex);
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = Utils.GetExStringContent(ex),
ReasonPhrase = "Server Error"
});
}
}
public async Task <IActionResult> Get(int id)
{
// GET /api/mediaitems/get/4
try
{
//var settings = new AddMediaObjectSettings { AlbumId = 2, CurrentUserName = "******", DiscardOriginalFile = false, FileName = "Desert.jpg", FileNameOnServer = "Desert.jpg" };
//var results = await _galleryObjectController.AddMediaObject(settings);
IGalleryObject mediaObject = Factory.LoadMediaObjectInstance(id);
SecurityManager.ThrowIfUserNotAuthorized(SecurityActions.ViewAlbumOrMediaObject, await _userController.GetGalleryServerRolesForUser(), mediaObject.Parent.Id, mediaObject.GalleryId, _userController.IsAuthenticated, mediaObject.Parent.IsPrivate, ((IAlbum)mediaObject.Parent).IsVirtualAlbum);
var siblings = mediaObject.Parent.GetChildGalleryObjects(GalleryObjectType.MediaObject, !_userController.IsAuthenticated).ToSortedList();
int mediaObjectIndex = siblings.IndexOf(mediaObject);
return(new JsonResult(_galleryObjectController.ToMediaItem(mediaObject, mediaObjectIndex + 1, _htmlController.GetMediaObjectHtmlBuilderOptions(mediaObject))));
}
catch (InvalidMediaObjectException)
{
return(NotFound($"Could not find media object with ID {id}"));
}
catch (GallerySecurityException)
{
return(Forbid());
}
catch (Exception ex)
{
AppEventController.LogError(ex);
return(StatusCode(500, _exController.GetExString(ex)));
}
}
public IQueryable <Entity.GalleryItem> Sort(Entity.AlbumAction albumAction)
{
// POST /api/albums/getsortedalbum -
try
{
return(GalleryObjectController.SortGalleryItems(albumAction));
}
catch (InvalidAlbumException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotFound)
{
Content = new StringContent(String.Format("Could not find album with ID = {0}", albumAction.Album.Id)),
ReasonPhrase = "Album Not Found"
});
}
catch (GallerySecurityException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Forbidden));
}
catch (Exception ex)
{
AppEventController.LogError(ex);
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = Utils.GetExStringContent(ex),
ReasonPhrase = "Server Error"
});
}
}
private void Gallery_Error(object sender, EventArgs e)
{
// Grab a handle to the exception that is giving us grief.
Exception ex = Server.GetLastError();
if (Context != null)
{
ex = Context.Error;
}
if (ex != null)
{
try
{
if (GalleryId > int.MinValue)
{
AppEventController.HandleGalleryException(ex, GalleryId);
}
else
{
AppEventController.HandleGalleryException(ex);
}
Utils.PerformMaintenance(); // This might fix errors like missing/corrupt records in the database.
}
catch { }
}
}
public IAlbum GetByRating(string rating, int top = 50, int sortByMetaNameId = (int)MetadataItemName.DateAdded, bool sortAscending = false, string destinationUrl = null, string filter = "mediaobject", int galleryId = int.MinValue)
{
IAlbum album = null;
try
{
album = GalleryObjectController.GetRatedMediaObjects(rating, top, ValidateGallery(galleryId), GalleryObjectTypeEnumHelper.Parse(filter, GalleryObjectType.MediaObject));
album.FeedFormatterOptions = new FeedFormatterOptions()
{
SortByMetaName = (MetadataItemName)sortByMetaNameId,
SortAscending = sortAscending,
DestinationUrl = String.IsNullOrWhiteSpace(destinationUrl) ? String.Concat(Utils.AppRoot, "/") : destinationUrl
};
return(album);
}
catch (GallerySecurityException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Forbidden));
}
catch (Exception ex)
{
AppEventController.LogError(ex, (album != null ? album.GalleryId : new int?()));
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = Utils.GetExStringContent(ex),
ReasonPhrase = "Server Error"
});
}
}
private void Gallery_Error(object sender, EventArgs e)
{
// Grab a handle to the exception that is giving us grief.
Exception ex = Server.GetLastError();
if (Context != null)
{
ex = Context.Error;
}
if (ex != null)
{
try
{
if (GalleryId > int.MinValue)
{
AppEventController.HandleGalleryException(ex, GalleryId);
}
else
{
AppEventController.HandleGalleryException(ex);
}
}
catch { }
}
}
public IQueryable <Entity.MetaItem> GetMetaItemsForMediaObjectId(int id)
{
// GET /api/mediaitems/12/meta - Gets metadata items for media object #12
try
{
return(GalleryObjectController.GetMetaItemsForMediaObject(id).AsQueryable());
}
catch (InvalidMediaObjectException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotFound)
{
Content = new StringContent(String.Format("Could not find media object with ID = {0}", id)),
ReasonPhrase = "Media Object Not Found"
});
}
catch (GallerySecurityException)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Forbidden));
}
catch (Exception ex)
{
AppEventController.LogError(ex);
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = Utils.GetExStringContent(ex),
ReasonPhrase = "Server Error"
});
}
}
private Stream GetWatermarkedImageStream()
{
Image watermarkedImage = null;
try
{
try
{
watermarkedImage = ImageHelper.AddWatermark(MediaObjectFilePath, MediaObject.GalleryId);
}
catch (Exception ex)
{
// Can't apply watermark to image. Substitute an error image and send that to the user.
if (!(ex is FileNotFoundException))
{
// Don't log FileNotFoundException exceptions. This helps avoid clogging the error log
// with entries caused by search engine retrieving media objects that have been moved or deleted.
AppEventController.LogError(ex);
}
watermarkedImage = Image.FromFile(_context.Request.MapPath(String.Concat(Utils.SkinPath, "/images/error-xl.png")));
}
MemoryStream stream = new MemoryStream();
watermarkedImage.Save(stream, ImageFormat.Jpeg);
return(stream);
}
finally
{
if (watermarkedImage != null)
{
watermarkedImage.Dispose();
}
}
}
private static void LogUploadZipFileResults(List <ActionResult> results, AddMediaObjectSettings settings)
{
var isSuccessful = results.All(r => r.Status == ActionResultStatus.Success.ToString());
int? galleryId = null;
IAlbum album = null;
try
{
album = Factory.LoadAlbumInstance(settings.AlbumId);
galleryId = album.GalleryId;
}
catch (InvalidAlbumException) { }
if (isSuccessful)
{
AppEventController.LogEvent(String.Format(CultureInfo.InvariantCulture, "{0} files were successfully extracted from the file '{1}' and added to album '{2}'.", results.Count, settings.FileName, album != null ? album.Title : "<Unknown>"), galleryId);
return;
}
// If we get here at least one of the results was an info, warning, error, etc.
var succesfulResults = results.Where(m => m.Status == ActionResultStatus.Success.ToString());
var unsuccesfulResults = results.Where(m => m.Status != ActionResultStatus.Success.ToString());
var msg = String.Format(CultureInfo.InvariantCulture, "{0} items in the uploaded file '{1}' were added to the gallery, but {2} files were skipped. Review the details for additional information. The file was uploaded by user {3}.", succesfulResults.Count(), settings.FileName, unsuccesfulResults.Count(), settings.CurrentUserName);
var ex = new UnsupportedMediaObjectTypeException(msg, null);
var i = 1;
foreach (var result in unsuccesfulResults)
{
ex.Data.Add("File " + i++, String.Format(CultureInfo.InvariantCulture, "{0}: {1}", result.Title, result.Message));
}
AppEventController.LogError(ex, galleryId);
}
public async Task <IActionResult> PutMetaItem(Entity.MetaItem metaItem)
{
try
{
return(new JsonResult(await _metadataController.Save(metaItem)));
}
catch (InvalidAlbumException)
{
return(NotFound($"Could not find album with ID {metaItem.MediaId}"));
}
catch (InvalidMediaObjectException)
{
return(NotFound($"Media Asset/Metadata Item Not Found: One of the following errors occurred: (1) Could not find meta item with ID {metaItem.Id} (2) Could not find media asset with ID {metaItem.MediaId}"));
}
catch (GallerySecurityException)
{
return(Forbid());
}
catch (Exception ex)
{
AppEventController.LogError(ex);
return(StatusCode(500, _exController.GetExString(ex)));
}
}
public IActionResult Delete(int id)
{
// DELETE /api/events/delete/12
IEvent appEvent = null;
try
{
appEvent = Factory.GetAppEvents().FindById(id);
if (appEvent == null)
{
// HTTP specification says the DELETE method must be idempotent, so deleting a nonexistent item must have
// the same effect as deleting an existing one. So we simply return HttpStatusCode.OK.
return(Ok(string.Format("Event with ID {0} does not exist.", id)));
//return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(String.Format("Event with ID = {0} does not exist.", id)) };
}
//var isAuthorized = true;
//// If the event has a non-template gallery ID (not all do), then check the user's permission. For those errors without a gallery ID,
//// just assume the user has permission, because there is no way to verify the user can delete this event. We could do something
//// that mostly works like verifying the user is a gallery admin for at least one gallery, but the function we are trying to
//// protect is deleting an event message, which is not that important to worry about.
//if (appEvent.GalleryId != GalleryController.GetTemplateGalleryId())
//{
// isAuthorized = Utils.IsUserAuthorized(SecurityActions.AdministerSite | SecurityActions.AdministerGallery, RoleController.GetGalleryServerRolesForUser(), int.MinValue, appEvent.GalleryId, false, false);
//}
//if (isAuthorized)
//{
Events.EventController.Delete(id);
CacheController.RemoveCache(CacheItem.AppEvents);
return(Ok("Event deleted..."));
//return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent("Event deleted...") };
//}
//else
//{
// throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Forbidden));
//}
}
catch (Exception ex)
{
if (appEvent != null)
{
AppEventController.LogError(ex, appEvent.GalleryId);
}
else
{
AppEventController.LogError(ex);
}
return(StatusCode(500, _exController.GetExString(ex)));
//throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
//{
// Content = Utils.GetExStringContent(ex),
// ReasonPhrase = "Server Error"
//});
}
}
/// <summary>
/// Moves or copies the <paramref name="itemsToTransfer" /> to the <paramref name="destinationAlbumId" />.
/// </summary>
/// <param name="destinationAlbumId">The ID of the destination album.</param>
/// <param name="itemsToTransfer">The items to transfer.</param>
/// <param name="transferType">Type of the transfer.</param>
/// <returns>An instance of <see cref="IActionResult" />.</returns>
private IActionResult TransferTo(int destinationAlbumId, Entity.GalleryItem[] itemsToTransfer, GalleryAssetTransferType transferType)
{
try
{
//TODO: Need to implement TransferToAlbum()
var destinationAlbum = _albumController.TransferToAlbum(destinationAlbumId, itemsToTransfer, transferType, out var createdGalleryItems);
return(new JsonResult(new Business.ActionResult()
{
Status = ActionResultStatus.Success.ToString(),
Title = $"{transferType} Successful",
Message = "The items were transferred.",
ActionTarget = createdGalleryItems
}));
}
catch (GallerySecurityException)
{
return(new JsonResult(new Business.ActionResult()
{
Status = ActionResultStatus.Error.ToString(),
Title = "Transfer Aborted - Invalid Selection",
Message = "You do not have permission to move or copy media assets to the selected album or you selected an album in a read-only gallery. Review your selection."
}));
}
catch (InvalidAlbumException ex)
{
return(new JsonResult(new Business.ActionResult()
{
Status = ActionResultStatus.Error.ToString(),
Title = "Transfer Aborted - Invalid Selection",
Message = ex.Message
}));
}
catch (CannotTransferAlbumToNestedDirectoryException ex)
{
return(new JsonResult(new Business.ActionResult()
{
Status = ActionResultStatus.Error.ToString(),
Title = "Transfer Aborted - Invalid Selection",
Message = ex.Message
}));
}
catch (UnsupportedMediaObjectTypeException ex)
{
return(new JsonResult(new Business.ActionResult()
{
Status = ActionResultStatus.Error.ToString(),
Title = "Transfer Aborted - Disabled File Type",
Message = $"One or more media assets you selected is a disabled file type ({System.IO.Path.GetExtension(ex.MediaObjectFilePath)}). An administrator can enable this file type on the File Types page."
}));
}
catch (Exception ex)
{
AppEventController.LogError(ex);
return(StatusCode(500, _exController.GetExString(ex)));
}
}