Merge with default

1 files changed, 70 insertions, 114 deletions

diff --git a/MediaBrowser.Api/HttpHandlers/ImageHandler.cs b/MediaBrowser.Api/HttpHandlers/ImageHandler.cs
index f73f783af..4aa367fb7 100644
--- a/MediaBrowser.Api/HttpHandlers/ImageHandler.cs
+++ b/MediaBrowser.Api/HttpHandlers/ImageHandler.cs
@@ -1,13 +1,12 @@
-using MediaBrowser.Common.Logging;

-using MediaBrowser.Common.Net;

+using MediaBrowser.Common.Net;

 using MediaBrowser.Common.Net.Handlers;

 using MediaBrowser.Controller;

+using MediaBrowser.Controller.Drawing;

 using MediaBrowser.Controller.Entities;

 using MediaBrowser.Model.Entities;

 using System;

 using System.ComponentModel.Composition;

 using System.IO;

-using System.Linq;

 using System.Net;

 using System.Threading.Tasks;

 

@@ -20,8 +19,9 @@ namespace MediaBrowser.Api.HttpHandlers
         {

             return ApiService.IsApiUrlMatch("image", request);

         }

-        

+

         private string _imagePath;

+

         private async Task<string> GetImagePath()

         {

             _imagePath = _imagePath ?? await DiscoverImagePath();

@@ -29,119 +29,99 @@ namespace MediaBrowser.Api.HttpHandlers
             return _imagePath;

         }

 

-        private async Task<string> DiscoverImagePath()

-        {

-            string personName = QueryString["personname"];

-

-            if (!string.IsNullOrEmpty(personName))

-            {

-                return (await Kernel.Instance.ItemController.GetPerson(personName).ConfigureAwait(false)).PrimaryImagePath;

-            }

-

-            string genreName = QueryString["genre"];

-

-            if (!string.IsNullOrEmpty(genreName))

-            {

-                return (await Kernel.Instance.ItemController.GetGenre(genreName).ConfigureAwait(false)).PrimaryImagePath;

-            }

-

-            string year = QueryString["year"];

-

-            if (!string.IsNullOrEmpty(year))

-            {

-                return (await Kernel.Instance.ItemController.GetYear(int.Parse(year)).ConfigureAwait(false)).PrimaryImagePath;

-            }

-

-            string studio = QueryString["studio"];

-

-            if (!string.IsNullOrEmpty(studio))

-            {

-                return (await Kernel.Instance.ItemController.GetStudio(studio).ConfigureAwait(false)).PrimaryImagePath;

-            }

-

-            string userId = QueryString["userid"];

-

-            if (!string.IsNullOrEmpty(userId))

-            {

-                return ApiService.GetUserById(userId, false).PrimaryImagePath;

-            }

-

-            BaseItem item = ApiService.GetItemById(QueryString["id"]);

-

-            string imageIndex = QueryString["index"];

-            int index = string.IsNullOrEmpty(imageIndex) ? 0 : int.Parse(imageIndex);

-

-            return GetImagePathFromTypes(item, ImageType, index);

-        }

-

-        private Stream _sourceStream;

-        private async Task<Stream> GetSourceStream()

-        {

-            await EnsureSourceStream().ConfigureAwait(false);

-            return _sourceStream;

-        }

+        private BaseEntity _sourceEntity;

 

-        private bool _sourceStreamEnsured;

-        private async Task EnsureSourceStream()

