gistfile1.txt

namespace Custom.Web.Areas.Website.Controllers
{
    using System;
    using System.Drawing;
    using System.IO;
    using System.Web.Mvc;

    using Sitecore;
    using Sitecore.Data;
    using Sitecore.Data.Fields;
    using Sitecore.Data.Items;
    using Sitecore.Data.Managers;
    using Sitecore.Diagnostics;
    using Sitecore.Globalization;
    using Sitecore.Odg;
    using Sitecore.Odg.Controllers;
    using Sitecore.PrintStudio.PublishingEngine;
    using Sitecore.PrintStudio.PublishingEngine.Helpers;
    using Sitecore.Resources.Media;
    using Sitecore.SecurityModel;

    /// <summary>All code taken from <see cref="Sitecore.Odg.Controllers.DesignController"/></summary>
    public partial class CustomDesignController : DesignController
    {
        /// <summary>Maximum width of the preview image</summary>
        private const int PreviewImageMaxWidth = 700;

        /// <summary>Maximum height of the preview image</summary>
        private const int PreviewImageMaxHeight = 1500;

        [HttpGet]
        public virtual ActionResult GetCustomPreviewImage(string itemId, string lang, bool forceNew, bool useHighRes, bool saveInPage)
        {
            string mediaUrl = string.Empty;
            string thumbnailUrl = string.Empty;
            
            // If this isn't used there won't be any content in the XML
            using (new SecurityDisabler())
            {
                Item pageItem = Context.Database.GetItem(itemId, LanguageManager.GetLanguage(lang));
                if (!forceNew && ((ImageField)pageItem.Fields["preview image"]).MediaItem != null)
                {
                    mediaUrl = this.GetLargePreviewMediaUrl(((ImageField)pageItem.Fields["preview image"]).MediaItem);
                }
                else
                {
                    Log.Debug("Generating new preview for: " + itemId);
                    string previewPath = this.GeneratePreview(pageItem, useHighRes);
                    if (!string.IsNullOrEmpty(previewPath))
                    {
                        if (System.IO.File.Exists(previewPath))
                        {
                            Item mediaItem = this.SavePreview(pageItem, previewPath, saveInPage);
                            if (mediaItem != null)
                            {
                                mediaUrl = this.GetLargePreviewMediaUrl(mediaItem);
                                if (saveInPage)
                                {
                                    thumbnailUrl = this.GetThumbnailMediaUrl(mediaItem);
                                }
                            }
                            else
                            {
                                Log.Error("Media item is null", this);
                            }
                        }
                        else
                        {
                            Log.Error("Preview file does not exist", this);
                        }
                    }
                    else
                    {
                        Log.Error("Unable to generate preview file", this);
                    }
                }
            }

            return this.Json(new { mediaUrl, thumbnailUrl }, JsonRequestBehavior.AllowGet);
        }

        /// <summary>Publishes a PDF</summary>
        /// <param name="itemId">Item to publish</param>
        /// <param name="processingJobId">Guid of processing job</param>
        /// <param name="lang">Language</param>
        /// <returns></returns>
        [HttpPost]
        public virtual ActionResult ExportToPdf(string itemId, string processingJobId, string lang)
        {
            Log.Debug("Exporting item to PDF: " + itemId);

            try
            {
                new PrintManager(Context.Database, LanguageManager.GetLanguage(lang)).PrintAsync(itemId, processingJobId, new PrintOptions());
                return this.Json(200, JsonRequestBehavior.AllowGet);
            }
            catch (Exception ex)
            {
                Logger.Error(ex.Message, ex);
                return new HttpStatusCodeResult(500, ex.Message);
            }
        }

        /// <summary>Based on GetPreviewMediaUrl from original controller</summary>
        /// <param name="mediaItem">Media item</param>
        /// <returns>Preview image string</returns>
        public string GetLargePreviewMediaUrl(Item mediaItem)
        {
            MediaUrlOptions options = new MediaUrlOptions(mediaItem.Database, false)
            {
                Language = mediaItem.Language,
                AllowStretch = false,
                IgnoreAspectRatio = false,
                MaxWidth = PreviewImageMaxWidth,
                MaxHeight = PreviewImageMaxHeight,
                BackgroundColor = Color.White
            };
            return $"{MediaManager.GetMediaUrl(mediaItem, options)}&_={mediaItem.Statistics.Updated.Ticks}";
        }

