/// <summary>
        /// Sets the custom parameters.
        /// </summary>
        /// <param name="renderingDefinition">The rendering definition.</param>
        /// <param name="options">The options.</param>
        private void SetCustomParameters(
            RenderingDefinition renderingDefinition, RenderingParametersFieldEditorOptions options)
        {
            Assert.ArgumentNotNull(renderingDefinition, "renderingDefinition");
            Assert.ArgumentNotNull(options, "options");

            Item item = (renderingDefinition.ItemID != null) ?
                        Client.ContentDatabase.GetItem(renderingDefinition.ItemID) : null;

            if (item != null)
            {
                options.Parameters["rendering"] = item.Uri.ToString();
            }
            if (Item != null)
            {
                options.Parameters["contentitem"] = Item.Uri.ToString();
            }
            if (WebEditUtil.IsRenderingPersonalized(renderingDefinition))
            {
                options.Parameters["warningtext"] = "There are personalization conditions defined for this control. Changing control properties may effect them.";
            }
            if (!string.IsNullOrEmpty(renderingDefinition.MultiVariateTest))
            {
                options.Parameters["warningtext"] = "There is a multivariate test set up for this control. Changing control properties may effect the test.";
            }
        }
        private LayoutDefinition GetLayoutDefinition()
        {
            var xml = WebEditUtil.ConvertJSONLayoutToXML(WebUtil.GetFormValue("scLayout"));
            var layoutDefinition = LayoutDefinition.Parse(xml);

            return(layoutDefinition);
        }
        /// <summary>
        /// Renders the page design mode.
        /// </summary>
        /// <param name="output">The output.</param>
        private void RenderPlaceholderPageDesignMode(HtmlTextWriter output)
        {
            Assert.ArgumentNotNull((object)output, "output");
            bool flag = true;

            if (!this.CanDesign(Sitecore.Context.Database) || !Policy.IsAllowed("Page Editor/Can Design"))
            {
                flag = false;
            }
            Item contextItem = this.GetContextItem();

            if (contextItem != null && !WebEditUtil.CanDesignItem(contextItem))
            {
                flag = false;
            }
            string            qualifiedKey = this.GetQualifiedKey();
            Item              obj          = this.GetItem();
            GetChromeDataArgs args         = obj != null ? new GetChromeDataArgs("placeholder", obj) : new GetChromeDataArgs("placeholder");

            args.CustomData["placeHolderKey"] = (object)qualifiedKey;
            GetChromeDataPipeline.Run(args);
            ChromeData chromeData  = args.ChromeData;
            string     startMarker = Placeholder72.GetStartMarker(qualifiedKey, chromeData, flag);

            output.Write(startMarker);
            for (int index = 0; index < this.Controls.Count; ++index)
            {
                Control control = this.Controls[index];
                this.RenderControlPageDesignMode(output, flag, control);
            }
            string endMarker = Placeholder72.GetEndMarker(chromeData);

            output.Write(endMarker);
        }
