Beispiel #1
0
        /// <summary>
        /// Loads the part from the specified path.
        /// </summary>
        /// <param name="partPath">The full path to the part to load.</param>
        /// <returns>The part deserialized from the specified file path.</returns>
        public PartInfo LoadFromFile(string partPath)
        {
            PartInfo info = null;

            //using (LogGroup logGroup = LogGroup.Start("Loading the part from the specified path.", NLog.LogLevel.Debug))
            //{
            if (!File.Exists(partPath))
            {
                throw new ArgumentException("The specified file does not exist.");
            }

            //	LogWriter.Debug("Path: " + partPath);


            using (StreamReader reader = new StreamReader(File.OpenRead(partPath)))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(PartInfo));

                info = (PartInfo)serializer.Deserialize(reader);

                reader.Close();
            }
            //}

            return(info);
        }
Beispiel #2
0
        /// <summary>
        /// Loads all the parts found in the parts file.
        /// </summary>
        /// <param name="includeDisabled">A value indicating whether or not to include disabled parts.</param>
        /// <returns>An array of the the parts found.</returns>
        public PartInfo[] LoadInfoFromFile(bool includeDisabled)
        {
            // Logging disabled to boost performance
            //using (LogGroup logGroup = LogGroup.StartDebug("Loading the parts from the XML file."))
            //{
            if (Parts == null)
            {
                List <PartInfo> validParts = new List <PartInfo>();

                PartInfo[] parts = new PartInfo[] {};

                using (StreamReader reader = new StreamReader(File.OpenRead(FileNamer.PartsInfoFilePath)))
                {
                    XmlSerializer serializer = new XmlSerializer(typeof(PartInfo[]));
                    parts = (PartInfo[])serializer.Deserialize(reader);
                }

                foreach (PartInfo part in parts)
                {
                    if (part.Enabled || includeDisabled)
                    {
                        validParts.Add(part);
                    }
                }

                Parts = validParts.ToArray();
            }
            //}
            return(Parts);
        }
Beispiel #3
0
        /// <summary>
        /// Locates the part info for performing the specified action with the specified type.
        /// </summary>
        /// <param name="action">The action that is to be performed by the part.</param>
        /// <param name="typeName">The short type name of the entity that is involved in the action.</param>
        /// <returns>The part info for the specified scenario.</returns>
        public PartInfo Locate(string action, string typeName)
        {
            // Get the specified type
            Type type = null;

            if (Entities.EntityState.Entities.Contains(typeName))
            {
                type = Entities.EntityState.Entities[typeName].GetEntityType();
            }

            // Create a direct part key for the specified type
            string key = Parts.GetPartKey(action, typeName);

            // Create the part info variable to hold the return value
            PartInfo partInfo = null;

            // Check the direct key to see if a part exists
            if (Parts.PartExists(key))
            {
                partInfo = Parts[key];
            }
            // If not then navigate up the heirarchy looking for a matching part
            else if (type != null)
            {
                partInfo = LocateFromHeirarchy(action, type);
            }

            return(partInfo);
        }
        /// <summary>
        /// Creates the full file path for the provided part.
        /// </summary>
        /// <param name="part">The part to create the file path for.</param>
        /// <returns>The full file path for the provided part.</returns>
        public string CreatePartFilePath(PartInfo part)
        {
            if (part.PartFilePath == null || part.PartFilePath == String.Empty)
            {
                throw new ArgumentException("The part.PartFilePath property hasn't been set.");
            }

            return(FileMapper.MapApplicationRelativePath(part.PartFilePath));
        }
Beispiel #5
0
        /// <summary>
        /// Locates the part info for performing the specified action with the specified type by looking at the base types and interfaces of the provided type.
        /// </summary>
        /// <param name="action">The action that is to be performed by the part.</param>
        /// <param name="type">The type that is involved in the action.</param>
        /// <returns>The part info for the specified scenario.</returns>
        public PartInfo LocateFromHeirarchy(string action, Type type)
        {
            PartInfo partInfo = LocateFromInterfaces(action, type);

            if (partInfo == null)
            {
                partInfo = LocateFromBaseTypes(action, type);
            }

            return(partInfo);
        }
