Exemplo n.º 1
0
        /// <summary>
        /// Inits the specified current node id.
        /// </summary>
        /// <param name="CurrentNodeId">The current node id.</param>
        /// <param name="PropertyData">The property data.</param>
        /// <param name="instance">The instance.</param>
        /// <returns></returns>
        public bool Init(int CurrentNodeId, string PropertyData, out object instance)
        {
            if (!Settings.RazorModelBindingEnabled)
            {
                if (Helper.Xml.CouldItBeXml(PropertyData))
                {
#pragma warning disable 0618
                    instance = new DynamicXml(PropertyData);
#pragma warning restore 0618
                    return(true);
                }

                instance = PropertyData;
                return(true);
            }

            UrlPickerState state = null;

            if (!string.IsNullOrEmpty(PropertyData))
            {
                state = UrlPickerState.Deserialize(PropertyData);
            }

            instance = state;

            return(true);
        }
Exemplo n.º 2
0
 /// <summary>
 /// Handles the Load event of the m_DataEditor control.
 /// </summary>
 /// <param name="sender">The source of the event.</param>
 /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
 void m_DataEditor_Load(object sender, EventArgs e)
 {
     if (!this.ContentEditor.Page.IsPostBack && !string.IsNullOrEmpty((string)this.Data.Value))
     {
         this.ContentEditor.State = UrlPickerState.Deserialize((string)this.Data.Value);
     }
 }
        /// <summary>
        /// Return the Multi UrlPicker that has been selected.
        /// </summary>
        /// <param name="content"></param>
        /// <param name="alias"></param>
        /// <returns></returns>
        public static IEnumerable <UrlPicker> GetMultiUrlPicker(this IPublishedContent content, string alias)
        {
            var xml = content.GetPropertyValue <RawXElement>(alias);

            if (xml != null)
            {
                var xmlData = xml.Value;

                if (xmlData != null)
                {
                    return
                        (
                        from pickerXml in xmlData.Elements("url-picker")
                        let urlPickerState = UrlPickerState.Deserialize(pickerXml.ToString())
                                             where (urlPickerState.Mode == UrlPickerMode.Content && urlPickerState.NodeId.HasValue) ||
                                             !string.IsNullOrEmpty(urlPickerState.Url)
                                             select new UrlPicker()
                    {
                        Url = urlPickerState.Mode == UrlPickerMode.Content ? Umbraco.TypedContent(urlPickerState.NodeId.Value).Url : urlPickerState.Url,
                        Title = urlPickerState.Title,
                        NewWindow = urlPickerState.NewWindow
                    }
                        );
                }
            }

            return(Enumerable.Empty <UrlPicker>());
        }
        public string Import(XElement propertyTag)
        {
            var result = string.Empty;

            if (!string.IsNullOrWhiteSpace(propertyTag.Value))
            {
                var ups = UrlPickerState.Deserialize(propertyTag.Value);

                if (ups.Mode == UrlPickerMode.Content && propertyTag.Attribute("nodeId") != null)
                {
                    var content = Services.ContentService.GetById(new Guid(propertyTag.Attribute("nodeId").Value));
                    if (content != null)
                    {
                        ups.NodeId = content.Id;
                    }
                }
                else if (ups.Mode == UrlPickerMode.Media && propertyTag.Attribute("nodeId") != null)
                {
                    var media = Services.MediaService.GetById(new Guid(propertyTag.Attribute("nodeId").Value));
                    if (media != null)
                    {
                        ups.NodeId = media.Id;
                    }
                }

                UrlPickerDataFormat format;
                if (Enum.TryParse(propertyTag.Attribute("format").Value, out format))
                {
                    result = ups.Serialize(format);
                }
            }

            return(result);
        }
Exemplo n.º 5
0
 /// <summary>
 /// Method for performing special actions while creating the <see cref="IDataType">datatype</see> editor.
 /// </summary>
 /// <param name="dataType">The <see cref="IDataType">datatype</see> instance.</param>
 /// <param name="eventArgs">The <see cref="DataTypeLoadEventArgs"/> instance containing the event data.</param>
 /// <remarks>Called when the grid creates the editor controls for the specified <see cref="IDataType">datatype</see>.</remarks>
 public override void Configure(UrlPickerDataType dataType, DataTypeLoadEventArgs eventArgs)
 {
     // Deserialize stored value
     if (dataType.Data.Value != null && !string.IsNullOrEmpty(dataType.Data.Value.ToString()) && dataType.ContentEditor.State == null)
     {
         dataType.ContentEditor.State = UrlPickerState.Deserialize((string)dataType.Data.Value) ?? new UrlPickerState();
     }
 }