示例#4
0
        /// <inheritdoc/>
        protected override SortContentOptions GetOptions(ClientPipelineArgs args)
        {
            Assert.ArgumentNotNull((object)args, "args");
            Item obj = Client.ContentDatabase.GetItem(args.Parameters["itemid"], WebEditUtil.GetClientContentLanguage() ?? Context.Language);

            Assert.IsNotNull(obj, "item");
            return(new ManageContentOptions(obj));
        }
        protected void Run(ClientPipelineArgs args)
        {
            Assert.ArgumentNotNull(args, "args");

            if (!args.IsPostBack)
            {
                SheerResponse.Input("Name: ", "New Prefab", "New Prefab");
                args.WaitForPostBack();
            }
            else if (args.HasResult)
            {
                var name = args.Result;

                var pageId      = args.Parameters["id"];
                var uniqueId    = args.Parameters["referenceId"];
                var renderingId = args.Parameters["renderingId"];

                var db = Client.ContentDatabase;

                LayoutDefinition layoutDefinition = GetCurrentLayoutDefinition();
                var deviceId = WebEditUtil.GetClientDeviceId();

                if (layoutDefinition == null || ID.IsNullOrEmpty(deviceId))
                {
                    SheerResponse.Alert("Action failed. Unable to find presentation details.");
                    return;
                }

                var deviceRenderings = layoutDefinition?.GetDevice(deviceId.ToString());
                if (deviceRenderings?.Renderings == null)
                {
                    SheerResponse.Alert("Action failed. Unable to find current device.");
                    return;
                }

                var index = GetIndex(deviceRenderings, uniqueId);
                if (index == -1)
                {
                    SheerResponse.Alert("Action failed. Unable to find selected rendering");
                    return;
                }

                var item = UIUtil.GetItemFromQueryString(db);

                // Create prefab
                var prefab = _prefabService.CreatePrefab(name, deviceRenderings, index, item);

                SheerResponse.Alert("Prefab Created");

                if (Config.Sxa.IsEnabled) // reload so toolbox shows new prefab
                {
                    SheerResponse.Eval("window.parent.location.reload();");
                }

                // TODO: Go Edit Prefab?
                return;
            }
        }
        protected virtual DeleteContentOptions GetOptions(ClientPipelineArgs args)
        {
            Assert.ArgumentNotNull(args, "args");
            string   str      = args.Parameters.Get("itemid");
            Language language = WebEditUtil.GetClientContentLanguage() ?? Context.Language;
            Item     item     = Client.ContentDatabase.GetItem(str, language);

            Assert.IsNotNull(item, "item");
            return(new DeleteContentOptions(item));
        }
        /// <summary>
        /// Get Rendering
        /// </summary>
        /// <param name="renderingId">
        /// The rendering Id.
        /// </param>
        /// <returns>
        /// returns Rendering as RenderingDefinition
        /// </returns>
        private static RenderingDefinition GetRendering(string renderingId)
        {
            var formValue        = WebUtil.GetFormValue("scLayout");
            var id               = ShortID.Decode(WebUtil.GetFormValue("scDeviceID"));
            var layoutDefinition = WebEditUtil.ConvertJSONLayoutToXML(formValue);
            var parsedLayout     = LayoutDefinition.Parse(layoutDefinition);
            var device           = parsedLayout.GetDevice(id);
            var index            = device.GetIndex(renderingId);

            return((RenderingDefinition)device.Renderings[index]);
        }
示例#8
0
        public override void Execute(CommandContext context)
        {
            string           formValue        = WebUtil.GetFormValue("scLayout");
            string           xml              = WebEditUtil.ConvertJSONLayoutToXML(formValue);
            string           id               = ShortID.Decode(WebUtil.GetFormValue("scDeviceID"));
            LayoutDefinition layoutDefinition = LayoutDefinition.Parse(xml);

            if (layoutDefinition == null)
            {
                ReturnLayout();
                return;
            }
            DeviceDefinition device = layoutDefinition.GetDevice(id);

            if (device == null)
            {
                ReturnLayout();
                return;
            }
            string uniqueId = Guid.Parse(context.Parameters["renderingUid"]).ToString("B").ToUpperInvariant();
            RenderingDefinition renderingByUniqueId = device.GetRenderingByUniqueId(uniqueId);

            if (renderingByUniqueId == null)
            {
                ReturnLayout();
                return;
            }
            if (string.IsNullOrEmpty(renderingByUniqueId.Parameters))
            {
                if (!string.IsNullOrEmpty(renderingByUniqueId.ItemID))
                {
                    RenderingItem renderingItem = Client.ContentDatabase.GetItem(renderingByUniqueId.ItemID);
                    renderingByUniqueId.Parameters = ((renderingItem != null) ? renderingItem.Parameters : string.Empty);
                }
                else
                {
                    renderingByUniqueId.Parameters = string.Empty;
                }
            }
            NameValueCollection nameValueCollection = WebUtil.ParseUrlParameters(renderingByUniqueId.Parameters);
            string input = nameValueCollection["FieldNames"];
            string text  = context.Parameters["variant"];

            if (Guid.TryParse(input, out Guid result) && result == Guid.Parse(text))
            {
                ReturnLayout();
                return;
            }
            nameValueCollection["FieldNames"] = text;
            renderingByUniqueId.Parameters    = new UrlString(nameValueCollection.EscapeDataValues()).GetUrl();
            formValue = WebEditUtil.ConvertXMLLayoutToJSON(layoutDefinition.ToXml());
            ReturnLayout(formValue);
        }
        public override void Execute(CommandContext context)
        {
            var id = ShortID.Decode(WebUtil.GetFormValue("scDeviceID"));
            var layoutDefinition = GetLayoutDefinition();

            if (layoutDefinition == null)
            {
                this.ReturnLayout();
            }
            else
            {
                var device = layoutDefinition.GetDevice(id);
                if (device == null)
                {
                    this.ReturnLayout();
                }
                else
                {
                    var renderingByUniqueId = device.GetRenderingByUniqueId(context.Parameters["referenceId"]);
                    if (renderingByUniqueId == null)
                    {
                        this.ReturnLayout();
                    }
                    else
                    {
                        if (string.IsNullOrEmpty(renderingByUniqueId.Parameters))
                        {
                            if (!string.IsNullOrEmpty(renderingByUniqueId.ItemID))
                            {
                                var renderingItem = (RenderingItem)Sitecore.Client.ContentDatabase.GetItem(renderingByUniqueId.ItemID);
                                renderingByUniqueId.Parameters = renderingItem != null ? renderingItem.Parameters : string.Empty;
                            }
                            else
                            {
                                renderingByUniqueId.Parameters = string.Empty;
                            }
                        }

                        var parameters = WebUtil.ParseUrlParameters(renderingByUniqueId.Parameters);

                        parameters[this.ParamKey] = this.ParamValue as string;

                        renderingByUniqueId.Parameters = new UrlString(parameters).GetUrl();
                        this.ReturnLayout(WebEditUtil.ConvertXMLLayoutToJSON(layoutDefinition.ToXml()));
                    }
                }
            }
        }
        protected virtual LayoutDefinition GetCurrentLayoutDefinition()
        {
            string formValue = WebUtil.GetFormValue("scLayout");

            if (string.IsNullOrEmpty(formValue))
            {
                return(null);
            }
            string xML = WebEditUtil.ConvertJSONLayoutToXML(formValue);

            if (string.IsNullOrEmpty(xML))
            {
                return(null);
            }
            return(LayoutDefinition.Parse(xML));
        }
        /// <summary>Handles the Accept_ click event.</summary>
        protected void OnAccept()
        {
            SaveRichTextContentArgs richTextContentArgs = new SaveRichTextContentArgs(this.Request.Form["FieldText"]);

            richTextContentArgs.Content = WebEditUtil.RepairLinks(richTextContentArgs.Content);
            using (new LongRunningOperationWatcher(250, "saveRichTextContent", new string[0]))
                CorePipeline.Run("saveRichTextContent", (PipelineArgs)richTextContentArgs);
            if (!RichTextEditorUrl.Parse(this.Context.Request.RawUrl).ShowInFrameBasedDialog)
            {
                SheerResponse.Eval(string.Format("scRichText.saveRichText({0})", (object)StringUtil.EscapeJavascriptString(richTextContentArgs.Content)));
            }
            else
            {
                SheerResponse.SetDialogValue(richTextContentArgs.Content);
            }
            SheerResponse.Eval("EditorPage.scCloseEditor();");
        }
