public Package(XPathNavigator xPathNavigator) : base(xPathNavigator) { this.m_Attributes = new Interface.WATFDictionary<string, string>(); XPathNavigator copyXPathNavigator = xPathNavigator.CreateNavigator(); if(copyXPathNavigator.MoveToFirstAttribute()) { if(copyXPathNavigator.Name.Equals(GlobalDefine.Keyword.Executive.Path)) { this.m_Attributes.Add(copyXPathNavigator.Name, Path.Value(xPathNavigator)); } else if(copyXPathNavigator.Name.Equals(GlobalDefine.Keyword.Executive.Prefix)) { this.m_Attributes.Add(copyXPathNavigator.Name, Prefix.Value(xPathNavigator)); } while (copyXPathNavigator.MoveToNextAttribute()) { if (copyXPathNavigator.Name.Equals(GlobalDefine.Keyword.Executive.Path)) { this.m_Attributes.Add(copyXPathNavigator.Name, Path.Value(xPathNavigator)); } else if (copyXPathNavigator.Name.Equals(GlobalDefine.Keyword.Executive.Prefix)) { this.m_Attributes.Add(copyXPathNavigator.Name, Prefix.Value(xPathNavigator)); } } } }
public Load(XPathNavigator xPathNavigator) : base(xPathNavigator) { this.m_Attributes = new WATF.Compiler.Interface.WATFDictionary<string, string>(); XPathNavigator copyXPathNavigator = xPathNavigator.CreateNavigator(); if (copyXPathNavigator.MoveToFirstAttribute()) { if (copyXPathNavigator.Name.Equals(GlobalDefine.Keyword.ConfigFile.Name)) { this.m_Attributes.Add(GlobalDefine.Keyword.ConfigFile.Name, Name.Value(xPathNavigator)); } else if (copyXPathNavigator.Name.Equals(GlobalDefine.Keyword.ConfigFile.Path)) { this.m_Attributes.Add(GlobalDefine.Keyword.ConfigFile.Path, Path.Value(xPathNavigator)); } while (copyXPathNavigator.MoveToNextAttribute()) { if (copyXPathNavigator.Name.Equals(GlobalDefine.Keyword.ConfigFile.Name)) { this.m_Attributes.Add(GlobalDefine.Keyword.ConfigFile.Name, Name.Value(xPathNavigator)); } else if (copyXPathNavigator.Name.Equals(GlobalDefine.Keyword.ConfigFile.Path)) { this.m_Attributes.Add(GlobalDefine.Keyword.ConfigFile.Path, Path.Value(xPathNavigator)); } } } }
internal Element(XPathNavigator node) : this(node.Name) { XPathNavigator navigator = node.CreateNavigator(); if (navigator.MoveToFirstAttribute()) { do { AddAttribute(navigator.Name, navigator.Value); } while (navigator.MoveToNextAttribute()); } }
public Test(XPathNavigator xPathNavigator) : base(xPathNavigator) { m_TestChilds = new Interface.WATFDictionary<string, Interface.WATFPathNavigator>(); XPathNodeIterator xPathNodeIterator = xPathNavigator.CreateNavigator().SelectChildren(XPathNodeType.Element); while (xPathNodeIterator.MoveNext()) { if (xPathNodeIterator.Current.LocalName.Equals(GlobalDefine.Keyword.Executive.Step)) { m_TestChilds.Add(GlobalDefine.Keyword.Executive.Step, new Step.Step(xPathNodeIterator.Current)); } } }
private ConfigFile(XPathNavigator xPathNavigator) : base(xPathNavigator) { m_ConfigFileNodes = new Interface.WATFDictionary<string, Interface.WATFPathNavigator>(); XPathNodeIterator xPathNodeIterator = xPathNavigator.CreateNavigator().SelectChildren(XPathNodeType.Element); while (xPathNodeIterator.MoveNext()) { if(xPathNodeIterator.Current.LocalName.Equals(GlobalDefine.Keyword.ConfigFile.Load)) { m_ConfigFileNodes.Add(GlobalDefine.Keyword.ConfigFile.Load, new Load.Load(xPathNodeIterator.Current)); } } }
public Import(XPathNavigator xPathNavigator) : base(xPathNavigator) { this.m_ImportChilds = new Interface.WATFDictionary<String, WATF.Compiler.Interface.WATFPathNavigator>(); XPathNodeIterator xPathNodeIterator = xPathNavigator.CreateNavigator().SelectChildren(XPathNodeType.Element); while (xPathNodeIterator.MoveNext()) { if (xPathNodeIterator.Current.LocalName.Equals(GlobalDefine.Keyword.Executive.Package)) { m_ImportChilds.Add(xPathNodeIterator.Current.LocalName, new Package.Package(xPathNodeIterator.Current)); } } }
public Var(XPathNavigator xPathNavigator) : base(xPathNavigator) { this.m_Attributes = new Interface.WATFDictionary<string, string>(); XPathNavigator copyXPathNavigator = xPathNavigator.CreateNavigator(); if (copyXPathNavigator.MoveToFirstAttribute()) { this.m_Attributes.Add(copyXPathNavigator.Name, copyXPathNavigator.Value); while (copyXPathNavigator.MoveToNextAttribute()) { this.m_Attributes.Add(copyXPathNavigator.Name, copyXPathNavigator.Value); } } }
public Action(XPathNavigator xPathNavigator) : base(xPathNavigator) { m_ActionChilds = new Interface.WATFDictionary<string, Interface.WATFPathNavigator>(); XPathNodeIterator xPathNodeIterator = xPathNavigator.CreateNavigator().SelectChildren(XPathNodeType.Element); while (xPathNodeIterator.MoveNext()) { if (xPathNodeIterator.Current.LocalName.Equals(GlobalDefine.Keyword.Executive.Action)) { m_ActionChilds.Add(GlobalDefine.Keyword.Executive.Action, new Action(xPathNodeIterator.Current)); } } this.m_Attributes = new Interface.WATFDictionary<string, string>(); XPathNavigator copyXPathNavigator = xPathNavigator.CreateNavigator(); if (copyXPathNavigator.MoveToFirstAttribute()) { this.m_Attributes.Add(copyXPathNavigator.Name, copyXPathNavigator.Value); while (copyXPathNavigator.MoveToNextAttribute()) { this.m_Attributes.Add(copyXPathNavigator.Name,copyXPathNavigator.Value); } } }
public Step(XPathNavigator xPathNavigator) : base(xPathNavigator) { m_StepChilds = new Interface.WATFDictionary<string, Interface.WATFPathNavigator>(); XPathNodeIterator xPathNodeIterator = xPathNavigator.CreateNavigator().SelectChildren(XPathNodeType.Element); while (xPathNodeIterator.MoveNext()) { if (xPathNodeIterator.Current.LocalName.Equals(GlobalDefine.Keyword.Executive.Var)) { m_StepChilds.Add(GlobalDefine.Keyword.Executive.Var, new Var.Var(xPathNodeIterator.Current)); } else if (xPathNodeIterator.Current.LocalName.Equals(GlobalDefine.Keyword.Executive.Action)) { m_StepChilds.Add(GlobalDefine.Keyword.Executive.Action, new Action.Action(xPathNodeIterator.Current)); } } }
public Executive(XPathNavigator xPathNavigator) : base(xPathNavigator) { XPathNodeIterator xPathNodeIterator = xPathNavigator.CreateNavigator().SelectChildren(XPathNodeType.Element); m_ExeChilds = new Interface.WATFDictionary<string, Interface.WATFPathNavigator>(); while (xPathNodeIterator.MoveNext()) { if (xPathNodeIterator.Current.LocalName.Equals(GlobalDefine.Keyword.Executive.Import)) { m_ExeChilds.Add(xPathNodeIterator.Current.LocalName, new Import.Import(xPathNodeIterator.Current)); } else if (xPathNodeIterator.Current.LocalName.Equals(GlobalDefine.Keyword.Executive.Test)) { m_ExeChilds.Add(xPathNodeIterator.Current.LocalName, new Test.Test(xPathNodeIterator.Current)); } } }
public void Read(XPathNavigator navigator, ContentItem item, ReadingJournal journal) { IDictionary<string, IAttachmentHandler> attachments = _explorer.Map<IAttachmentHandler>(item.GetContentType()); foreach(XPathNavigator attachmentElement in EnumerateChildren(navigator)) { string name = attachmentElement.GetAttribute("name", string.Empty); if(attachments.ContainsKey(name)) { XPathNavigator attachmentContents = navigator.CreateNavigator(); attachmentContents.MoveToFirstChild(); Attachment a = attachments[name].Read(attachmentContents, item); if(a != null) journal.Report(a); } } }
public IList<string> GrabBackDropUrls(XPathNavigator nav) { List<string> urls = new List<string>(); XPathNodeIterator nIter = nav.SelectChildren("backdrop", ""); if (nav.MoveToFollowing("backdrop", "")) { XPathNavigator localNav = nav.CreateNavigator(); nav.MoveToParent(); for (int i = 0; i < nIter.Count; i++) { if (localNav.GetAttribute("size", "").ToUpperInvariant().Equals("original".ToUpperInvariant())) urls.Add(localNav.Value); localNav.MoveToNext(); } } return urls; }
private void ReadComponents(XPathNavigator manifestNav) { foreach (XPathNavigator componentNav in manifestNav.CreateNavigator().Select("components/component")) { int order = ComponentInstallers.Count; string type = componentNav.GetAttribute("type", ""); if (InstallMode == InstallMode.Install) { string installOrder = componentNav.GetAttribute("installOrder", ""); if (!string.IsNullOrEmpty(installOrder)) { order = int.Parse(installOrder); } } else { string unInstallOrder = componentNav.GetAttribute("unInstallOrder", ""); if (!string.IsNullOrEmpty(unInstallOrder)) { order = int.Parse(unInstallOrder); } } if (Package.InstallerInfo != null) { Log.AddInfo(Util.DNN_ReadingComponent + " - " + type); } ComponentInstallerBase installer = InstallerFactory.GetInstaller(componentNav, Package); if (installer == null) { Log.AddFailure(Util.EXCEPTION_InstallerCreate); } else { ComponentInstallers.Add(order, installer); this.Package.InstallerInfo.AllowableFiles += ", " + installer.AllowableFiles; } } }
private void loadDataFromNavigatorToTitle(ref XPathNavigator navigator, ref OMLSDKTitle newTitle) { SDKUtilities.DebugLine("[MyMoviesImporter] Loading data for a new title"); newTitle.MetadataSourceID = GetChildNodesValue(navigator, "WebServiceID"); #region covers SDKUtilities.DebugLine("[MyMoviesImporter] Scanning for {0} node", "Covers"); if (navigator.MoveToChild("Covers", "")) { SDKUtilities.DebugLine("[MyMoviesImporter] Covers found, processing"); SDKUtilities.DebugLine("[MyMoviesImporter] Scanning for {0} node", "Front"); if (navigator.MoveToChild("Front", "")) { string imagePath = navigator.Value; string finalImagePath = FindFinalImagePath(imagePath); SDKUtilities.DebugLine("[MyMoviesImporter] Final image path is: {0}", finalImagePath); if (File.Exists(finalImagePath)) { SDKUtilities.DebugLine("[MyMoviesImporter] This file appears to be valid, we'll set it on the title"); newTitle.FrontCoverPath = finalImagePath; } navigator.MoveToParent(); } SDKUtilities.DebugLine("[MyMoviesImporter] Scanning for {0} node", "Back"); if (navigator.MoveToChild("Back", "")) { string imagePath = navigator.Value; if (File.Exists(imagePath)) { SDKUtilities.DebugLine("[MyMoviesImporter] Found Back cover image"); newTitle.BackCoverPath = imagePath; } navigator.MoveToParent(); } navigator.MoveToParent(); } #endregion newTitle.Synopsis = GetChildNodesValue(navigator, "Description"); #region production year if (navigator.MoveToChild("ProductionYear", "")) { SDKUtilities.DebugLine("[MyMoviesImporter] Found production year, I hope the format is something we can read"); try { string year = navigator.Value; if (!string.IsNullOrEmpty(year)) { DateTime rls_date = new DateTime(int.Parse(year), 1, 1); if (rls_date != null) { SDKUtilities.DebugLine("[MyMoviesImporter] Got it, loading the production year"); newTitle.ReleaseDate = rls_date; } } navigator.MoveToParent(); } catch (Exception e) { navigator.MoveToParent(); SDKUtilities.DebugLine("[MyMoviesImporter] error reading ProductionYear: " + e.Message); } } #endregion #region parental rating (mpaa rating) if (navigator.MoveToChild("ParentalRating", "")) { SDKUtilities.DebugLine("[MyMoviesImporter] Scanning for the ParentalRating"); if (navigator.HasChildren) { string ratingId = GetChildNodesValue(navigator, "Value"); if (!string.IsNullOrEmpty(ratingId)) { int mmRatingId; if (int.TryParse(ratingId, out mmRatingId)) switch (mmRatingId) { case 0: SDKUtilities.DebugLine("[MyMoviesImporter] This appears to be unrated"); newTitle.ParentalRating = "Unrated"; break; case 1: SDKUtilities.DebugLine("[MyMoviesImporter] This appears to be rated G"); newTitle.ParentalRating = "G"; break; case 2: SDKUtilities.DebugLine("[MyMoviesImporter] I have no idea what rating this is"); break; case 3: SDKUtilities.DebugLine("[MyMoviesImporter] This appears to be rated PG"); newTitle.ParentalRating = "PG"; break; case 4: SDKUtilities.DebugLine("[MyMoviesImporter] This appears to be rated PG13"); newTitle.ParentalRating = "PG13"; break; case 5: SDKUtilities.DebugLine("[MyMoviesImporter] I have NO idea what rating this is"); break; case 6: SDKUtilities.DebugLine("[MyMoviesImporter] This appears to be rated R"); newTitle.ParentalRating = "R"; break; } else SDKUtilities.DebugLine("[MyMoviesImporter] Error parsing rating: {0} not a number", ratingId); } string ratingReason = GetChildNodesValue(navigator, "Description"); if (!string.IsNullOrEmpty(ratingReason)) newTitle.ParentalRatingReason = ratingReason; } navigator.MoveToParent(); } #endregion newTitle.Runtime = Int32.Parse(GetChildNodesValue(navigator, "RunningTime")); #region persons if (navigator.MoveToChild("Persons", "")) { SDKUtilities.DebugLine("[MyMoviesImporter] Beginning the long, painful process of scanning people"); if (navigator.HasChildren) { XPathNodeIterator nIter = navigator.SelectChildren("Person", ""); if (navigator.MoveToFirstChild()) { XPathNavigator localNav = navigator.CreateNavigator(); navigator.MoveToParent(); for (int i = 0; i < nIter.Count; i++) { string name = GetChildNodesValue(localNav, "Name"); string role = GetChildNodesValue(localNav, "Role"); string type = GetChildNodesValue(localNav, "Type"); if (!string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(type)) { switch (type) { case "Actor": SDKUtilities.DebugLine("[MyMoviesImporter] actor {0}, {1}", name, role); newTitle.AddActingRole(name, role); break; case "Director": SDKUtilities.DebugLine("[MyMoviesImporter] director {0}", name); newTitle.AddDirector(new OMLSDKPerson(name)); break; default: break; } } localNav.MoveToNext("Person", ""); } } } navigator.MoveToParent(); } #endregion #region studio (s) if (navigator.MoveToChild("Studios", "")) { SDKUtilities.DebugLine("[MyMoviesImporter] Ahh... Studios (pssst.. we only copy the last entry from here... dont tell anyone)"); if (navigator.HasChildren) { XPathNodeIterator nIter = navigator.SelectChildren("Studio", ""); if (navigator.MoveToFirstChild()) { XPathNavigator localNav = navigator.CreateNavigator(); navigator.MoveToParent(); for (int i = 0; i < nIter.Count; i++) { newTitle.Studio = localNav.Value; } } } navigator.MoveToParent(); } #endregion newTitle.CountryOfOrigin = GetChildNodesValue(navigator, "Country"); newTitle.AspectRatio = GetChildNodesValue(navigator, "AspectRatio"); newTitle.VideoStandard = GetChildNodesValue(navigator, "VideoStandard"); newTitle.OriginalName = GetChildNodesValue(navigator, "OriginalTitle"); newTitle.SortName = GetChildNodesValue(navigator, "SortTitle"); #region genres if (navigator.MoveToChild("Genres", "")) { SDKUtilities.DebugLine("[MyMoviesImporter] Genres... good old genres"); XPathNodeIterator nIter = navigator.SelectChildren("Genre", ""); if (navigator.MoveToFirstChild()) { XPathNavigator localNav = navigator.CreateNavigator(); navigator.MoveToParent(); for (int i = 0; i < nIter.Count; i++) { newTitle.AddGenre(localNav.Value); localNav.MoveToNext("Genre", ""); } } navigator.MoveToParent(); } #endregion #region audio tracks if (navigator.MoveToChild("AudioTracks", "")) { SDKUtilities.DebugLine("[MyMoviesImporter] AudioTracks.. yeah, like you can even change them anyway"); XPathNodeIterator nIter = navigator.SelectChildren("AudioTrack", ""); if (navigator.MoveToFirstChild()) { XPathNavigator localNav = navigator.CreateNavigator(); navigator.MoveToParent(); for (int i = 0; i < nIter.Count; i++) { string audioLanguage = localNav.GetAttribute("Language", ""); string audioType = localNav.GetAttribute("Type", ""); string audioChannels = localNav.GetAttribute("Channels", ""); if (!string.IsNullOrEmpty(audioLanguage)) { string audioTrackString = audioLanguage; if (!string.IsNullOrEmpty(audioType)) audioTrackString += string.Format(", {0}", audioType); if (!string.IsNullOrEmpty(audioChannels)) audioTrackString += string.Format(", {0}", audioChannels); SDKUtilities.DebugLine("[MyMoviesImporter] Got one: {0}, {1}, {2}", audioLanguage, audioType, audioChannels); newTitle.AddAudioTrack(audioTrackString); } localNav.MoveToNext("AudioTrack", ""); } } navigator.MoveToParent(); } #endregion #region watched status (Submitted by yodine from our forums) if (navigator.MoveToChild("Watched", "")) { navigator.MoveToParent(); // move back, we just wanted to know this field existed. SDKUtilities.DebugLine("[MyMoviesImporter] Found Watched status. Trying to decode"); string watched = GetChildNodesValue(navigator, "Watched"); if (!string.IsNullOrEmpty(watched)) { if (Boolean.Parse(watched)) newTitle.WatchedCount++; } } #endregion #region subtitles if (navigator.MoveToChild("Subtitles", "")) { SDKUtilities.DebugLine("[MyMoviesImporter] Subtitles here we come!"); if (navigator.GetAttribute("NotPresent", "").CompareTo("False") == 0) { XPathNodeIterator nIter = navigator.SelectChildren("Subtitle", ""); if (navigator.MoveToFirstChild()) { XPathNavigator localNav = navigator.CreateNavigator(); navigator.MoveToParent(); for (int i = 0; i < nIter.Count; i++) { string subtitleLanguage = localNav.GetAttribute("Language", ""); if (!string.IsNullOrEmpty(subtitleLanguage)) { SDKUtilities.DebugLine("[MyMoviesImporter] Subtitle {0}", subtitleLanguage); newTitle.AddSubtitle(subtitleLanguage); } localNav.MoveToNext("Subtitle", ""); } } } navigator.MoveToParent(); } #endregion #region discs if (navigator.MoveToChild("Discs", "")) { SDKUtilities.DebugLine("[MyMoviesImporter] Discs... ok here is the good one, we'll passing this off to some other method to handle."); XPathNodeIterator nIter = navigator.SelectChildren("Disc", ""); if (navigator.MoveToFirstChild()) { XPathNavigator localNav = navigator.CreateNavigator(); extractDisksFromXML(nIter, localNav, newTitle); navigator.MoveToParent(); } navigator.MoveToParent(); } #endregion }
private static void WriteElement(TextWriter writer, XPathNavigator nav, int depth, string leadIn) { writer.Write(leadIn); writer.WriteLine(nav.Name); WriteNamespaces(writer, nav, leadIn); if (nav.HasAttributes) WriteAttributes(writer, nav, leadIn); if (!nav.HasChildren) return; var childNav = nav.CreateNavigator(); childNav.MoveToFirstChild(); Traverse(writer, childNav, depth + 1); }
private static void AreXPathNavigatorsEqual(XPathNavigator nav1, XPathNavigator nav2, string message) { while (true) { if (nav1.Name != nav2.Name) { Assert.Fail("Expected element <{0}>. Actual element <{1}>.{2}", nav1.Name, nav2.Name, message); } var anav1 = nav1.CreateNavigator(); var anav2 = nav2.CreateNavigator(); var attr1 = new List<string>(); var attr2 = new List<string>(); if (anav1.MoveToFirstAttribute()) { do { attr1.Add(string.Format("{0}=\"{1}\"", anav1.Name, anav1.Value)); } while (anav1.MoveToNextAttribute()); } if (anav2.MoveToFirstAttribute()) { do { attr2.Add(string.Format("{0}=\"{1}\"", anav2.Name, anav2.Value)); } while (anav2.MoveToNextAttribute()); } AssertUtil.ContainsExactly(attr2, attr1); var cnav1 = nav1.CreateNavigator(); var cnav2 = nav2.CreateNavigator(); if (cnav1.MoveToFirstChild()) { if (cnav2.MoveToFirstChild()) { AreXPathNavigatorsEqual(cnav1, cnav2, message); } else { Assert.Fail("Expected element {0}.{1}", GetFullPath(cnav1), message); } } else if (cnav2.MoveToFirstChild()) { Assert.Fail("Unexpected element {0}.{1}", GetFullPath(cnav2), message); } if (nav1.MoveToNext()) { if (nav2.MoveToNext()) { continue; } else { Assert.Fail("Expected element {0}.{1}", GetFullPath(nav1), message); } } else if (nav2.MoveToNext()) { Assert.Fail("Unexpected element {0}.{1}", GetFullPath(nav2), message); } break; } }
private static string GetFullPath(XPathNavigator nav) { nav = nav.CreateNavigator(); var names = new Stack<string>(); names.Push(nav.Name); while (nav.MoveToParent()) { names.Push(nav.Name); } return "/" + string.Join("/", names); }
/// <summary> /// Loads this <see cref="OpmlOutline"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param> /// <returns><b>true</b> if the <see cref="OpmlOutline"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns> /// <remarks> /// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="OpmlOutline"/>. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception> public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings) { //------------------------------------------------------------ // Local members //------------------------------------------------------------ bool wasLoaded = false; //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(source, "source"); //------------------------------------------------------------ // Attempt to extract syndication information //------------------------------------------------------------ if (source.HasAttributes) { XPathNavigator attributesNavigator = source.CreateNavigator(); if (attributesNavigator.MoveToFirstAttribute()) { //------------------------------------------------------------ // Extract first attribute //------------------------------------------------------------ if (this.LoadAttribute(attributesNavigator)) { wasLoaded = true; } //------------------------------------------------------------ // Enumerate through additional attributes //------------------------------------------------------------ while (attributesNavigator.MoveToNextAttribute()) { if (this.LoadAttribute(attributesNavigator)) { wasLoaded = true; } } } } if (source.HasChildren) { XPathNodeIterator outlinesIterator = source.Select("outline"); if (outlinesIterator != null && outlinesIterator.Count > 0) { while (outlinesIterator.MoveNext()) { OpmlOutline outline = new OpmlOutline(); if (outline.Load(outlinesIterator.Current, settings)) { this.Outlines.Add(outline); wasLoaded = true; } } } } //------------------------------------------------------------ // Attempt to extract syndication extension information //------------------------------------------------------------ SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings); adapter.Fill(this); return wasLoaded; }
public override void ReadManifest(XPathNavigator manifestNav) { Package.Name = Util.ReadAttribute(manifestNav, "name", Log, Util.EXCEPTION_NameMissing); Package.PackageType = Util.ReadAttribute(manifestNav, "type", Log, Util.EXCEPTION_TypeMissing); if (Package.PackageType == "Skin" || Package.PackageType == "Container") { Package.PortalID = Package.InstallerInfo.PortalID; } CheckSecurity(); if (!IsValid) { return; } InstalledPackage = PackageController.GetPackageByName(Package.PortalID, Package.Name); Package.IsSystemPackage = bool.Parse(Util.ReadAttribute(manifestNav, "isSystem", false, Log, "", bool.FalseString)); string strVersion = Util.ReadAttribute(manifestNav, "version", Log, Util.EXCEPTION_VersionMissing); ValidateVersion(strVersion); if (!IsValid) { return; } Log.AddInfo(Util.DNN_ReadingPackage + " - " + Package.PackageType + " - " + Package.Name); Package.FriendlyName = Util.ReadElement(manifestNav, "friendlyName", Package.Name); Package.Description = Util.ReadElement(manifestNav, "description"); XPathNavigator authorNav = manifestNav.SelectSingleNode("owner"); if (authorNav != null) { Package.Owner = Util.ReadElement(authorNav, "name"); Package.Organization = Util.ReadElement(authorNav, "organization"); Package.Url = Util.ReadElement(authorNav, "url"); Package.Email = Util.ReadElement(authorNav, "email"); } XPathNavigator licenseNav = manifestNav.SelectSingleNode("license"); if (licenseNav != null) { string licenseSrc = Util.ReadAttribute(licenseNav, "src"); if (string.IsNullOrEmpty(licenseSrc)) { Package.License = licenseNav.Value; } else { Package.License = ReadTextFromFile(licenseSrc); } } if (string.IsNullOrEmpty(Package.License)) { Package.License = Util.PACKAGE_NoLicense; } XPathNavigator relNotesNav = manifestNav.SelectSingleNode("releaseNotes"); if (relNotesNav != null) { string relNotesSrc = Util.ReadAttribute(relNotesNav, "src"); if (string.IsNullOrEmpty(relNotesSrc)) { Package.ReleaseNotes = relNotesNav.Value; } else { Package.ReleaseNotes = ReadTextFromFile(relNotesSrc); } } if (string.IsNullOrEmpty(Package.License)) { Package.License = Util.PACKAGE_NoReleaseNotes; } IDependency dependency = null; foreach (XPathNavigator dependencyNav in manifestNav.CreateNavigator().Select("dependencies/dependency")) { dependency = DependencyFactory.GetDependency(dependencyNav); if (!dependency.IsValid) { Log.AddFailure(dependency.ErrorMessage); return; } } ReadComponents(manifestNav); }
private void WriteNextNode(XmlWriter writer, XPathNavigator nav, bool iterateSiblings) { if (nav.Name == "ScatterFile") { writer.WriteStartElement(nav.Name, nav.NamespaceURI); } else { writer.WriteStartElement(nav.Name); } XPathNavigator attrib = nav.CreateNavigator(); if (attrib.MoveToFirstAttribute()) { do { writer.WriteAttributeString(attrib.Name, attrib.Value); } while (attrib.MoveToNextAttribute()); } if (nav.Name == "LoadRegion") { string lrName = nav.GetAttribute("Name", ""); foreach (ExecRegion er in (m_execRegionOrderMap[lrName] as SortedList).Values) { WriteNextNode(writer, m_execRegionsToNavNode[lrName + ":" + er.Name] as XPathNavigator, false); } } /* else if (nav.Name == "ExecRegion") { string erName = nav.GetAttribute("Name", ""); foreach (FileMapping fm in (m_symOrderMap[erName] as SortedList).Values) { WriteNextNode(writer, m_symToNavNode[erName + ":" + fm.Name] as XPathNavigator, false); } } */ else { XPathNodeIterator children = nav.SelectChildren(XPathNodeType.Element); while (children.MoveNext()) { WriteNextNode(writer, children.Current, iterateSiblings); } } writer.WriteEndElement(); if (iterateSiblings && nav.MoveToNext()) { WriteNextNode(writer, nav, iterateSiblings); } }
/// ----------------------------------------------------------------------------- /// <summary> /// The ReadManifest method reads the manifest file and parses it into components. /// </summary> /// <history> /// [cnurse] 07/24/2007 created /// </history> /// ----------------------------------------------------------------------------- public override void ReadManifest(XPathNavigator manifestNav) { //Get Name Property Package.Name = Util.ReadAttribute(manifestNav, "name", Log, Util.EXCEPTION_NameMissing); //Get Type Package.PackageType = Util.ReadAttribute(manifestNav, "type", Log, Util.EXCEPTION_TypeMissing); //If Skin or Container then set PortalID if (Package.PackageType == "Skin" || Package.PackageType == "Container") { Package.PortalID = Package.InstallerInfo.PortalID; } CheckSecurity(); if (!IsValid) { return; } //Attempt to get the Package from the Data Store (see if its installed) _installedPackage = PackageController.GetPackageByName(Package.PortalID, Package.Name); //Get IsSystem Package.IsSystemPackage = bool.Parse(Util.ReadAttribute(manifestNav, "isSystem", false, Log, "", bool.FalseString)); //Get Version string strVersion = Util.ReadAttribute(manifestNav, "version", Log, Util.EXCEPTION_VersionMissing); ValidateVersion(strVersion); if (!IsValid) { return; } Log.AddInfo(Util.DNN_ReadingPackage + " - " + Package.PackageType + " - " + Package.Name); Package.FriendlyName = Util.ReadElement(manifestNav, "friendlyName", Package.Name); Package.Description = Util.ReadElement(manifestNav, "description"); XPathNavigator foldernameNav = null; Package.FolderName = String.Empty; switch (Package.PackageType) { case "Module": //In Dynamics moduels, a component:type=File can have a basePath pointing to the App_Conde folder. This is not a correct FolderName //To ensure that FolderName is DesktopModules... var folderNameValue = getSpecificFolderName(manifestNav, "components/component/files", "basePath", "DesktopModules"); if (!String.IsNullOrEmpty(folderNameValue)) Package.FolderName = folderNameValue.Replace('\\', '/'); break; case "Auth_System": foldernameNav = manifestNav.SelectSingleNode("components/component/files"); if (foldernameNav != null) Package.FolderName = Util.ReadElement(foldernameNav, "basePath").Replace('\\', '/'); break; case "Container": foldernameNav = manifestNav.SelectSingleNode("components/component/containerFiles"); if (foldernameNav != null) Package.FolderName = Globals.glbContainersPath + Util.ReadElement(foldernameNav, "containerName").Replace('\\', '/'); break; case "Skin": foldernameNav = manifestNav.SelectSingleNode("components/component/skinFiles"); if (foldernameNav != null) Package.FolderName = Globals.glbSkinsPath + Util.ReadElement(foldernameNav, "skinName").Replace('\\', '/'); break; default: break; } //Get Icon XPathNavigator iconFileNav = manifestNav.SelectSingleNode("iconFile"); if (iconFileNav != null) { if (iconFileNav.Value != string.Empty) { if (iconFileNav.Value.StartsWith("~/")) { Package.IconFile = iconFileNav.Value; } else { Package.IconFile = (String.IsNullOrEmpty(Package.FolderName) ? "" : Package.FolderName + "/") + iconFileNav.Value; Package.IconFile = (!Package.IconFile.StartsWith("~/")) ? "~/" + Package.IconFile : Package.IconFile; } } } //Get Author XPathNavigator authorNav = manifestNav.SelectSingleNode("owner"); if (authorNav != null) { Package.Owner = Util.ReadElement(authorNav, "name"); Package.Organization = Util.ReadElement(authorNav, "organization"); Package.Url = Util.ReadElement(authorNav, "url"); Package.Email = Util.ReadElement(authorNav, "email"); } //Get License XPathNavigator licenseNav = manifestNav.SelectSingleNode("license"); if (licenseNav != null) { string licenseSrc = Util.ReadAttribute(licenseNav, "src"); if (string.IsNullOrEmpty(licenseSrc)) { //Load from element Package.License = licenseNav.Value; } else { Package.License = ReadTextFromFile(licenseSrc); } } if (string.IsNullOrEmpty(Package.License)) { //Legacy Packages have no license Package.License = Util.PACKAGE_NoLicense; } //Get Release Notes XPathNavigator relNotesNav = manifestNav.SelectSingleNode("releaseNotes"); if (relNotesNav != null) { string relNotesSrc = Util.ReadAttribute(relNotesNav, "src"); if (string.IsNullOrEmpty(relNotesSrc)) { //Load from element Package.ReleaseNotes = relNotesNav.Value; } else { Package.ReleaseNotes = ReadTextFromFile(relNotesSrc); } } if (string.IsNullOrEmpty(Package.ReleaseNotes)) { //Legacy Packages have no Release Notes Package.ReleaseNotes = Util.PACKAGE_NoReleaseNotes; } //Parse the Dependencies IDependency dependency = null; foreach (XPathNavigator dependencyNav in manifestNav.CreateNavigator().Select("dependencies/dependency")) { dependency = DependencyFactory.GetDependency(dependencyNav); if (!dependency.IsValid) { Log.AddFailure(dependency.ErrorMessage); return; } } //Read Components ReadComponents(manifestNav); }
/// <summary> /// Returns the <see cref="SyndicationContentFormat"/> of the syndicated resource represented by the supplied <see cref="XPathNavigator"/>. /// </summary> /// <param name="navigator">A <see cref="XPathNavigator"/> that represents the XML data for the syndicated resource.</param> /// <returns> /// A <see cref="SyndicationContentFormat"/> enumeration value indicating the format of the syndicated resource. /// If unable to determine format, returns <see cref="SyndicationContentFormat.None"/>. /// </returns> /// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception> public static SyndicationContentFormat SyndicationContentFormatGet(XPathNavigator navigator) { //------------------------------------------------------------ // Local members //------------------------------------------------------------ SyndicationContentFormat syndicationFormat = SyndicationContentFormat.None; XPathNavigator source = null; //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(navigator, "navigator"); //------------------------------------------------------------ // Move to document element //------------------------------------------------------------ source = navigator.CreateNavigator(); if (String.IsNullOrEmpty(source.LocalName)) { source.MoveToRoot(); source.MoveToChild(XPathNodeType.Element); } //------------------------------------------------------------ // Determine syndication format based on root element name //------------------------------------------------------------ string rootElementName = source.LocalName; foreach (System.Reflection.FieldInfo fieldInfo in typeof(SyndicationContentFormat).GetFields()) { if (fieldInfo.FieldType == typeof(SyndicationContentFormat)) { SyndicationContentFormat format = (SyndicationContentFormat)Enum.Parse(fieldInfo.FieldType, fieldInfo.Name); object[] customAttributes = fieldInfo.GetCustomAttributes(typeof(EnumerationMetadataAttribute), false); if (customAttributes != null && customAttributes.Length > 0) { EnumerationMetadataAttribute enumerationMetadata = customAttributes[0] as EnumerationMetadataAttribute; if (String.Compare(rootElementName, enumerationMetadata.AlternateValue, StringComparison.OrdinalIgnoreCase) == 0) { syndicationFormat = format; break; } } } } return syndicationFormat; }
/// <summary> /// Updates the node replacing inheritdoc node with comments found. /// </summary> /// <param name="inheritDocNodeNavigator">Navigator for inheritdoc node</param> /// <param name="contentNodeNavigator">Navigator for content</param> private void UpdateNode(XPathNavigator inheritDocNodeNavigator, XPathNavigator contentNodeNavigator) { // retrieve the selection filter if specified. string selectValue = inheritDocNodeNavigator.GetAttribute("select", string.Empty); if(!string.IsNullOrEmpty(selectValue)) sourceExpression = XPathExpression.Compile(selectValue); inheritDocNodeNavigator.MoveToParent(); if(inheritDocNodeNavigator.LocalName != "comments" && inheritDocNodeNavigator.LocalName != "element") sourceExpression = XPathExpression.Compile(inheritDocNodeNavigator.LocalName); else inheritDocNodeNavigator.MoveTo(this.sourceDocument.CreateNavigator().SelectSingleNode(inheritDocExpression)); XPathNodeIterator sources = (XPathNodeIterator)contentNodeNavigator.CreateNavigator().Evaluate(sourceExpression); inheritDocNodeNavigator.DeleteSelf(); // append the source nodes to the target node foreach(XPathNavigator source in sources) inheritDocNodeNavigator.AppendChild(source); }
/// <summary> /// Constructs a new <see cref="IXmlRpcValue"/> object from the specified <see cref="XPathNavigator"/>. /// Parameters specify the XML data source and the variable where the new <see cref="IXmlRpcValue"/> object is returned. /// </summary> /// <param name="source">A <see cref="XPathNavigator"/> that represents the XML data source to be parsed.</param> /// <param name="value"> /// When this method returns, contains an object that represents the <see cref="IXmlRpcValue"/> specified by the <paramref name="source"/>, or <b>null</b> if the conversion failed. /// This parameter is passed uninitialized. /// </param> /// <returns> /// <b>true</b> if <paramref name="source"/> was converted successfully; otherwise, <b>false</b>. /// This operation returns <b>false</b> if the <paramref name="source"/> parameter is a null reference (Nothing in Visual Basic), /// or represents XML data that is not in the expected format. /// </returns> /// <remarks> /// The <paramref name="source"/> is expected to represent an XML-RPC <b>value</b> node. /// </remarks> public static bool TryParseValue(XPathNavigator source, out IXmlRpcValue value) { //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ if (source == null || String.Compare(source.Name, "value", StringComparison.OrdinalIgnoreCase) != 0) { value = null; return false; } //------------------------------------------------------------ // Attempt to perform conversion //------------------------------------------------------------ if(source.HasChildren) { XPathNavigator navigator = source.CreateNavigator(); if (navigator.MoveToFirstChild()) { if (String.Compare(navigator.Name, "i4", StringComparison.OrdinalIgnoreCase) == 0) { int scalar; if (Int32.TryParse(navigator.Value, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out scalar)) { value = new XmlRpcScalarValue(scalar); return true; } } else if (String.Compare(navigator.Name, "int", StringComparison.OrdinalIgnoreCase) == 0) { int scalar; if (Int32.TryParse(navigator.Value, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out scalar)) { value = new XmlRpcScalarValue(scalar); return true; } } else if (String.Compare(navigator.Name, "boolean", StringComparison.OrdinalIgnoreCase) == 0) { bool scalar; if (XmlRpcClient.TryParseBoolean(navigator.Value, out scalar)) { value = new XmlRpcScalarValue(scalar); return true; } } else if (String.Compare(navigator.Name, "string", StringComparison.OrdinalIgnoreCase) == 0) { value = new XmlRpcScalarValue(navigator.Value); return true; } else if (String.Compare(navigator.Name, "double", StringComparison.OrdinalIgnoreCase) == 0) { double scalar; if (Double.TryParse(navigator.Value, NumberStyles.Float, NumberFormatInfo.InvariantInfo, out scalar)) { value = new XmlRpcScalarValue(scalar); return true; } } else if (String.Compare(navigator.Name, "dateTime.iso8601", StringComparison.OrdinalIgnoreCase) == 0) { DateTime scalar; if (SyndicationDateTimeUtility.TryParseRfc3339DateTime(navigator.Value, out scalar)) { value = new XmlRpcScalarValue(scalar); return true; } } else if (String.Compare(navigator.Name, "base64", StringComparison.OrdinalIgnoreCase) == 0) { if(!String.IsNullOrEmpty(navigator.Value)) { try { byte[] data = Convert.FromBase64String(navigator.Value); value = new XmlRpcScalarValue(data); return true; } catch(FormatException) { value = null; return false; } } } else if (String.Compare(navigator.Name, "struct", StringComparison.OrdinalIgnoreCase) == 0) { XmlRpcStructureValue structure = new XmlRpcStructureValue(); if (structure.Load(source)) { value = structure; return true; } } else if (String.Compare(navigator.Name, "array", StringComparison.OrdinalIgnoreCase) == 0) { XmlRpcArrayValue array = new XmlRpcArrayValue(); if (array.Load(source)) { value = array; return true; } } } } else if (!String.IsNullOrEmpty(source.Value)) { value = new XmlRpcScalarValue(source.Value); return true; } //------------------------------------------------------------ // Conversion failed, so set result as null and return false //------------------------------------------------------------ value = null; return false; }
public Vector GetVector(XPathNavigator root) { XmlNamespaceManager nsm = FhirNamespaceManager.CreateManager(root); Structure structure = specification.GetStructureByName(root.Name); XPathNavigator node = root.CreateNavigator(); return Vector.Create(structure, node, nsm); }
private void ProcessElement(XPathNavigator navigator) { //TODO: prob a better way of doing this using the navigator if (!isFirstElement) { textWriter.Write(Environment.NewLine); } isFirstElement = false; WriteIndent(); if (navigator.LocalName.ToLower() == "pre") { isInsidePre = true; } if (navigator.LocalName == "div") { var temp = navigator.CreateNavigator(); if (temp.MoveToAttribute("id", null)) { textWriter.Write("#"); textWriter.Write(temp.Value); } else if (temp.MoveToAttribute("class", null)) { var strings = temp.Value.Split(new []{' '}, StringSplitOptions.RemoveEmptyEntries); foreach (var s in strings) { textWriter.Write("."); textWriter.Write(s); } } else { textWriter.Write("%div"); } } else if (navigator.Prefix == string.Empty) { textWriter.Write("%{0}", navigator.LocalName); CheckForAndAppendClass(navigator); } //else //{ //TODO: //Console.Write(" <{0}:{1}>",oNavigator.Prefix,oNavigator.LocalName); //Console.WriteLine("\t" + oNavigator.NamespaceURI); //} var attributeNavigator = navigator.CreateNavigator(); ProcessAttributes(attributeNavigator); indent++; }