Exemplo n.º 6
0
        public object ConvertValueWhenRead(object inputValue)
        {
            if (inputValue is string)
            {
                return(UrlPickerState.Deserialize(inputValue.ToString()));
            }

            return(inputValue);
        }
Exemplo n.º 7
0
        /// <summary>
        /// Attempts to convert the value specified into a useable value on the front-end
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public Attempt <object> ConvertPropertyValue(object value)
        {
            if (value != null && value.ToString().Length > 0)
            {
                return(new Attempt <object>(true, UrlPickerState.Deserialize(value.ToString())));
            }

            return(Attempt <object> .False);
        }
        public void Export(Property property, XElement propertyTag, Dictionary <int, ObjectTypes> dependantNodes)
        {
            if (property.Value != null && !string.IsNullOrWhiteSpace(property.Value.ToString()))
            {
                var ups = UrlPickerState.Deserialize(property.Value.ToString());

                if (ups != null)
                {
                    // find the data type definition
                    var dtd =
                        Services.DataTypeService.GetAllDataTypeDefinitions()
                        .FirstOrDefault(x => x.Name == propertyTag.Attribute("dataTypeName").Value);

                    // store how data is saved
                    if (dtd != null)
                    {
                        var values = PreValues.GetPreValues(dtd.Id);

                        if (values.Count >= 1)
                        {
                            var pv = values[1] as PreValue;

                            propertyTag.Add(new XAttribute("format", pv.Value));
                        }
                    }

                    propertyTag.Add(new XAttribute("mode", ups.Mode.ToString()));
                    propertyTag.Value = property.Value.ToString();

                    // find the id and convert it to guid
                    if (ups.NodeId != null && ups.NodeId.Value > 0)
                    {
                        if (ups.Mode == UrlPickerMode.Content)
                        {
                            var content = Services.ContentService.GetById(ups.NodeId.Value);

                            if (content != null)
                            {
                                propertyTag.Add(new XAttribute("nodeId", content.Key.ToString()));
                            }
                        }
                        else if (ups.Mode == UrlPickerMode.Media)
                        {
                            var media = Services.MediaService.GetById(ups.NodeId.Value);
                            if (media != null)
                            {
                                propertyTag.Add(new XAttribute("nodeId", media.Key.ToString()));
                            }
                        }
                    }
                }
            }
        }
Exemplo n.º 9
0
        /// <summary>
        /// Raises the <see cref="E:System.Web.UI.Control.Load"/> event.
        /// </summary>
        /// <param name="e">The <see cref="T:System.EventArgs"/> object that contains the event data.</param>
        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);

            //add the js/css required
            this.AddAllUrlPickerClientDependencies();

            // If this.State was not set, create a default state
            if (State == null)
            {
                State = new UrlPickerState(Settings);
            }
        }
        /// <summary>
        /// Return the UrlPicker that has been selected.
        /// </summary>
        /// <param name="content"></param>
        /// <param name="alias"></param>
        /// <returns></returns>
        public static UrlPicker GetUrlPicker(this IPublishedContent content, string alias)
        {
            var urlPickerState = UrlPickerState.Deserialize(content.GetPropertyValue <string>(alias));

            if ((urlPickerState.Mode == UrlPickerMode.Content && !urlPickerState.NodeId.HasValue) || string.IsNullOrEmpty(urlPickerState.Url))
            {
                return(new UrlPicker());
            }

            return(new UrlPicker()
            {
                Url = urlPickerState.Mode == UrlPickerMode.Content ? Umbraco.NiceUrl(urlPickerState.NodeId.Value) : urlPickerState.Url,
                Title = urlPickerState.Title,
                NewWindow = urlPickerState.NewWindow
            });
        }
