Hi Mohammed,

Not tried it yet, I will give it another go with the debugger (although I can't always get that working). I noticed the same about the MacroComment - must be an old package!

Have you had any luck upgrading from old websites to the new Umbraco 7 framework before? Bearing in mind i'm not a .Net Developer, I'm a Web Developer who can fumble his way through a few bits of code within complex databases ! :)

Yes, after a lot of work, especially rewriting the macros, replacing the old datatypes and packages by newer equivalent, it worked. But I agree, upgrading has always be a hard thing on Umbraco.

That's the part I'm lost on....

I created a page that performs a migration from uComponents to Archetype (uComponents was being used primarily for lists of data, which Archetype is good at)

I don't know how to go about changing old functionality ie. uComponents to newer components in V7 without being able to actually get V7 installed? It's a bit of catch 22 (forgive me if I'm being stupid).

I think I'm going to try again, get to the same point and try to utilise the debugger to find out what's using the MacroComment. If I can it to recognise the upgrade process I'll be halfway there - as I really don't want to have to come up with a way to export bespoke news/video articles and import them along with the document type relationships (most that would fail as they are out of date) into V7...

Sometimes I with it was all done with a push of a button(!)

Thanks Nicholas.

Hi Nicholas,

I am facing issues while upgrading from 4.11.10 to 7.3.8 due to uComponents.

I need your help on your solution. Can you please share your solution regarding fakeUComponents as well as entire method to migrate data from uComponents to Archtypes with steps?

Please help me on this.

Thanks in Advance.

Dhiren

What sorts of issues are you facing? My above post pretty much covered it. In fact, you can probably just skip the parts about creating transitional code and just convert everything to Archetype.

The only reason you'd need a FakeUComponents would be to read in the old property data during the conversion process. In particular, I pretty much just had to do that for the links that are part of uComponents. Here are a few of the files in my FakeUComponents project:

// UrlPickerStates.cs:
namespace uComponents.DataTypes.UrlPicker.Dto
{
    using System;
    using System.Collections.Generic;
    using System.Web.Script.Serialization;
    using System.Xml.Linq;
    using umbraco;
    using Umbraco.Web;


    public class UrlPickerState
    {

        #region DTO Properties

        /// <summary>
        /// Title for the URL
        /// </summary>
        public string Title { get; set; }
        /// <summary>
        /// Mode that the URL picker is set to.  See UrlPickerMode.
        /// </summary>
        public UrlPickerMode Mode { get; set; }
        /// <summary>
        /// Node ID, if set, for a content node
        /// </summary>
        public int? NodeId { get; set; }
        /// <summary>
        /// URL which is the whole point of this datatype
        /// </summary>
        public string Url { get; set; }
        /// <summary>
        /// Whether the URL is to open in a new window
        /// </summary>
        public bool NewWindow { get; set; }

        #endregion


        public static UrlPickerState Deserialize(string serializedState)
        {
            // Can't deserialize an empty whatever
            if (string.IsNullOrEmpty(serializedState))
            {
                return null;
            }

            // Default
            var state = new 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:
                        var dataNode = XElement.Parse(serializedState);

                        // Carefully try to get values out.  This is in case new versions add
                        // to the XML
                        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 UrlPickerDataFormat.Csv:

                        var parameters = serializedState.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 UrlPickerDataFormat.Json:

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

                        // Check for old states
                        var untypedState = jss.DeserializeObject(serializedState);
                        if (untypedState is Dictionary<string, object>)
                        {
                            var dictState = (Dictionary<string, object>)untypedState;

                            if (dictState.ContainsKey("LinkTitle"))
                            {
                                state.Title = (string)dictState["LinkTitle"];

                                if (dictState.ContainsKey("NewWindow"))
                                {
                                    // There was a short period where the UrlPickerMode values were
                                    // integers starting with zero, instead of one.  This period only
                                    // existed when both the "LinkTitle" and "NewWindow" keys were
                                    // used.
                                    state.Mode = (UrlPickerMode)((int)dictState["Mode"] + 1);
                                }
                            }
                        }

                        break;
                    default:
                        throw new NotImplementedException();
                }

                // If the mode is a content node, get the url for the node
                if (state.Mode == UrlPickerMode.Content && state.NodeId.HasValue && UmbracoContext.Current != null)
                {
                    var n = uQuery.GetNode(state.NodeId.Value);
                    var url = n != null ? n.Url : "#";

                    if (!string.IsNullOrWhiteSpace(url))
                    {
                        state.Url = url;
                    }

                    if (string.IsNullOrWhiteSpace(state.Title) && n != null)
                    {
                        state.Title = n.Name;
                    }
                }
            }
            catch (Exception ex)
            {
                // Could not be deserialised, return null
                state = null;
            }

            return state;
        }

    }
}

// UrlPickerDataFormat.cs
namespace uComponents.DataTypes.UrlPicker
{
    public enum UrlPickerDataFormat
    {
        /// <summary>
        /// Store as XML
        /// </summary>
        Xml,
        /// <summary>
        /// Store as comma delimited (CSV, single line)
        /// </summary>
        Csv,
        /// <summary>
        /// Store as a JSON object, which can be deserialized by .NET or JavaScript
        /// </summary>
        Json
    }
}

// UrlPickerMode.cs
namespace uComponents.DataTypes.UrlPicker
{
    public enum UrlPickerMode : int
    {
        /// <summary>
        /// URL string
        /// </summary>
        URL = 1,
        /// <summary>
        /// Content node
        /// </summary>
        Content = 2,
        /// <summary>
        /// Media node
        /// </summary>
        Media = 3,
        /// <summary>
        /// Upload a file
        /// </summary>
        Upload = 4
    }
}

The code is all open source, so you pretty much just copy/paste what you need.