        /// <summary>Saves a preview</summary>
        /// <param name="pageItem">Page item</param>
        /// <param name="imageFullPath">Full path to the image</param>
        /// <param name="saveInPage">Whether or not to save in the page</param>
        /// <returns>Preview item</returns>
        private Item SavePreview(Item pageItem, string imageFullPath, bool saveInPage)
        {
            using (new SecurityDisabler())
            {
                using (new LanguageSwitcher(pageItem.Language))
                {
                    try
                    {
                        string extension = Path.GetExtension(imageFullPath);
                        Item mediaItem = ((ImageField)pageItem.Fields["preview image"]).MediaItem;
                        if (mediaItem != null && saveInPage)
                        {
                            bool flag = true;
                            if (pageItem.IsClone && pageItem.SharedFieldsSource != null)
                            {
                                ID mediaId = ((ImageField)pageItem.SharedFieldsSource.Fields["preview image"]).MediaID;
                                flag = mediaId.IsNull || !mediaId.ToString().Equals(mediaItem.ID.ToString(), StringComparison.InvariantCultureIgnoreCase);
                            }
                            if (flag)
                            {
                                Item innerItem = mediaItem;
                                using (FileStream fileStream = new FileStream(imageFullPath, FileMode.Open, FileAccess.Read))
                                {
                                    try
                                    {
                                        new Media(new MediaData(new MediaItem(innerItem))).SetStream(new MediaStream(fileStream, extension, new MediaItem(innerItem)));
                                    }
                                    catch (Exception ex)
                                    {
                                        Logger.Error("DesignController.SavePreview Error : " + ex.Message, ex);
                                    }
                                }
                                return innerItem;
                            }
                        }
                        using (FileStream memoryStream = new FileStream(imageFullPath, FileMode.Open, FileAccess.Read))
                        {
                            Item parentItem = pageItem.Database.GetItem(OdgSettings.PagePreviewsRootFolderId);
                            Assert.IsNotNull(parentItem, "Page Previews folder item not found");
                            Item previewItem = this.CreatePreviewItem(memoryStream, parentItem, pageItem, extension);
                            if (previewItem != null && saveInPage)
                            {
                                pageItem.Editing.BeginEdit();
                                ((ImageField)pageItem.Fields["preview image"]).MediaID = previewItem.ID;
                                pageItem.Editing.EndEdit();
                            }
                            return previewItem;
                        }
                    }
                    catch (Exception ex)
                    {
                        Logger.Error("DesignController.SavePreview: " + ex.Message, ex);
                    }
                }
            }
            return null;
        }

        /// <summary>Creates a preview item</summary>
        /// <param name="memoryStream">Memory stream containing preview</param>
        /// <param name="parentItem">Parent item</param>
        /// <param name="pageItem">Page item</param>
        /// <param name="ext">Extension</param>
        /// <returns>Preview item</returns>
        private Item CreatePreviewItem(FileStream memoryStream, Item parentItem, Item pageItem, string ext)
        {
            try
            {
                using (new SecurityDisabler())
                {
                    string str = $"{pageItem.ID.ToGuid().ToString().Replace('-', '_')}_{pageItem.Language}";
                    MediaCreatorOptions options = new MediaCreatorOptions
                    {
                        KeepExisting = false,
                        Destination = parentItem.Paths.LongID + "/" + str,
                        Database = pageItem.Database,
                        AlternateText = $"{pageItem.Name}_{pageItem.Language}"
                    };
                    return MediaManager.Creator.CreateFromStream(memoryStream, str + ext, options);
                }
            }
            catch (Exception ex)
            {
                Logger.Error("DesignController.CreatePreviewItem Error : " + ex.Message, ex);
            }
            return null;
        }

    }
}