+        private async Task<BaseEntity> GetSourceEntity()

         {

-            if (!_sourceStreamEnsured)

+            if (_sourceEntity == null)

             {

-                try

+                if (!string.IsNullOrEmpty(QueryString["personname"]))

                 {

-                    _sourceStream = File.OpenRead(await GetImagePath().ConfigureAwait(false));

+                    _sourceEntity =

+                        await Kernel.Instance.ItemController.GetPerson(QueryString["personname"]).ConfigureAwait(false);

                 }

-                catch (FileNotFoundException ex)

+

+                else if (!string.IsNullOrEmpty(QueryString["genre"]))

                 {

-                    StatusCode = 404;

-                    Logger.LogException(ex);

+                    _sourceEntity =

+                        await Kernel.Instance.ItemController.GetGenre(QueryString["genre"]).ConfigureAwait(false);

                 }

-                catch (DirectoryNotFoundException ex)

+

+                else if (!string.IsNullOrEmpty(QueryString["year"]))

                 {

-                    StatusCode = 404;

-                    Logger.LogException(ex);

+                    _sourceEntity =

+                        await

+                        Kernel.Instance.ItemController.GetYear(int.Parse(QueryString["year"])).ConfigureAwait(false);

                 }

-                catch (UnauthorizedAccessException ex)

+

+                else if (!string.IsNullOrEmpty(QueryString["studio"]))

                 {

-                    StatusCode = 403;

-                    Logger.LogException(ex);

+                    _sourceEntity =

+                        await Kernel.Instance.ItemController.GetStudio(QueryString["studio"]).ConfigureAwait(false);

                 }

-                finally

+

+                else if (!string.IsNullOrEmpty(QueryString["userid"]))

                 {

-                    _sourceStreamEnsured = true;

+                    _sourceEntity = ApiService.GetUserById(QueryString["userid"], false);

+                }

+

+                else

+                {

+                    _sourceEntity = ApiService.GetItemById(QueryString["id"]);

                 }

             }

+

+            return _sourceEntity;

         }

 

-        public async override Task<string> GetContentType()

+        private async Task<string> DiscoverImagePath()

         {

-            await EnsureSourceStream().ConfigureAwait(false);

+            var entity = await GetSourceEntity().ConfigureAwait(false);

+

+            return ImageProcessor.GetImagePath(entity, ImageType, ImageIndex);

+        }

+

+        protected async override Task<ResponseInfo> GetResponseInfo()

+        {

+            string path = await GetImagePath().ConfigureAwait(false);

+

+            ResponseInfo info = new ResponseInfo

+            {

+                CacheDuration = TimeSpan.FromDays(365),

+                ContentType = MimeTypes.GetMimeType(path)

+            };

 

-            if (await GetSourceStream().ConfigureAwait(false) == null)

+            DateTime? date = File.GetLastWriteTimeUtc(path);

+

+            // If the file does not exist it will return jan 1, 1601

+            // http://msdn.microsoft.com/en-us/library/system.io.file.getlastwritetimeutc.aspx

+            if (date.Value.Year == 1601)

             {

-                return null;

+                if (!File.Exists(path))

+                {

+                    info.StatusCode = 404;

+                    date = null;

+                }

             }

 

-            return MimeTypes.GetMimeType(await GetImagePath().ConfigureAwait(false));

+            info.DateLastModified = date;

+

+            return info;

         }

 

-        public override TimeSpan CacheDuration

+        private int ImageIndex

         {

             get

             {

-                return TimeSpan.FromDays(365);

-            }

-        }

+                string val = QueryString["index"];

 

-        protected async override Task<DateTime?> GetLastDateModified()

-        {

-            await EnsureSourceStream().ConfigureAwait(false);

+                if (string.IsNullOrEmpty(val))

+                {

+                    return 0;

+                }

 

-            if (await GetSourceStream().ConfigureAwait(false) == null)

-            {

-                return null;

+                return int.Parse(val);

             }

-

-            return File.GetLastWriteTimeUtc(await GetImagePath().ConfigureAwait(false));

         }

 

         private int? Height

@@ -236,33 +216,9 @@ namespace MediaBrowser.Api.HttpHandlers
 

         protected override async Task WriteResponseToOutputStream(Stream stream)

         {

-            ImageProcessor.ProcessImage(await GetSourceStream().ConfigureAwait(false), stream, Width, Height, MaxWidth, MaxHeight, Quality);

-        }

-

-        private string GetImagePathFromTypes(BaseItem item, ImageType imageType, int imageIndex)

-        {

-            if (imageType == ImageType.Logo)

-            {

-                return item.LogoImagePath;

-            }

-            if (imageType == ImageType.Backdrop)

-            {

-                return item.BackdropImagePaths.ElementAt(imageIndex);

-            }

-            if (imageType == ImageType.Banner)

-            {

-                return item.BannerImagePath;

-            }

-            if (imageType == ImageType.Art)

-            {

-                return item.ArtImagePath;

-            }

-            if (imageType == ImageType.Thumbnail)

-            {

-                return item.ThumbnailImagePath;

-            }

+            var entity = await GetSourceEntity().ConfigureAwait(false);

 

-            return item.PrimaryImagePath;

+            ImageProcessor.ProcessImage(entity, ImageType, ImageIndex, stream, Width, Height, MaxWidth, MaxHeight, Quality);

         }

     }

 }