Exemplo n.º 11
0
 /// <summary>
 /// Sets defaults
 /// </summary>
 public MultiUrlPickerSettings()
 {
     UrlPickerSettings     = new UrlPickerSettings();
     UrlPickerDefaultState = new UrlPickerState(UrlPickerSettings);
     Standalone            = true;
 }
        public override object ConvertDbToEditor(Property property, PropertyType propertyType, IDataTypeService dataTypeService)
        {
            if (property.Value == null || property.Value.ToString() == String.Empty)
            {
                return(null);
            }

            var dataFormat = "";

            // Imply data format from the formatting of the serialized state
            if (property.Value.ToString().StartsWith("<"))
            {
                dataFormat = "xml";
            }
            else if (property.Value.ToString().StartsWith("{"))
            {
                dataFormat = "json";
            }
            else
            {
                dataFormat = "csv";
            }

            var state = new UrlPickerState();

            switch (dataFormat.ToLower())
            {
            case "xml":
                XElement dataNode = null;
                try
                {
                    dataNode = XElement.Parse(property.Value.ToString());
                } catch (Exception ex)
                {
                    return(null);
                }

                var modeAttribute = dataNode.Attribute("mode");
                if (modeAttribute != null)
                {
                    state.Mode = (UrlPickerMode)Enum.Parse(typeof(UrlPickerMode), modeAttribute.Value, false);
                }

                var newWindowElement = dataNode.Element("new-window");
                if (newWindowElement != null)
                {
                    state.NewWindow = bool.Parse(newWindowElement.Value);
                }

                var nodeIdElement = dataNode.Element("node-id");
                if (nodeIdElement != null)
                {
                    int nodeId;
                    if (int.TryParse(nodeIdElement.Value, out nodeId))
                    {
                        state.NodeId = nodeId;
                    }
                }

                var urlElement = dataNode.Element("url");
                if (urlElement != null)
                {
                    state.Url = urlElement.Value;
                }

                var linkTitleElement = dataNode.Element("link-title");
                if (linkTitleElement != null && !string.IsNullOrEmpty(linkTitleElement.Value))
                {
                    state.Title = linkTitleElement.Value;
                }
                break;

            case "csv":
                var parameters = property.Value.ToString().Split(',');

                if (parameters.Length > 0)
                {
                    state.Mode = (UrlPickerMode)Enum.Parse(typeof(UrlPickerMode), parameters[0], false);
                }
                if (parameters.Length > 1)
                {
                    state.NewWindow = bool.Parse(parameters[1]);
                }
                if (parameters.Length > 2)
                {
                    int nodeId;
                    if (int.TryParse(parameters[2], out nodeId))
                    {
                        state.NodeId = nodeId;
                    }
                }
                if (parameters.Length > 3)
                {
                    state.Url = parameters[3].Replace("&#45;", ",");
                }
                if (parameters.Length > 4)
                {
                    if (!string.IsNullOrEmpty(parameters[4]))
                    {
                        state.Title = parameters[4].Replace("&#45;", ",");
                    }
                }
                break;

            case "json":
                state = JsonConvert.DeserializeObject <UrlPickerState>(property.Value.ToString());
                break;
            }

            property.Value = JsonConvert.SerializeObject(state);

            return(base.ConvertDbToEditor(property, propertyType, dataTypeService));
        }