Beispiel #6
0
        /// <summary>
        /// Extracts the part infos from the provided file path.
        /// </summary>
        /// <param name="filePath">The full path to the part (.ascx) file.</param>
        /// <returns></returns>
        public PartInfo[] ExtractPartInfo(string filePath)
        {
            string shortName = Path.GetFileNameWithoutExtension(filePath);
            string extension = Path.GetExtension(filePath).Trim('.');

            string[] actions = ExtractActions(shortName);

            string typeName = ExtractType(shortName);

            List <PartInfo> parts = new List <PartInfo>();

            string relativeFilePath = filePath.Replace(StateAccess.State.PhysicalApplicationPath, "")
                                      .Replace(@"\", "/")
                                      .Trim('/');


            foreach (string action in actions)
            {
                PartInfo info = new PartInfo();
                info.Action       = action;
                info.TypeName     = typeName;
                info.PartFilePath = relativeFilePath;

                BasePart p = (BasePart)ControlLoader.LoadControl(filePath);

                if (p == null)
                {
                    throw new ArgumentException("Cannot find part file at path: " + filePath);
                }

                // Ensure that the info properties have been set
                p.InitializeInfo();

                info.MenuTitle    = p.MenuTitle;
                info.MenuCategory = p.MenuCategory;

                parts.Add(info);
            }

            return(parts.ToArray());
        }
        /// <summary>
        /// Creates the file name for the serialized info for the provided part.
        /// </summary>
        /// <param name="part">The part to create the file name for.</param>
        /// <returns>The full file name for the serialized info for the provided part.</returns>
        public virtual string CreateInfoFileName(PartInfo part)
        {
            if (part == null)
            {
                throw new ArgumentNullException("part");
            }

            if (part.Action == null)
            {
                throw new ArgumentNullException("part.Action", "No action has been set to the Action property.");
            }

            string name = String.Empty;

            if (part.TypeName != String.Empty)
            {
                name += part.TypeName + "-";
            }

            name += part.Action + ".part";

            return(name);
        }
Beispiel #8
0
        /// <summary>
        /// Locates the part info for performing the specified action with the specified type by looking at the base types of the provided type.
        /// </summary>
        /// <param name="action">The action that is to be performed by the part.</param>
        /// <param name="type">The type that is involved in the action.</param>
        /// <param name="format">The output format of the part to locate.</param>
        /// <returns>The part info for the specified scenario.</returns>
        public PartInfo LocateFromBaseTypes(string action, Type type)
        {
            PartInfo partInfo = null;

            TypeNavigator navigator = new TypeNavigator(type);

            while (navigator.HasNext && partInfo == null)
            {
                Type nextType = navigator.Next();

                string key = Parts.GetPartKey(action, nextType.Name);

                // If a part exists for the base type then use it
                if (Parts.PartExists(key))
                {
                    partInfo = Parts[key];

                    break;
                }
            }

            return(partInfo);
        }
Beispiel #9
0
        /// <summary>
        /// Locates the part info for performing the specified action with the specified type by looking at the interfaces of the provided type.
        /// </summary>
        /// <param name="action">The action that is to be performed by the part.</param>
        /// <param name="type">The type that is involved in the action.</param>
        /// <returns>The part info for the specified scenario.</returns>
        public PartInfo LocateFromInterfaces(string action, Type type)
        {
            PartInfo partInfo = null;

            Type[] interfaceTypes = type.GetInterfaces();

            // Loop backwards through the interface types
            for (int i = interfaceTypes.Length - 1; i >= 0; i--)
            {
                Type interfaceType = interfaceTypes[i];

                string key = Parts.GetPartKey(action, interfaceType.Name);

                if (Parts.PartExists(key))
                {
                    partInfo = Parts[key];

                    break;
                }
            }

            return(partInfo);
        }
Beispiel #10
0
        /// <summary>
        /// Initializes the parts and loads all parts to state.
        /// </summary>
        public void Initialize()
        {
            using (LogGroup logGroup = LogGroup.StartDebug("Initializing the web parts."))
            {
                if (StateAccess.IsInitialized && !PartState.IsInitialized)
                {
                    PartInfo[] parts = new PartInfo[] {};

                    bool pageIsAccessible = Page != null;

                    // Only scan for parts if the page component is accessible (otherwise they can't be loaded through LoadControl)
                    // and when the parts have NOT yet been mapped
                    if (pageIsAccessible && !IsCached)
                    {
                        LogWriter.Debug("Is not cached. Scanning from type attributes.");

                        parts = FindParts();

                        Saver.SaveInfoToFile(parts);

                        Initialize(parts);
                    }
                    else if (IsCached)
                    {
                        LogWriter.Debug("Is cached. Loading from XML.");

                        parts = LoadParts();

                        Initialize(parts);
                    }
                }
                else
                {
                    LogWriter.Debug("State is not initialized. Skipping.");
                }
            }
        }