示例#12
0
        /// <summary>
        /// Copied from
        /// <see cref="Sitecore.Shell.Applications.WebEdit.Commands.EditRenderingProperties"/> class.
        /// </summary>
        /// <param name="context"></param>
        /// <remarks>
        /// Changed <see cref="Sitecore.Shell.Applications.Layouts.DeviceEditor.RenderingParameters"/>
        /// to <see cref="AMRenderingParameters"/> class.
        /// </remarks>
        protected override void Run(ClientPipelineArgs args)
        {
            Assert.ArgumentNotNull(args, "args");
            int @int = MainUtil.GetInt(args.Parameters["selectedindex"], -1);

            if (@int < 0)
            {
                return;
            }
            Item clientContentItem = WebEditUtil.GetClientContentItem(Client.ContentDatabase);
            CustomRenderingParameters renderingParameters = new CustomRenderingParameters
            {
                Args          = args,
                DeviceId      = args.Parameters["device"],
                SelectedIndex = @int,
                HandleName    = args.Parameters["handle"],
                Item          = clientContentItem
            };

            if (!renderingParameters.Show())
            {
                return;
            }

            if (args.HasResult)
            {
                string sessionString = WebUtil.GetSessionString(args.Parameters["handle"]);
                sessionString = EditRenderingPropertiesCommand.GetLayout(sessionString);
                SheerResponse.SetAttribute("scLayoutDefinition", "value", sessionString);

                SheerResponse.Eval(
                    "window.parent.Sitecore.PageModes.ChromeManager.handleMessage('chrome:rendering:propertiescompleted');");

                SheerResponse.Eval(
                    "ExperienceEditor.ribbonDocument().querySelector('[data-sc-id=\"QuickSave\"]').click();");
            }
            else
            {
                SheerResponse.SetAttribute("scLayoutDefinition", "value", string.Empty);
            }
            WebUtil.RemoveSessionValue(args.Parameters["handle"]);
        }
        private Item GetDatasourceItem(string referenceId, Item item)
        {
            Assert.ArgumentNotNull(referenceId, "referenceId");
            Assert.ArgumentNotNull(item, "item");
            string str2 = WebEditUtil.ConvertJSONLayoutToXML(WebUtil.GetFormValue("scLayout"));

            Assert.IsNotNull(str2, "xmlLayout");
            LayoutDefinition definition = LayoutDefinition.Parse(str2);
            ID clientDeviceId           = WebEditUtil.GetClientDeviceId();

            Assert.IsNotNull(clientDeviceId, "deviceId");
            RenderingDefinition renderingByUniqueId = definition.GetDevice(clientDeviceId.ToString()).GetRenderingByUniqueId(referenceId);

            Assert.IsNotNull(renderingByUniqueId, "rendering");
            RenderingReference reference = new RenderingReference(renderingByUniqueId, item.Language, item.Database);

            if (!string.IsNullOrEmpty(reference.Settings.DataSource))
            {
                return(item.Database.GetItem(reference.Settings.DataSource));
            }
            return(null);
        }
        /// <summary>
        /// Run Form
        /// </summary>
        /// <param name="args">
        /// The args.
        /// </param>
        protected void Run(ClientPipelineArgs args)
        {
            if (!args.IsPostBack)
            {
                var rendering = GetRendering(ShortID.Decode(args.Parameters["uniqueid"]));
                if (rendering == null)
                {
                    return;
                }
                var urlString = new UrlString(UIUtil.GetUri("control:MediaFramework.EmbedMedia"));
                urlString["mo"] = "webedit";

                if (!string.IsNullOrEmpty(rendering.Parameters))
                {
                    var collection = StringUtil.GetNameValues(rendering.Parameters, '=', '&');
                    foreach (string key in collection)
                    {
                        urlString[key] = collection[key];
                    }
                }

                if (ID.IsID(rendering.Datasource))
                {
                    urlString[Constants.PlayerParameters.ItemId] = rendering.Datasource;
                }

                string activePage = args.Parameters[Constants.PlayerParameters.ActivePage];
                if (!string.IsNullOrEmpty(activePage))
                {
                    urlString[Constants.PlayerParameters.ActivePage] = activePage;
                }

                Context.ClientPage.ClientResponse.ShowModalDialog(urlString.ToString(), "1100", "600", string.Empty, true);
                args.WaitForPostBack();
            }
            else
            {
                Assert.ArgumentNotNull(args, "args");

                if (args.HasResult)
                {
                    var formValue        = WebUtil.GetFormValue("scLayout");
                    var id               = ShortID.Decode(WebUtil.GetFormValue("scDeviceID"));
                    var uniqueId         = ShortID.Decode(args.Parameters["uniqueid"]);
                    var layoutDefinition = WebEditUtil.ConvertJSONLayoutToXML(formValue);
                    var parsedLayout     = LayoutDefinition.Parse(layoutDefinition);
                    var device           = parsedLayout.GetDevice(id);
                    var deviceIndex      = parsedLayout.Devices.IndexOf(device);
                    var index            = device.GetIndex(uniqueId);
                    var rendering        = (RenderingDefinition)device.Renderings[index];

                    UrlString url = new UrlString(this.GetParameters(args.Result));

                    string itemId = url[Constants.PlayerParameters.ItemId];

                    url.Remove(Constants.PlayerParameters.ItemId);

                    rendering.Datasource = new ID(itemId).ToString();
                    rendering.Parameters = url.ToString();


                    parsedLayout.Devices[deviceIndex] = device;
                    var updatedLayout = parsedLayout.ToXml();
                    var layout        = GetLayout(updatedLayout);
                    SheerResponse.SetAttribute("scLayoutDefinition", "value", layout);
                    SheerResponse.Eval("window.parent.Sitecore.PageModes.ChromeManager.handleMessage('chrome:rendering:propertiescompleted');");
                }
            }
        }
 /// <summary>
 /// Get Layout
 /// </summary>
 /// <param name="layout">
 /// The layout.
 /// </param>
 /// <returns>
 /// returns layout as string
 /// </returns>
 private static string GetLayout(string layout)
 {
     Assert.ArgumentNotNull(layout, "layout");
     return(WebEditUtil.ConvertXMLLayoutToJSON(layout));
 }
 /// <summary>
 ///     Determines if Design mode is available
 /// </summary>
 /// <param name="item"></param>
 /// <returns></returns>
 public bool CanDesignItem(Item item)
 {
     return(Policy.IsAllowed("Page Editor/Can Design") && WebEditUtil.CanDesignItem(item));
 }