Exemplo n.º 13
0
        /// <summary>
        /// Returns a MultiUrlPickerState based on a serialized string.
        ///
        /// Tries to infer the format of the serialized data based on known types.  Will throw exceptions
        /// if it fails to parse.
        /// </summary>
        /// <param name="serializedState">An instance of MultiUrlPickerState as a serialized string</param>
        /// <returns>The state</returns>
        public static MultiUrlPickerState Deserialize(string serializedState)
        {
            // Can't deserialize an empty whatever
            if (string.IsNullOrEmpty(serializedState))
            {
                return(null);
            }

            // Default
            var state = new MultiUrlPickerState();
            var items = new List <UrlPickerState>();

            // Imply data format from the formatting of the serialized state
            UrlPickerDataFormat impliedDataFormat;

            if (serializedState.StartsWith("<"))
            {
                impliedDataFormat = UrlPickerDataFormat.Xml;
            }
            else if (serializedState.StartsWith("{"))
            {
                impliedDataFormat = UrlPickerDataFormat.Json;
            }
            else
            {
                impliedDataFormat = UrlPickerDataFormat.Csv;
            }

            // Try to deserialize the string
            try
            {
                switch (impliedDataFormat)
                {
                case UrlPickerDataFormat.Xml:

                    // Get each url-picker node
                    var dataNode = XElement.Parse(serializedState);
                    var xmlItems = dataNode.Elements("url-picker");

                    foreach (var xmlItem in xmlItems)
                    {
                        // Deserialize it
                        items.Add(UrlPickerState.Deserialize(xmlItem.ToString()));
                    }

                    state.Items = items;

                    break;

                case UrlPickerDataFormat.Csv:

                    // Split CSV by lines
                    var csvItems = serializedState.Split(new string[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);

                    // Deserialize each line
                    foreach (var csvItem in csvItems)
                    {
                        items.Add(UrlPickerState.Deserialize(csvItem));
                    }

                    state.Items = items;

                    break;

                case UrlPickerDataFormat.Json:

                    var jss = new JavaScriptSerializer();
                    state = jss.Deserialize <MultiUrlPickerState>(serializedState);

                    break;

                default:
                    throw new NotImplementedException();
                }
            }
            catch (Exception)
            {
                // Could not be deserialised, return null
                state = null;
            }

            return(state);
        }
Exemplo n.º 14
0
        /// <summary>
        /// Method for customizing the way the <see cref="IDataType">datatype</see> value is displayed in the grid.
        /// </summary>
        /// <remarks>Called when the grid displays the cell value for the specified <see cref="IDataType">datatype</see>.</remarks>
        /// <param name="dataType">The <see cref="IDataType">datatype</see> instance.</param>
        /// <returns>The display value.</returns>
        public override string GetDisplayValue(UrlPickerDataType dataType)
        {
            UrlPickerState state = null;

            var displayValue = string.Empty;

            // Deserialize stored value
            if (dataType.Data.Value != null && !string.IsNullOrEmpty(dataType.Data.Value.ToString()) && dataType.ContentEditor.State == null)
            {
                try
                {
                    state = UrlPickerState.Deserialize((string)dataType.Data.Value);
                }
                catch (Exception ex)
                {
                    Helper.Log.Error <DataType>(string.Format("DTG: Could not parse '{0}' as URL Picker state", dataType.Data.Value), ex);
                }
            }

            // Generate display value
            if (state != null)
            {
                if (state.Mode == UrlPickerMode.Content && state.NodeId != null)
                {
                    var node = uQuery.GetNode(state.NodeId.Value);

                    displayValue = string.Format(
                        "<span>{0}: </span><span>{1}</span><br/><span>{2}: </span><a href='{3}' title='{4}'>{5}</a>",
                        Helper.Dictionary.GetDictionaryItem("OpenInNewWindow", "Open in new window"),
                        state.NewWindow,
                        Helper.Dictionary.GetDictionaryItem("Node", "Node"),
                        node.NiceUrl,
                        Helper.Dictionary.GetDictionaryItem("OpenContent", "Open content"),
                        node.Name);

                    if (!string.IsNullOrEmpty(state.Title))
                    {
                        displayValue += string.Format(
                            "<br/><span>{0}: </span><span>{1}</span>",
                            Helper.Dictionary.GetDictionaryItem("Title", "Title"),
                            state.Title);
                    }
                }
                else if (state.Mode == UrlPickerMode.URL)
                {
                    displayValue = string.Format(
                        "<span>{0}: </span><span>{1}</span><br/><span>{2}: </span><a href='{3}' title='{4}' target='_blank'>{5}</a>",
                        Helper.Dictionary.GetDictionaryItem("OpenInNewWindow", "Open in new window"),
                        state.NewWindow,
                        Helper.Dictionary.GetDictionaryItem("URL", "URL"),
                        state.Url,
                        Helper.Dictionary.GetDictionaryItem("OpenUrl", "Open URL"),
                        state.Url);

                    if (!string.IsNullOrEmpty(state.Title))
                    {
                        displayValue = string.Format(
                            "<br/><span>{0}: </span><span>{1}</span>",
                            Helper.Dictionary.GetDictionaryItem("Title", "Title"),
                            state.Title);
                    }
                }
                else if (state.Mode == UrlPickerMode.Media && state.NodeId != null)
                {
                    var media = uQuery.GetMedia(state.NodeId.Value);

                    displayValue = string.Format(
                        "<span>{0}: </span><span>{1}</span><br/><span>{2}: </span><a href='{3}' title='{4}'>{5}</a>",
                        Helper.Dictionary.GetDictionaryItem("OpenInNewWindow", "Open in new window"),
                        state.NewWindow,
                        Helper.Dictionary.GetDictionaryItem("Node", "Node"),
                        media.getProperty("umbracoFile"),
                        Helper.Dictionary.GetDictionaryItem("OpenMedia", "Open media"),
                        media.Text);

                    if (!string.IsNullOrEmpty(state.Title))
                    {
                        displayValue += string.Format(
                            "<br/><span>{0}: </span><span>{1}</span>",
                            Helper.Dictionary.GetDictionaryItem("Title", "Title"),
                            state.Title);
                    }
                }
            }

            return(displayValue);
        }