Пример #1
0
		public JsonSerializationReader (DataContractJsonSerializer serializer, XmlReader reader, Type rootType, bool verifyObjectName)
		{
			this.serializer = serializer;
			this.reader = reader;
			this.root_type = rootType;
			this.verify_object_name = verifyObjectName;
		}
Пример #2
0
 private void BriefAction(XmlReader reader, ServiceAction action)
 {
     reader.Read ();
     foreach (Argument argument in action.Arguments.Values) {
         argument.Value = argument.RelatedStateVariable.DefaultValue;
     }
     while (Helper.ReadToNextElement (reader)) {
         if (!action.Arguments.ContainsKey (reader.Name)) {
             throw UpnpControlException.InvalidArgs ();
         }
         Argument argument = action.Arguments[reader.Name];
         if (argument.RelatedStateVariable.DataType.IsEnum) {
             try {
                 argument.Value = Enum.Parse (argument.RelatedStateVariable.DataType, reader.ReadString ());
             } catch {
                 throw UpnpControlException.ArgumentValueOutOfRange ();
             }
         } else {
             try {
                 argument.Value = Convert.ChangeType (reader.ReadString (), argument.RelatedStateVariable.DataType);
             } catch {
                 throw UpnpControlException.InvalidArgs ();
             }
             // TODO handle min, max, and step
         }
     }
     reader.Close ();
 }
Пример #3
0
    public override void gaxb_load(XmlReader reader, object _parent, Hashtable args)
    {
        base.gaxb_load(reader, _parent, args);

        if (nameExists && titleExists == false) {
            gameObject.name = name;
        }

        var prefab = Resources.Load (name);
        if (prefab == null) {
            UnityEngine.Debug.Log ("Unable to load prefab resource " + name);
            return;
        }
        GameObject clone = GameObject.Instantiate(prefab) as GameObject;
        if (clone == null) {
            UnityEngine.Debug.Log ("Unable to instantiate prefab resource " + name);
            return;
        }
        clone.transform.parent = gameObject.transform;
        clone.transform.localPosition = Vector3.zero;
        clone.transform.localRotation = Quaternion.identity;

        if (clone.renderer != null) {
            clone.gameObject.layer = PlanetUnityOverride.puCameraLayer;
            clone.renderer.material.renderQueue = scope ().getRenderQueue () + renderQueueOffset;
        }

        foreach (Transform t in clone.transform) {
            t.gameObject.layer = PlanetUnityOverride.puCameraLayer;
            if (t.renderer != null) {
                t.renderer.material.renderQueue = scope ().getRenderQueue () + renderQueueOffset;
            }
        }
    }
Пример #4
0
		private void AssertNodeValues (
			XmlReader xmlReader,
			XmlNodeType nodeType,
			int depth,
			bool isEmptyElement,
			string name,
			string prefix,
			string localName,
			string namespaceURI,
			string value,
			int attributeCount)
		{
			Assert.AreEqual (nodeType, xmlReader.NodeType, "NodeType");
			Assert.AreEqual (depth, xmlReader.Depth, "Depth");
			Assert.AreEqual (isEmptyElement, xmlReader.IsEmptyElement, "IsEmptyElement");

			Assert.AreEqual (name, xmlReader.Name, "name");

			Assert.AreEqual (prefix, xmlReader.Prefix, "prefix");

			Assert.AreEqual (localName, xmlReader.LocalName, "localName");

			Assert.AreEqual (namespaceURI, xmlReader.NamespaceURI, "namespaceURI");

			Assert.AreEqual ((value != String.Empty), xmlReader.HasValue, "hasValue");

			Assert.AreEqual (value, xmlReader.Value, "Value");

			Assert.AreEqual (attributeCount > 0, xmlReader.HasAttributes, "hasAttributes");

			Assert.AreEqual (attributeCount, xmlReader.AttributeCount, "attributeCount");
		}
Пример #5
0
        private void client_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            if (e.Error == null)
            {
                int itemsCount = 7;
                xmlReader = XmlReader.Create(new StringReader(e.Result));
                feed = SyndicationFeed.Load(xmlReader);

                List<RSSItem> itemsList = new List<RSSItem>();

                if (feed.Items.Count() < 7)
                {
                    itemsCount = feed.Items.Count();
                }

                for (int i = 0; i <= itemsCount; i++)
                {
                    RSSItem rssitem = new RSSItem();
                    rssitem.RSSTitle = feed.Items.ToList()[i].Title.Text;
                    rssitem.RSSLink = feed.Items.ToList()[i].Links[0].Uri;
                    itemsList.Add(rssitem);
                }
                RSS.ItemsSource = itemsList;
            }
        }
 /// <param name="xml">Don't set it, it's just for tests.</param>
 public static IEnumerable<string> GetSearchTags(this FunctionDescriptor member, XmlReader xml = null)
 {
     return GetMemberElement(member, xml, DocumentElementType.SearchTags)
         .Split(',')
         .Select(x => x.Trim())
         .Where(x => x != String.Empty);
 }
        private static string GetMemberElement(
            FunctionDescriptor function,
            XmlReader xml,
            DocumentElementType property,
            string paramName = "")
        {
            //customNodeDefinitions typedParameters don't have functionDescriptors
            if (function == null)
            {
                return string.Empty;
            }
            var assemblyName = function.Assembly;

            if (string.IsNullOrEmpty(assemblyName))
                return String.Empty;

            var fullyQualifiedName = MemberDocumentNode.MakeFullyQualifiedName
                (assemblyName, GetMemberElementName(function));

            if (!documentNodes.ContainsKey(fullyQualifiedName))
            {
                if (xml == null)
                    xml = DocumentationServices.GetForAssembly(function.Assembly, function.PathManager);
                LoadDataFromXml(xml, assemblyName);
            }

            MemberDocumentNode documentNode = null;
            if (documentNodes.ContainsKey(fullyQualifiedName))
                documentNode = documentNodes[fullyQualifiedName];
            else
            {
                var overloadedName = documentNodes.Keys.
                        Where(key => key.Contains(function.ClassName + "." + function.FunctionName)).FirstOrDefault();

                if (overloadedName == null)
                    return String.Empty;
                if (documentNodes.ContainsKey(overloadedName))
                    documentNode = documentNodes[overloadedName];
            }
            
            if (documentNode == null)
                return String.Empty;
            if (property.Equals(DocumentElementType.Description) && !documentNode.Parameters.ContainsKey(paramName))
                return String.Empty;

            switch (property)
            {
                case DocumentElementType.Summary:
                    return documentNode.Summary;

                case DocumentElementType.Description:
                    return documentNode.Parameters[paramName];

                case DocumentElementType.SearchTags:
                    return documentNode.SearchTags;

                default:
                    throw new ArgumentException("property");
            }
        }
Пример #8
0
        /// <summary>
        /// Decodes an <see cref="Error"/> object from its XML representation.
        /// </summary>
        public static Error Decode(XmlReader reader)
        {
            if (reader == null) throw new ArgumentNullException("reader");
            if (!reader.IsStartElement()) throw new ArgumentException("Reader is not positioned at the start of an element.", "reader");

            //
            // Read out the attributes that contain the simple
            // typed state.
            //

            var error = new Error();
            ReadXmlAttributes(reader, error);

            //
            // Move past the element. If it's not empty, then
            // read also the inner XML that contains complex
            // types like collections.
            //

            var isEmpty = reader.IsEmptyElement;
            reader.Read();

            if (!isEmpty)
            {
                ReadInnerXml(reader, error);
                reader.ReadEndElement();
            }

            return error;
        }
		public override bool CanRead (XmlReader reader)
		{
			if (reader == null)
				throw new ArgumentNullException ("reader");
			reader.MoveToContent ();
			return reader.LocalName == "service" && reader.NamespaceURI == Version;
		}
Пример #10
0
        // TwoWayRequest: Accept two integer values, return their sum
        public byte[] TwoWayRequest(WsWsaHeader header, XmlReader reader)
        {
            try
            {
                // Find beginning of request
                reader.ReadStartElement("TwoWayRequest", SimpleServiceNamespaceUri);

                // Find the values to be added
                int X = Convert.ToInt32(reader.ReadElementString("X", SimpleServiceNamespaceUri));
                int Y = Convert.ToInt32(reader.ReadElementString("Y", SimpleServiceNamespaceUri));

                Log.Comment("");
                Log.Comment("X = " + X.ToString() + " Y = " + Y.ToString());
                Log.Comment(X.ToString() + " + " + Y.ToString() + " = " + ((int)(X + Y)).ToString());
                Log.Comment("");

                // Return the response
                return TwoWayResponse(header, X + Y);
            }
            catch (Exception e)
            {
                // Something went wrong 
                throw new WsFaultException(header, WsFaultType.XmlException, e.ToString());
            }
        }
Пример #11
0
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="xml">XML to validate</param>
        /// <param name="schemaUri">Schema Uri</param>
        public DnaXmlValidator(string xml, string schemaUri)
        {
            _schemaUri = schemaUri;
            // set up the schema
            LoadSchema(schemaUri);

            // set up the xml reader
            _rawXml = xml;
            _xml = new StringReader(xml);

            // set up the settings for validating the xml
            _validationSettings = new XmlReaderSettings();
            _validationSettings.Schemas.Add(_xmlSchema);
            _validationSettings.IgnoreWhitespace = true;
            _validationSettings.ValidationFlags |= XmlSchemaValidationFlags.ProcessSchemaLocation;
            _validationSettings.ValidationFlags |= XmlSchemaValidationFlags.ReportValidationWarnings;
            _validationSettings.ValidationFlags |= XmlSchemaValidationFlags.ProcessInlineSchema;
            _validationSettings.ValidationType = ValidationType.Schema;
            try
            {
                _validationSettings.Schemas.Compile();
            }
            catch (XmlSchemaException e)
            {
                string s = e.SourceUri;
            }
            _validationSettings.ValidationEventHandler += new ValidationEventHandler(xmlReaderSettingsValidationEventHandler);
            _validationSettings.DtdProcessing = DtdProcessing.Parse;
            // set the the XmlReader for validation
            _validator = XmlReader.Create(_xml, _validationSettings);
        }
Пример #12
0
 /// <summary>Initializes a new instance of the XmlConfigFile
 /// class.</summary>
 /// <param name='reader'>A XmlReader object.</param>
 /// <param name='rootElement'>A string object.</param>
 /// <exception cref='ArgumentNullException'>The parameter <paramref
 /// name='reader'/> is null.</exception>
 private XmlConfigFile(XmlReader reader, string rootElement)
 {
     if (reader == null) {
     throw new ArgumentNullException("reader");
       }
       if (rootElement.Length == 0) {
     throw new ArgumentException("'rootElement' is empty.");
       }
       XmlDocument doc;
       try {
     doc = new XmlDocument();
     doc.Load(reader);
       } catch (IOException e) {
     throw new XmlConfigException(e.Message, e);
       } catch (UnauthorizedAccessException e) {
     throw new XmlConfigException(e.Message, e);
       } catch (XmlException e) {
     throw new XmlConfigException(e.Message, e);
       }
       if (doc.DocumentElement == null) {
     throw new XmlConfigException("The file contains no XML element.");
       }
       if (rootElement != null && !doc.DocumentElement.Name.Equals(rootElement))
     throw new XmlConfigException(
       ("The XML file's root element is " + doc.DocumentElement.Name +
     ", not " + rootElement + "."));
       this.Initialize(doc.DocumentElement);
 }
Пример #13
0
		// copy from XmlTextReaderTests
		private void AssertStartDocument (XmlReader xmlReader)
		{
			Assert.IsTrue (xmlReader.ReadState == ReadState.Initial);
			Assert.IsTrue (xmlReader.NodeType == XmlNodeType.None);
			Assert.IsTrue (xmlReader.Depth == 0);
			Assert.IsTrue (!xmlReader.EOF);
		}
Пример #14
0
 internal InternalDeserializer(XmlReader reader, DeserializationContext context)
 {
     this._reader = reader;
     this._context = context;
     this.objectRefIdHandler = new ReferenceIdHandlerForDeserializer<object>();
     this.typeRefIdHandler = new ReferenceIdHandlerForDeserializer<ConsolidatedString>();
 }
Пример #15
0
 void createPlayer(XmlReader reader)
 {
     Vector2 pos = Vector2.Zero;
     TextureMap t = new TextureMap();
     while (reader.Read())
     {
         if (reader.NodeType == XmlNodeType.Element)
         {
             switch (reader.Name)
             {
                 case "position":
                     {
                         reader.ReadToDescendant("x");
                         float x = (float)float.Parse((reader.GetAttribute(0)));
                         reader.ReadToNextSibling("y");
                         float y = (float)float.Parse((reader.GetAttribute(0)));
                         pos = new Vector2(x, y);
                     }
                     break;
                 default:
                     int o = 0;//fer teh deboog
                     break;
             }
         }
     }
     Player p = new Player(pos, t);
 }
Пример #16
0
        internal XmlNode ReadCurrentNode(XmlDocument doc, XmlReader reader)
        {
            _doc = doc;
            _reader = reader;
            // WS are optional only for loading (see XmlDocument.PreserveWhitespace)
            _preserveWhitespace = true;
            if (doc == null)
                throw new ArgumentException(SR.Xdom_Load_NoDocument);
            if (reader == null)
                throw new ArgumentException(SR.Xdom_Load_NoReader);

            if (reader.ReadState == ReadState.Initial)
            {
                reader.Read();
            }
            if (reader.ReadState == ReadState.Interactive)
            {
                XmlNode n = LoadNode(true);

                // Move to the next node
                if (n.NodeType != XmlNodeType.Attribute)
                    reader.Read();

                return n;
            }
            return null;
        }
 protected override void DeserializeElement(XmlReader reader, bool serializeCollectionKey)
 {
     base.DeserializeElement(reader, serializeCollectionKey);
     WebContext hostingContext = base.EvaluationContext.HostingContext as WebContext;
     if ((hostingContext != null) && (this.Href.Length != 0))
     {
         string path = hostingContext.Path;
         string configurationDirectory = null;
         if (path == null)
         {
             path = HostingEnvironment.ApplicationVirtualPath;
             if (path == null)
             {
                 path = "";
             }
             configurationDirectory = this.GetConfigurationDirectory();
         }
         else
         {
             configurationDirectory = HostingEnvironment.MapPath(path);
         }
         if (!path.EndsWith("/", StringComparison.Ordinal))
         {
             path = path + "/";
         }
         CheckIOReadPermission(configurationDirectory, this.Href);
         this.actualPath = configurationDirectory;
         this.virtualPath = path;
         this.needToValidateHref = true;
     }
 }
Пример #18
0
 public static XmlDocument IsWellFormed(XmlReader reader)
 {
     Assert.IsNotNull(reader);
     XmlDocument doc = new XmlDocument();
     doc.Load(reader);
     return doc;
 }
Пример #19
0
        public static void TransformNode(XmlNode element, XmlReader xslTemplate)
        {
            XmlReader reader = new XmlNodeReader(element);

              XmlReader transformResultReader = TransformXml(reader, xslTemplate, null);
              element.CreateNavigator().ReplaceSelf(transformResultReader);
        }
Пример #20
0
 public MappingOption(XmlReader xml)
 {
     Schema = xml.GetAttribute("Schema");
     Prefix = xml.GetAttribute("Prefix");
     Class = xml.GetAttribute("Class");
     Pattern = xml.GetAttribute("Pattern");
 }
        public override void ReadXml(XmlReader reader)
        {
            complexParameters.Clear();
            primitiveParameters.Clear();

            reader.MoveToContent();

            reader.ReadStartElement();

            primitiveParameters.Add("Regions", reader.ReadElementContentAsDouble());
            primitiveParameters.Add("PointsPerRegion", reader.ReadElementContentAsDouble());

            reader.MoveToFirstAttribute();

            int cnt = Int32.Parse(reader.GetAttribute("Count"));
            reader.ReadToFollowing("Requirement");
            IList<string> requirements = new List<string>();

            for (int i = 0; i < cnt; i++)
            {
                requirements.Add(reader.ReadElementContentAsString());
            }

            complexParameters.Add("Requirements", requirements);

            reader.ReadEndElement();

            primitiveParameters.Add("UseAdaptiveRandomSearch", reader.ReadElementContentAsBoolean());
            primitiveParameters.Add("OptimizationAlgorithm", reader.ReadElementContentAsString());
            reader.ReadEndElement();
        }
Пример #22
0
 public static XmlReader CreateReader(XmlReader baseReader, WhitespaceRuleLookup wsRules)
 {
     if (wsRules == null)
     {
         return baseReader;    // There is no rules to process
     }
     XmlReaderSettings readerSettings = baseReader.Settings;
     if (readerSettings != null)
     {
         if (readerSettings.IgnoreWhitespace)
         {
             return baseReader;        // V2 XmlReader that strips all WS
         }
     }
     else
     {
         XmlTextReader txtReader = baseReader as XmlTextReader;
         if (txtReader != null && txtReader.WhitespaceHandling == WhitespaceHandling.None)
         {
             return baseReader;        // V1 XmlTextReader that strips all WS
         }
         XmlTextReaderImpl txtReaderImpl = baseReader as XmlTextReaderImpl;
         if (txtReaderImpl != null && txtReaderImpl.WhitespaceHandling == WhitespaceHandling.None)
         {
             return baseReader;        // XmlTextReaderImpl that strips all WS
         }
     }
     return new WhitespaceRuleReader(baseReader, wsRules);
 }
		private void AssertNodeValues (
			XmlReader xmlReader,
			XmlNodeType nodeType,
			int depth,
			bool isEmptyElement,
			string name,
			string prefix,
			string localName,
			string namespaceURI,
			string value,
			int attributeCount)
		{
			AssertEquals ("NodeType", nodeType, xmlReader.NodeType);
			AssertEquals ("Depth", depth, xmlReader.Depth);
			AssertEquals ("IsEmptyElement", isEmptyElement, xmlReader.IsEmptyElement);

			AssertEquals ("name", name, xmlReader.Name);

			AssertEquals ("prefix", prefix, xmlReader.Prefix);

			AssertEquals ("localName", localName, xmlReader.LocalName);

			AssertEquals ("namespaceURI", namespaceURI, xmlReader.NamespaceURI);

			AssertEquals ("hasValue", (value != String.Empty), xmlReader.HasValue);

			AssertEquals ("Value", value, xmlReader.Value);

			AssertEquals ("hasAttributes", attributeCount > 0, xmlReader.HasAttributes);

			AssertEquals ("attributeCount", attributeCount, xmlReader.AttributeCount);
		}
Пример #24
0
        private ClientData(XmlReader reader)
        {
            reader.ReadStartElement("ClientData");

            for (int iter = 0; iter < _NumStoredValues; iter++) {

                reader.ReadStartElement(_StoredValueNames[iter]);

                if (_StoredValues[iter] is string)
                    _StoredValues[iter] = reader.ReadContentAsString();
                else if (_StoredValues[iter] is DateTime) {
                    string s = reader.ReadContentAsString();
                    long l = long.Parse(s, NumberStyles.HexNumber, CultureInfo.InvariantCulture);
                    _StoredValues[iter] = DateTime.FromFileTimeUtc(l);
                } else if (_StoredValues[iter] is bool) {
                    string s = reader.ReadContentAsString();
                    _StoredValues[iter] = !(string.IsNullOrEmpty(s) || s != "1");
                } else {
                    _StoredValues[iter] = ReadStringArray(reader);
                }
                reader.ReadEndElement();
            }

            reader.ReadEndElement();
        }
		public void LoadFromXml (XmlReader reader)
		{
			reader.ReadToDescendant ("plist");
			while (reader.Read () && reader.NodeType != XmlNodeType.Element);
			if (!reader.EOF)
				root = LoadFromNode (reader);
		}
Пример #26
0
 private static string GenerateCode(XmlReader reader, string nameSpace)
 {
     EntityClassGenerator generator = new EntityClassGenerator(LanguageOption.GenerateCSharpCode) {
         Version = DataServiceCodeVersion.V2
     };
     StringWriter targetWriter = new StringWriter();
     try
     {
         IList<EdmSchemaError> list = generator.GenerateCode(reader, targetWriter, nameSpace);
         if (list.Count > 0)
         {
             throw new DisplayToUserException(string.Concat(new object[] { "Bad schema: ", list[0].Message, " (line ", list[0].Line, ")" }));
         }
     }
     catch (MetadataException exception)
     {
         throw new DisplayToUserException("MetadataException: " + exception.Message);
     }
     catch (XmlSchemaValidationException exception2)
     {
         throw new DisplayToUserException("This schema is unsupported.\r\n\r\nEntityClassGenerator returned the following error: " + exception2.Message);
     }
     catch (FileNotFoundException exception3)
     {
         if (exception3.Message.Contains("System.Data.Services.Design"))
         {
             throw new DisplayToUserException("Cannot load System.Data.Services.Design.dll. (A possible cause is installing only the .NET Framework Client Profile instead of the full .NET Framework.)");
         }
         throw;
     }
     return targetWriter.ToString();
 }
Пример #27
0
        /// <summary>tries to parse a category collection document</summary> 
        /// <param name="reader"> xmlReader positioned at the start element</param>
        /// <param name="owner">the base object that the collection belongs to</param>
        /// <returns></returns>
        public AtomCategoryCollection ParseCategories(XmlReader reader, AtomBase owner) {
            Tracing.Assert(reader != null, "reader should not be null");
            if (reader == null) {
                throw new ArgumentNullException("reader");
            }
            AtomCategoryCollection ret = new AtomCategoryCollection();
            MoveToStartElement(reader);

            Tracing.TraceCall("entering Categories Parser");
            object localname = reader.LocalName;
            Tracing.TraceInfo("localname is: " + reader.LocalName);

            if (IsCurrentNameSpace(reader, BaseNameTable.AppPublishingNamespace(owner)) &&
                localname.Equals(this.nameTable.Categories)) {
                Tracing.TraceInfo("Found categories  document");
                int depth = -1;
                while (NextChildElement(reader, ref depth)) {
                    localname = reader.LocalName;
                    if (IsCurrentNameSpace(reader, BaseNameTable.NSAtom)) {
                        if (localname.Equals(this.nameTable.Category)) {
                            AtomCategory category = ParseCategory(reader, owner);
                            ret.Add(category);
                        }
                    }
                }
            } else {
                Tracing.TraceInfo("ParseCategories called and nothing was parsed" + localname);
                throw new ClientFeedException("An invalid Atom Document was passed to the parser. This was not an app:categories document: " + localname);
            }

            return ret;
        }
Пример #28
0
        public static bool ValidateXml(XmlReader reader, string customSchema, Action<string> warning, Action<string> error)
        {
            bool isValid = true;

            var schemas = GetSchemas();

            if (customSchema != null)
            {
                schemas.Add(null, XmlReader.Create(customSchema));
            }

            ValidationEventHandler handler = (s, args) =>
            {
                isValid = false;
                if (warning != null && args.Severity == XmlSeverityType.Warning)
                    warning(args.Message);
                else if (error != null)
                    error(args.Message);
            };

            var settings = new XmlReaderSettings();
            settings.ValidationType = ValidationType.Schema;
            settings.Schemas.Add(schemas);
            settings.ValidationEventHandler += handler;

            var r = XmlReader.Create(reader, settings);
            while (r.Read()) ;

            return isValid;
        }
 public XmlRpcResponse DeserializeResponse(XmlReader rdr, Type returnType)
 {
     try
     {
         IEnumerator<Node> enumerator = new XmlRpcParser().ParseResponse(rdr).GetEnumerator();
         enumerator.MoveNext();
         if (enumerator.Current is FaultNode)
             throw DeserializeFault(enumerator);
         if (returnType == typeof (void) || !enumerator.MoveNext())
         {
             return new XmlRpcResponse
                    {
                        retVal = null
                    };
         }
         Node current = enumerator.Current;
         object obj = MapValueNode(enumerator, returnType, new MappingStack("response"), MappingAction.Error);
         return new XmlRpcResponse
                {
                    retVal = obj
                };
     }
     catch (XmlException ex)
     {
         throw new XmlRpcIllFormedXmlException("Response contains invalid XML", ex);
     }
 }
 public static WebReferenceOptions Read(XmlReader xmlReader, ValidationEventHandler validationEventHandler)
 {
     WebReferenceOptions options;
     XmlValidatingReader reader = new XmlValidatingReader(xmlReader) {
         ValidationType = ValidationType.Schema
     };
     if (validationEventHandler != null)
     {
         reader.ValidationEventHandler += validationEventHandler;
     }
     else
     {
         reader.ValidationEventHandler += new ValidationEventHandler(WebReferenceOptions.SchemaValidationHandler);
     }
     reader.Schemas.Add(Schema);
     webReferenceOptionsSerializer serializer = new webReferenceOptionsSerializer();
     try
     {
         options = (WebReferenceOptions) serializer.Deserialize(reader);
     }
     catch (Exception exception)
     {
         throw exception;
     }
     finally
     {
         reader.Close();
     }
     return options;
 }
Пример #31
0
        protected static IList <object> ParseResult(TextReader textReader, CpAction action, bool sourceSupportsUPnP11)
        {
            object[] outParameterValues = new object[action.OutArguments.Count];
            using (XmlReader reader = XmlReader.Create(textReader, UPnPConfiguration.DEFAULT_XML_READER_SETTINGS))
            {
                reader.MoveToContent();
                // Parse SOAP envelope
                reader.ReadStartElement("Envelope", UPnPConsts.NS_SOAP_ENVELOPE);
                reader.ReadStartElement("Body", UPnPConsts.NS_SOAP_ENVELOPE);
                // Reader is positioned at the action element
                string serviceTypeVersion_URN = reader.NamespaceURI;
                string type;
                int    version;
                // Parse service and action
                if (!ParserHelper.TryParseTypeVersion_URN(serviceTypeVersion_URN, out type, out version))
                {
                    throw new ArgumentException("Invalid service type or version");
                }
                string actionName = reader.LocalName;
                if (!actionName.EndsWith("Response") ||
                    actionName.Substring(0, actionName.Length - "Response".Length) != action.Name)
                {
                    throw new ArgumentException("Invalid action name in result message");
                }

                // UPnP spec says we have to be able to handle return values being out
                // of order to support UPnP 1.0 devices. See UPnP-arch-DeviceArchitecture-v1.1
                // section 2.5.4. We need a dictionary to make this easy.
                IDictionary <string, int> formalArgIdxDictionary = new Dictionary <string, int>();
                for (int i = 0; i < action.OutArguments.Count; i++)
                {
                    formalArgIdxDictionary.Add(action.OutArguments[i].Name, i);
                }

                int outArgCount = 0;
                if (!SoapHelper.ReadEmptyStartElement(reader))
                {
                    // Parse and check output parameters
                    while (reader.NodeType != XmlNodeType.EndElement)
                    {
                        string argumentName = reader.Name; // Arguments don't have a namespace, so take full name
                        int    formalArgumentIndex;
                        if (!formalArgIdxDictionary.TryGetValue(argumentName, out formalArgumentIndex))
                        {
                            throw new ArgumentException("Invalid argument name");
                        }
                        CpArgument formalArgument = action.OutArguments[formalArgumentIndex];

                        // Get the argument value and store it in the correct position in the return list.
                        object value = null;
                        if (!SoapHelper.ReadNull(reader))
                        {
                            formalArgument.SoapParseArgument(reader, !sourceSupportsUPnP11, out value);
                        }
                        outParameterValues[formalArgumentIndex] = value;
                        outArgCount++;

                        // Don't allow duplicates of the same argument.
                        formalArgIdxDictionary.Remove(formalArgument.Name);
                    }
                }
                if (outArgCount != action.OutArguments.Count) // Too few arguments
                {
                    throw new ArgumentException("Invalid out argument count");
                }
            }
            return(outParameterValues);
        }
Пример #32
0
        private bool SetPropertyFromReader(XmlReader reader, SsdpDevice device)
        {
            switch (reader.LocalName)
            {
            case "friendlyName":
                device.FriendlyName = reader.ReadElementContentAsString();
                break;

            case "manufacturer":
                device.Manufacturer = reader.ReadElementContentAsString();
                break;

            case "manufacturerURL":
                device.ManufacturerUrl = StringToUri(reader.ReadElementContentAsString());
                break;

            case "modelDescription":
                device.ModelDescription = reader.ReadElementContentAsString();
                break;

            case "modelName":
                device.ModelName = reader.ReadElementContentAsString();
                break;

            case "modelNumber":
                device.ModelNumber = reader.ReadElementContentAsString();
                break;

            case "modelURL":
                device.ModelUrl = StringToUri(reader.ReadElementContentAsString());
                break;

            case "presentationURL":
                device.PresentationUrl = StringToUri(reader.ReadElementContentAsString());
                break;

            case "serialNumber":
                device.SerialNumber = reader.ReadElementContentAsString();
                break;

            case "UDN":
                device.Udn = reader.ReadElementContentAsString();
                SetUuidFromUdn(device);
                break;

            case "UPC":
                device.Upc = reader.ReadElementContentAsString();
                break;

            case "deviceType":
                SetDeviceTypePropertiesFromFullDeviceType(device, reader.ReadElementContentAsString());
                break;

            case "iconList":
                reader.Read();
                LoadIcons(reader, device);
                break;

            case "deviceList":
                reader.Read();
                LoadChildDevices(reader, device);
                break;

            case "serviceList":
                reader.Skip();
                break;

            default:
                if (reader.NodeType == XmlNodeType.Element && reader.Name != "device" && reader.Name != "icon")
                {
                    AddCustomProperty(reader, device);
                    break;
                }
                else
                {
                    return(false);
                }
            }
            return(true);
        }
Пример #33
0
        private Task ReadTitlesFile()
        {
            return(Task.Run(() =>
            {
                _logger.Debug("Loading AniDB titles");

                var titlesFile = _downloader.TitlesFilePath;

                var settings = new XmlReaderSettings
                {
                    CheckCharacters = false,
                    IgnoreProcessingInstructions = true,
                    IgnoreComments = true,
                    ValidationType = ValidationType.None
                };

                using (var stream = new StreamReader(titlesFile, Encoding.UTF8))
                    using (var reader = XmlReader.Create(stream, settings))
                    {
                        string aid = null;

                        while (reader.Read())
                        {
                            if (reader.NodeType == XmlNodeType.Element)
                            {
                                switch (reader.Name)
                                {
                                case "anime":
                                    reader.MoveToAttribute("aid");
                                    aid = reader.Value;
                                    break;

                                case "title":
                                    var title = reader.ReadElementContentAsString();
                                    if (!string.IsNullOrEmpty(aid) && !string.IsNullOrEmpty(title))
                                    {
                                        var type = ParseType(reader.GetAttribute("type"));

                                        if (!_titles.TryGetValue(title, out TitleInfo currentTitleInfo) || (int)currentTitleInfo.Type < (int)type)
                                        {
                                            _titles[title] = new TitleInfo {
                                                AniDbId = aid, Type = type, Title = title
                                            };
                                        }
                                    }
                                    break;
                                }
                            }
                        }
                    }

                var comparable = (from pair in _titles
                                  let comp = GetComparableName(pair.Key)
                                             where !_titles.ContainsKey(comp)
                                             select new { Title = comp, Id = pair.Value })
                                 .ToArray();

                foreach (var pair in comparable)
                {
                    _titles[pair.Title] = pair.Id;
                }
            }));
        }
Пример #34
0
        public HashSet <User> ReadData(string filename)
        {
            HashSet <User> users = new HashSet <User>();

            //XmlDocument doc = new XmlDocument();
            //doc.Load(filename);
            //foreach (XmlNode node in doc.DocumentElement.ChildNodes)
            //{
            //    string blah = node.Name;
            //}
            //return users;

            try
            {
                using (XmlReader reader = XmlReader.Create(filename))
                {
                    bool done = false;
                    while (!done && reader.Read())
                    {
                        if (reader.IsStartElement())
                        {
                            switch (reader.Name)
                            {
                            case "User":
                                string[] name = reader.ReadInnerXml().Split(" ".ToCharArray());
                                User     temp = new User(name[0], name[1]);
                                while (reader.Read())
                                {
                                    if (reader.IsStartElement())
                                    {
                                        switch (reader.Name.Substring(0, 3))
                                        {
                                        case "day":
                                            string          day        = reader.Name;
                                            List <Activity> activities = new List <Activity>();
                                            reader.ReadToDescendant("ActivityDATA");
                                            while (reader.Name != day)
                                            {
                                                reader.ReadToDescendant("Activity");
                                                string activity = reader.ReadInnerXml();
                                                reader.ReadToNextSibling("HappyLevel");
                                                string happpylevel = reader.ReadInnerXml();
                                                reader.ReadToNextSibling("Time");
                                                string time = reader.ReadInnerXml();
                                                reader.ReadToNextSibling("Location");
                                                string location = reader.ReadInnerXml();
                                                activities.Add(new Activity(time, activity, happpylevel, location));
                                                reader.MoveToContent();
                                                reader.ReadToNextSibling("ActivityDATA");
                                            }
                                            temp.Days.Add(day, activities);
                                            break;

                                        case "Use":
                                            done = true;
                                            break;
                                        }
                                    }
                                }
                                users.Add(temp);
                                break;
                            }
                        }
                    }
                }
                return(users);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
Пример #35
0
        private static SecurityKeyIdentifierClause ReadX509IssuerSerialKeyIdentifierClause(XmlReader reader)
        {
            reader.ReadStartElement("X509IssuerSerial", SignedXml.XmlDsigNamespaceUrl);
            reader.ReadStartElement("X509IssuerName", SignedXml.XmlDsigNamespaceUrl);
            string issuerName = reader.ReadContentAsString();

            reader.ReadEndElement();
            reader.ReadStartElement("X509SerialNumber", SignedXml.XmlDsigNamespaceUrl);
            string serialNumber = reader.ReadContentAsString();

            reader.ReadEndElement();
            reader.ReadEndElement();

            return(new X509IssuerSerialKeyIdentifierClause(issuerName, serialNumber));
        }
Пример #36
0
        private void ParseWasspWithXmlReader(string wasspFile, Object.File file)
        {
            try
            {
                XmlReaderSettings xmlReaderSettings = GenerateXmlReaderSettings();
                if (DatabaseBuilder.sqliteConnection.State.ToString().Equals("Closed"))
                {
                    DatabaseBuilder.sqliteConnection.Open();
                }
                using (SQLiteTransaction sqliteTransaction = DatabaseBuilder.sqliteConnection.BeginTransaction())
                {
                    using (SQLiteCommand sqliteCommand = DatabaseBuilder.sqliteConnection.CreateCommand())
                    {
                        databaseInterface.InsertParameterPlaceholders(sqliteCommand);
                        sqliteCommand.Parameters["FindingType"].Value   = "WASSP";
                        sqliteCommand.Parameters["GroupName"].Value     = string.IsNullOrWhiteSpace(_groupName) ? "All" : _groupName;
                        sqliteCommand.Parameters["SourceName"].Value    = "Windows Automated Security Scanning Program (WASSP)";
                        sqliteCommand.Parameters["SourceVersion"].Value = string.Empty;
                        sqliteCommand.Parameters["SourceRelease"].Value = string.Empty;
                        databaseInterface.InsertParsedFileSource(sqliteCommand, file);
                        using (XmlReader xmlReader = XmlReader.Create(wasspFile, xmlReaderSettings))
                        {
                            while (xmlReader.Read())
                            {
                                if (xmlReader.IsStartElement() && xmlReader.Name.Equals("table"))
                                {
                                    while (xmlReader.Read())
                                    {
                                        if (xmlReader.NodeType == XmlNodeType.Element)
                                        {
                                            switch (xmlReader.Name)
                                            {
                                            case "MachineInfo":
                                            {
                                                sqliteCommand.Parameters["DiscoveredHostName"].Value = ObtainItemValue(xmlReader).Trim();
                                                sqliteCommand.Parameters["DisplayedHostName"].Value  = sqliteCommand.Parameters["DiscoveredHostName"].Value;
                                                break;
                                            }

                                            case "TestInfo":
                                            {
                                                sqliteCommand.Parameters["UniqueVulnerabilityIdentifier"].Value = ObtainItemValue(xmlReader);
                                                break;
                                            }

                                            case "DateInfo":
                                            {
                                                string dateTime = ObtainItemValue(xmlReader).Replace("\n", string.Empty);
                                                sqliteCommand.Parameters["FirstDiscovered"].Value = DateTime.ParseExact(
                                                    dateTime, "ddd MMM dd HH:mm:ss yyyy", CultureInfo.InvariantCulture).ToShortDateString();
                                                sqliteCommand.Parameters["LastObserved"].Value = sqliteCommand.Parameters["FirstDiscovered"].Value;
                                                break;
                                            }

                                            case "ValueInfo":
                                            {
                                                sqliteCommand.Parameters["VulnerabilityTitle"].Value = ObtainItemValue(xmlReader);
                                                break;
                                            }

                                            case "DescriptionInfo":
                                            {
                                                sqliteCommand.Parameters["VulnerabilityDescription"].Value = ObtainItemValue(xmlReader);
                                                break;
                                            }

                                            case "TestRes":
                                            {
                                                sqliteCommand.Parameters["Status"].Value = ObtainItemValue(xmlReader).ToVulneratorStatus();
                                                break;
                                            }

                                            case "VulnInfo":
                                            {
                                                sqliteCommand.Parameters["PrimaryRawRiskIndicator"].Value = ObtainItemValue(xmlReader).ToRawRisk();
                                                break;
                                            }

                                            case "RecInfo":
                                            {
                                                sqliteCommand.Parameters["FixText"].Value = ObtainItemValue(xmlReader);
                                                break;
                                            }
                                            }
                                        }
                                        else if (xmlReader.NodeType == XmlNodeType.EndElement && xmlReader.Name.Equals("table"))
                                        {
                                            sqliteCommand.Parameters["DeltaAnalysisIsRequired"].Value = "False";
                                            if (sqliteCommand.Parameters["VulnerabilityVersion"].Value == DBNull.Value)
                                            {
                                                sqliteCommand.Parameters["VulnerabilityVersion"].Value = string.Empty;
                                            }
                                            if (sqliteCommand.Parameters["VulnerabilityRelease"].Value == DBNull.Value)
                                            {
                                                sqliteCommand.Parameters["VulnerabilityRelease"].Value = string.Empty;
                                            }
                                            databaseInterface.InsertVulnerabilitySource(sqliteCommand);
                                            databaseInterface.InsertHardware(sqliteCommand);
                                            databaseInterface.InsertVulnerability(sqliteCommand);
                                            databaseInterface.MapVulnerabilityToSource(sqliteCommand);
                                            databaseInterface.UpdateUniqueFinding(sqliteCommand);
                                            databaseInterface.InsertUniqueFinding(sqliteCommand);
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                    sqliteTransaction.Commit();
                }
            }
            catch (Exception exception)
            {
                LogWriter.LogError("Unable to parse WASSP file with XML reader.");
                throw exception;
            }
            finally
            { DatabaseBuilder.sqliteConnection.Close(); }
        }
Пример #37
0
 /// <summary>
 /// Event GetStatus stub.
 /// </summary>
 /// <param name="header">Header object.</param>
 /// <param name="reader">An XmlReader positioned at the begining of the GetStatus request body element.</param>
 /// <returns>Byte array containing an GetStatus response.</returns>
 /// <remarks>This method is used by the stack framework. Do not use this method.</remarks>
 public byte[] GetStatus(WsWsaHeader header, XmlReader reader)
 {
     // Call SubscriptionManagers global eventing method
     return Device.SubscriptionManager.GetStatus(header, reader, Device.HostedServices);
 }
Пример #38
0
        public static XmlReader Create(Stream partStream, XmlReaderSettings settings, bool strictRelationshipFound)
        {
            XmlReader xmlReader = XmlReader.Create(partStream, settings);

            return(new XmlConvertingReader(xmlReader, strictRelationshipFound));
        }
Пример #39
0
        /// <summary>
        /// Gets all private assembly search paths as found in the module's <c>.config</c> file.
        /// </summary>
        /// <param name="module">The module or <c>null</c> if unknown</param>
        /// <returns>A list of search paths</returns>
        protected IEnumerable <string> GetModulePrivateSearchPaths(ModuleDef module)
        {
            if (module == null)
            {
                return(new string[0]);
            }
            var asm = module.Assembly;

            if (asm == null)
            {
                return(new string[0]);
            }
            module = asm.ManifestModule;
            if (module == null)
            {
                return(new string[0]);                  // Should never happen
            }
            string baseDir = null;

            try {
                var imageName = module.Location;
                if (imageName != string.Empty)
                {
                    baseDir = Directory.GetParent(imageName).FullName;
                    var configName = imageName + ".config";
                    if (File.Exists(configName))
                    {
                        return(GetPrivatePaths(baseDir, configName));
                    }
                }
            }
            catch {
            }
            if (baseDir != null)
            {
                return new List <string> {
                           baseDir
                }
            }
            ;
            return(new string[0]);
        }

        IEnumerable <string> GetPrivatePaths(string baseDir, string configFileName)
        {
            var searchPaths = new List <string>();

            try {
                var dirName = Path.GetDirectoryName(Path.GetFullPath(configFileName));

                searchPaths.Add(dirName);

                using (var xmlStream = new FileStream(configFileName, FileMode.Open, FileAccess.Read, FileShare.Read)) {
                    var doc = new XmlDocument();
                    doc.Load(XmlReader.Create(xmlStream));
                    foreach (var tmp in doc.GetElementsByTagName("probing"))
                    {
                        var probingElem = tmp as XmlElement;
                        if (probingElem == null)
                        {
                            continue;
                        }
                        var privatePath = probingElem.GetAttribute("privatePath");
                        if (string.IsNullOrEmpty(privatePath))
                        {
                            continue;
                        }
                        foreach (var tmp2 in privatePath.Split(';'))
                        {
                            var path = tmp2.Trim();
                            if (path == "")
                            {
                                continue;
                            }
                            var newPath = Path.GetFullPath(Path.Combine(dirName, path.Replace('\\', Path.DirectorySeparatorChar)));
                            if (Directory.Exists(newPath) && newPath.StartsWith(baseDir + Path.DirectorySeparatorChar))
                            {
                                searchPaths.Add(newPath);
                            }
                        }
                    }
                }
            }
            catch (ArgumentException) {
            }
            catch (IOException) {
            }
            catch (XmlException) {
            }

            return(searchPaths);
        }
Пример #40
0
        public static XmlReader Create(TextReader textReader, bool strictRelationshipFound)
        {
            XmlReader xmlReader = XmlReader.Create(textReader);

            return(new XmlConvertingReader(xmlReader, strictRelationshipFound));
        }
Пример #41
0
        static void ParseXamlElementFor(IElementNode node, XmlReader reader)
        {
            Debug.Assert(reader.NodeType == XmlNodeType.Element);

            var elementName = reader.Name;
            var isEmpty     = reader.IsEmptyElement;

            if (isEmpty)
            {
                return;
            }

            while (reader.Read())
            {
                switch (reader.NodeType)
                {
                case XmlNodeType.EndElement:
                    Debug.Assert(reader.Name == elementName);                             //make sure we close the right element
                    return;

                case XmlNodeType.Element:
                    // 1. Property Element.
                    if (reader.Name.Contains("."))
                    {
                        XmlName name;
                        if (reader.Name.StartsWith(elementName + ".", StringComparison.Ordinal))
                        {
                            name = new XmlName(reader.NamespaceURI, reader.Name.Substring(elementName.Length + 1));
                        }
                        else                                 //Attached BP
                        {
                            name = new XmlName(reader.NamespaceURI, reader.LocalName);
                        }

                        if (reader.IsEmptyElement)
                        {
                            throw new XamlParseException($"Unexpected empty element '<{reader.Name}/>'", (IXmlLineInfo)reader);
                        }
                        var prop = ReadNode(reader);
                        if (prop != null)
                        {
                            node.Properties.Add(name, prop);
                        }
                    }
                    // 2. Xaml2009 primitives, x:Arguments, ...
                    else if (reader.NamespaceURI == X2009Uri && reader.LocalName == "Arguments")
                    {
                        var prop = ReadNode(reader);
                        if (prop != null)
                        {
                            node.Properties.Add(XmlName.xArguments, prop);
                        }
                    }
                    // 3. DataTemplate (should be handled by 4.)
                    else if (node.XmlType.NamespaceUri == XFUri &&
                             (node.XmlType.Name == "DataTemplate" || node.XmlType.Name == "ControlTemplate"))
                    {
                        var prop = ReadNode(reader, true);
                        if (prop != null)
                        {
                            node.Properties.Add(XmlName._CreateContent, prop);
                        }
                    }
                    // 4. Implicit content, implicit collection, or collection syntax. Add to CollectionItems, resolve case later.
                    else
                    {
                        var item = ReadNode(reader, true);
                        if (item != null)
                        {
                            node.CollectionItems.Add(item);
                        }
                    }
                    break;

                case XmlNodeType.Whitespace:
                    break;

                case XmlNodeType.Text:
                case XmlNodeType.CDATA:
                    if (node.CollectionItems.Count == 1 && node.CollectionItems[0] is ValueNode)
                    {
                        ((ValueNode)node.CollectionItems[0]).Value += reader.Value.Trim();
                    }
                    else
                    {
                        node.CollectionItems.Add(new ValueNode(reader.Value.Trim(), (IXmlNamespaceResolver)reader));
                    }
                    break;

                default:
                    Debug.WriteLine("Unhandled node {0} {1} {2}", reader.NodeType, reader.Name, reader.Value);
                    break;
                }
            }
        }
Пример #42
0
        public ConexionXML DatosConexion()
        {
            ConexionXML con = new ConexionXML();

            try
            {
                using (XmlReader reader = XmlReader.Create("conexion.xml"))
                {
                    while (reader.Read())
                    {
                        if (reader.IsStartElement())
                        {
                            switch (reader.Name)
                            {
                            case "Server":
                                if (reader.Read())
                                {
                                    con.Server = reader.Value.Trim();
                                }
                                break;

                            case "Database":

                                if (reader.Read())
                                {
                                    con.Database = reader.Value.Trim();
                                }
                                break;

                            case "Uid":

                                if (reader.Read())
                                {
                                    con.Uid = reader.Value.Trim();
                                }
                                break;

                            case "Pwd":

                                if (reader.Read())
                                {
                                    con.Pwd = reader.Value.Trim();
                                }
                                break;
                            }
                        }
                    }
                }
            }
            catch (XmlException ex)
            {
                new Logcat(string.Join(" ", ex.Source, ex.ToString()));
            }
            catch (InvalidOperationException ex)
            {
                new Logcat(string.Join(" ", ex.Source, ex.ToString()));
            }
            catch (Exception ex)
            {
                new Logcat(string.Join(" ", ex.Source, ex.ToString()));
            }

            return(con);
        }
Пример #43
0
        static INode ReadNode(XmlReader reader, bool nested = false)
        {
            var skipFirstRead = nested;

            Debug.Assert(reader.NodeType == XmlNodeType.Element);
            var          name  = reader.Name;
            List <INode> nodes = new List <INode>();
            INode        node  = null;

            while (skipFirstRead || reader.Read())
            {
                skipFirstRead = false;

                switch (reader.NodeType)
                {
                case XmlNodeType.EndElement:
                    Debug.Assert(reader.Name == name);
                    if (nodes.Count == 0)                             //Empty element
                    {
                        return(null);
                    }
                    if (nodes.Count == 1)
                    {
                        return(nodes[0]);
                    }
                    return(new ListNode(nodes, (IXmlNamespaceResolver)reader, ((IXmlLineInfo)reader).LineNumber,
                                        ((IXmlLineInfo)reader).LinePosition));

                case XmlNodeType.Element:
                    var isEmpty        = reader.IsEmptyElement && reader.Name == name;
                    var elementName    = reader.Name;
                    var elementNsUri   = reader.NamespaceURI;
                    var elementXmlInfo = (IXmlLineInfo)reader;
                    IList <KeyValuePair <string, string> > xmlns;

                    var attributes = ParseXamlAttributes(reader, out xmlns);
                    var prefixes   = PrefixesToIgnore(xmlns);

                    IList <XmlType> typeArguments = null;
                    if (attributes.Any(kvp => kvp.Key == XmlName.xTypeArguments))
                    {
                        typeArguments =
                            ((ValueNode)attributes.First(kvp => kvp.Key == XmlName.xTypeArguments).Value).Value as IList <XmlType>;
                    }

                    node = new ElementNode(new XmlType(elementNsUri, elementName, typeArguments), elementNsUri,
                                           reader as IXmlNamespaceResolver, elementXmlInfo.LineNumber, elementXmlInfo.LinePosition);
                    ((IElementNode)node).Properties.AddRange(attributes);
                    (node.IgnorablePrefixes ?? (node.IgnorablePrefixes = new List <string>())).AddRange(prefixes);

                    ParseXamlElementFor((IElementNode)node, reader);
                    nodes.Add(node);
                    if (isEmpty || nested)
                    {
                        return(node);
                    }
                    break;

                case XmlNodeType.Text:
                    node = new ValueNode(reader.Value.Trim(), (IXmlNamespaceResolver)reader, ((IXmlLineInfo)reader).LineNumber,
                                         ((IXmlLineInfo)reader).LinePosition);
                    nodes.Add(node);
                    break;

                case XmlNodeType.Whitespace:
                    break;

                default:
                    Debug.WriteLine("Unhandled node {0} {1} {2}", reader.NodeType, reader.Name, reader.Value);
                    break;
                }
            }
            throw new XamlParseException("Closing PropertyElement expected", (IXmlLineInfo)reader);
        }
 public override bool CanDeserialize(XmlReader xmlReader)
 {
     return(xmlReader.IsStartElement("CommonMethodMetadata", ""));
 }
Пример #45
0
        public override string ToText(Subtitle subtitle, string title)
        {
            var ss = Configuration.Settings.SubtitleSettings;

            if (!string.IsNullOrEmpty(ss.CurrentDCinemaEditRate))
            {
                string[] temp = ss.CurrentDCinemaEditRate.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                double   d1, d2;
                if (temp.Length == 2 && double.TryParse(temp[0], out d1) && double.TryParse(temp[1], out d2))
                {
                    _frameRate = d1 / d2;
                }
            }

            string xmlStructure =
                "<dcst:SubtitleReel xmlns:dcst=\"http://www.smpte-ra.org/schemas/428-7/2007/DCST\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">" + Environment.NewLine +
                "  <dcst:Id>urn:uuid:7be835a3-cfb4-43d0-bb4b-f0b4c95e962e</dcst:Id>" + Environment.NewLine +
                "  <dcst:ContentTitleText></dcst:ContentTitleText> " + Environment.NewLine +
                "  <dcst:AnnotationText>This is a subtitle file</dcst:AnnotationText>" + Environment.NewLine +
                "  <dcst:IssueDate>2012-06-26T12:33:59.000-00:00</dcst:IssueDate>" + Environment.NewLine +
                "  <dcst:ReelNumber>1</dcst:ReelNumber>" + Environment.NewLine +
                "  <dcst:Language>en</dcst:Language>" + Environment.NewLine +
                "  <dcst:EditRate>25 1</dcst:EditRate>" + Environment.NewLine +
                "  <dcst:TimeCodeRate>25</dcst:TimeCodeRate>" + Environment.NewLine +
                "  <dcst:StartTime>00:00:00:00</dcst:StartTime> " + Environment.NewLine +
                "  <dcst:LoadFont ID=\"theFontId\">urn:uuid:3dec6dc0-39d0-498d-97d0-928d2eb78391</dcst:LoadFont>" + Environment.NewLine +
                "  <dcst:SubtitleList>" + Environment.NewLine +
                "    <dcst:Font ID=\"theFontId\" Size=\"39\" Weight=\"normal\" Color=\"FFFFFFFF\" Effect=\"border\" EffectColor=\"FF000000\">" + Environment.NewLine +
                "    </dcst:Font>" + Environment.NewLine +
                "  </dcst:SubtitleList>" + Environment.NewLine +
                "</dcst:SubtitleReel>";

            var xml = new XmlDocument();

            xml.LoadXml(xmlStructure);
            xml.PreserveWhitespace = true;
            var nsmgr = new XmlNamespaceManager(xml.NameTable);

            nsmgr.AddNamespace("dcst", xml.DocumentElement.NamespaceURI);

            if (string.IsNullOrEmpty(ss.CurrentDCinemaMovieTitle))
            {
                ss.CurrentDCinemaMovieTitle = title;
            }

            if (ss.CurrentDCinemaFontSize == 0 || string.IsNullOrEmpty(ss.CurrentDCinemaFontEffect))
            {
                Configuration.Settings.SubtitleSettings.InitializeDCinameSettings(true);
            }

            xml.DocumentElement.SelectSingleNode("dcst:ContentTitleText", nsmgr).InnerText = ss.CurrentDCinemaMovieTitle;
            if (string.IsNullOrEmpty(ss.CurrentDCinemaSubtitleId) || !ss.CurrentDCinemaSubtitleId.StartsWith("urn:uuid:"))
            {
                ss.CurrentDCinemaSubtitleId = "urn:uuid:" + Guid.NewGuid();
            }
            xml.DocumentElement.SelectSingleNode("dcst:Id", nsmgr).InnerText         = ss.CurrentDCinemaSubtitleId;
            xml.DocumentElement.SelectSingleNode("dcst:ReelNumber", nsmgr).InnerText = ss.CurrentDCinemaReelNumber;
            xml.DocumentElement.SelectSingleNode("dcst:IssueDate", nsmgr).InnerText  = ss.CurrentDCinemaIssueDate;
            if (string.IsNullOrEmpty(ss.CurrentDCinemaLanguage))
            {
                ss.CurrentDCinemaLanguage = "en";
            }
            xml.DocumentElement.SelectSingleNode("dcst:Language", nsmgr).InnerText = ss.CurrentDCinemaLanguage;
            if (ss.CurrentDCinemaEditRate == null && ss.CurrentDCinemaTimeCodeRate == null)
            {
                if (Configuration.Settings.General.CurrentFrameRate == 24)
                {
                    ss.CurrentDCinemaEditRate     = "24 1";
                    ss.CurrentDCinemaTimeCodeRate = "24";
                }
                else
                {
                    ss.CurrentDCinemaEditRate     = "25 1";
                    ss.CurrentDCinemaTimeCodeRate = "25";
                }
            }
            xml.DocumentElement.SelectSingleNode("dcst:EditRate", nsmgr).InnerText     = ss.CurrentDCinemaEditRate;
            xml.DocumentElement.SelectSingleNode("dcst:TimeCodeRate", nsmgr).InnerText = ss.CurrentDCinemaTimeCodeRate;
            if (string.IsNullOrEmpty(ss.CurrentDCinemaStartTime))
            {
                ss.CurrentDCinemaStartTime = "00:00:00:00";
            }
            xml.DocumentElement.SelectSingleNode("dcst:StartTime", nsmgr).InnerText = ss.CurrentDCinemaStartTime;
            xml.DocumentElement.SelectSingleNode("dcst:LoadFont", nsmgr).InnerText  = ss.CurrentDCinemaFontUri;
            int    fontSize     = ss.CurrentDCinemaFontSize;
            string loadedFontId = "Font1";

            if (!string.IsNullOrEmpty(ss.CurrentDCinemaFontId))
            {
                loadedFontId = ss.CurrentDCinemaFontId;
            }
            xml.DocumentElement.SelectSingleNode("dcst:LoadFont", nsmgr).Attributes["ID"].Value = loadedFontId;
            xml.DocumentElement.SelectSingleNode("dcst:SubtitleList/dcst:Font", nsmgr).Attributes["Size"].Value        = fontSize.ToString();
            xml.DocumentElement.SelectSingleNode("dcst:SubtitleList/dcst:Font", nsmgr).Attributes["Color"].Value       = "FF" + Utilities.ColorToHex(ss.CurrentDCinemaFontColor).TrimStart('#').ToUpper();
            xml.DocumentElement.SelectSingleNode("dcst:SubtitleList/dcst:Font", nsmgr).Attributes["ID"].Value          = loadedFontId;
            xml.DocumentElement.SelectSingleNode("dcst:SubtitleList/dcst:Font", nsmgr).Attributes["Effect"].Value      = ss.CurrentDCinemaFontEffect;
            xml.DocumentElement.SelectSingleNode("dcst:SubtitleList/dcst:Font", nsmgr).Attributes["EffectColor"].Value = "FF" + Utilities.ColorToHex(ss.CurrentDCinemaFontEffectColor).TrimStart('#').ToUpper();

            XmlNode mainListFont = xml.DocumentElement.SelectSingleNode("dcst:SubtitleList/dcst:Font", nsmgr);
            int     no           = 0;

            foreach (Paragraph p in subtitle.Paragraphs)
            {
                if (p.Text != null)
                {
                    XmlNode subNode = xml.CreateElement("dcst:Subtitle", "dcst");

                    XmlAttribute id = xml.CreateAttribute("SpotNumber");
                    id.InnerText = (no + 1).ToString();
                    subNode.Attributes.Append(id);

                    XmlAttribute fadeUpTime = xml.CreateAttribute("FadeUpTime");
                    fadeUpTime.InnerText = "00:00:00:00"; //Configuration.Settings.SubtitleSettings.DCinemaFadeUpDownTime.ToString();
                    subNode.Attributes.Append(fadeUpTime);

                    XmlAttribute fadeDownTime = xml.CreateAttribute("FadeDownTime");
                    fadeDownTime.InnerText = "00:00:00:00"; //Configuration.Settings.SubtitleSettings.DCinemaFadeUpDownTime.ToString();
                    subNode.Attributes.Append(fadeDownTime);

                    XmlAttribute start = xml.CreateAttribute("TimeIn");
                    start.InnerText = ConvertToTimeString(p.StartTime);
                    subNode.Attributes.Append(start);

                    XmlAttribute end = xml.CreateAttribute("TimeOut");
                    end.InnerText = ConvertToTimeString(p.EndTime);
                    subNode.Attributes.Append(end);

                    bool alignLeft = p.Text.StartsWith("{\\a1}") || p.Text.StartsWith("{\\a5}") || p.Text.StartsWith("{\\a9}") ||      // sub station alpha
                                     p.Text.StartsWith("{\\an1}") || p.Text.StartsWith("{\\an4}") || p.Text.StartsWith("{\\an7}");     // advanced sub station alpha

                    bool alignRight = p.Text.StartsWith("{\\a3}") || p.Text.StartsWith("{\\a7}") || p.Text.StartsWith("{\\a11}") ||    // sub station alpha
                                      p.Text.StartsWith("{\\an3}") || p.Text.StartsWith("{\\an6}") || p.Text.StartsWith("{\\an9}");    // advanced sub station alpha

                    bool alignVTop = p.Text.StartsWith("{\\a5}") || p.Text.StartsWith("{\\a6}") || p.Text.StartsWith("{\\a7}") ||      // sub station alpha
                                     p.Text.StartsWith("{\\an7}") || p.Text.StartsWith("{\\an8}") || p.Text.StartsWith("{\\an9}");     // advanced sub station alpha

                    bool alignVCenter = p.Text.StartsWith("{\\a9}") || p.Text.StartsWith("{\\a10}") || p.Text.StartsWith("{\\a11}") || // sub station alpha
                                        p.Text.StartsWith("{\\an4}") || p.Text.StartsWith("{\\an5}") || p.Text.StartsWith("{\\an6}");  // advanced sub station alpha

                    // remove styles for display text (except italic)
                    string text = RemoveSubStationAlphaFormatting(p.Text);

                    var lines      = text.SplitToLines();
                    int vPos       = 1 + lines.Length * 7;
                    int vPosFactor = (int)Math.Round(fontSize / 7.4);
                    if (alignVTop)
                    {
                        vPos = Configuration.Settings.SubtitleSettings.DCinemaBottomMargin; // Bottom margin is normally 8
                    }
                    else if (alignVCenter)
                    {
                        vPos = (int)Math.Round((lines.Length * vPosFactor * -1) / 2.0);
                    }
                    else
                    {
                        vPos = (lines.Length * vPosFactor) - vPosFactor + Configuration.Settings.SubtitleSettings.DCinemaBottomMargin; // Bottom margin is normally 8
                    }

                    bool           isItalic   = false;
                    int            fontNo     = 0;
                    Stack <string> fontColors = new Stack <string>();
                    foreach (string line in lines)
                    {
                        XmlNode textNode = xml.CreateElement("dcst:Text", "dcst");

                        XmlAttribute vPosition = xml.CreateAttribute("Vposition");
                        vPosition.InnerText = vPos.ToString();
                        textNode.Attributes.Append(vPosition);

                        XmlAttribute vAlign = xml.CreateAttribute("Valign");
                        if (alignVTop)
                        {
                            vAlign.InnerText = "top";
                        }
                        else if (alignVCenter)
                        {
                            vAlign.InnerText = "center";
                        }
                        else
                        {
                            vAlign.InnerText = "bottom";
                        }
                        textNode.Attributes.Append(vAlign); textNode.Attributes.Append(vAlign);

                        XmlAttribute hAlign = xml.CreateAttribute("Halign");
                        if (alignLeft)
                        {
                            hAlign.InnerText = "left";
                        }
                        else if (alignRight)
                        {
                            hAlign.InnerText = "right";
                        }
                        else
                        {
                            hAlign.InnerText = "center";
                        }
                        textNode.Attributes.Append(hAlign);

                        XmlAttribute direction = xml.CreateAttribute("Direction");
                        direction.InnerText = "ltr";
                        textNode.Attributes.Append(direction);

                        int     i        = 0;
                        var     txt      = new StringBuilder();
                        var     html     = new StringBuilder();
                        XmlNode nodeTemp = xml.CreateElement("temp");
                        while (i < line.Length)
                        {
                            if (!isItalic && line.Substring(i).StartsWith("<i>"))
                            {
                                if (txt.Length > 0)
                                {
                                    nodeTemp.InnerText = txt.ToString();
                                    html.Append(nodeTemp.InnerXml);
                                    txt = new StringBuilder();
                                }
                                isItalic = true;
                                i       += 2;
                            }
                            else if (isItalic && line.Substring(i).StartsWith("</i>"))
                            {
                                if (txt.Length > 0)
                                {
                                    XmlNode fontNode = xml.CreateElement("dcst:Font", "dcst");

                                    XmlAttribute italic = xml.CreateAttribute("Italic");
                                    italic.InnerText = "yes";
                                    fontNode.Attributes.Append(italic);

                                    if (line.Length > i + 5 && line.Substring(i + 4).StartsWith("</font>"))
                                    {
                                        XmlAttribute fontColor = xml.CreateAttribute("Color");
                                        fontColor.InnerText = fontColors.Pop();
                                        fontNode.Attributes.Append(fontColor);
                                        fontNo--;
                                        i += 7;
                                    }

                                    fontNode.InnerText = HtmlUtil.RemoveHtmlTags(txt.ToString());
                                    html.Append(fontNode.OuterXml);
                                    txt = new StringBuilder();
                                }
                                isItalic = false;
                                i       += 3;
                            }
                            else if (line.Substring(i).StartsWith("<font color=") && line.Substring(i + 3).Contains('>'))
                            {
                                int endOfFont = line.IndexOf('>', i);
                                if (txt.Length > 0)
                                {
                                    nodeTemp.InnerText = txt.ToString();
                                    html.Append(nodeTemp.InnerXml);
                                    txt = new StringBuilder();
                                }
                                string c = line.Substring(i + 12, endOfFont - (i + 12));
                                c = c.Trim('"').Trim('\'').Trim();
                                if (c.StartsWith('#'))
                                {
                                    c = c.TrimStart('#').ToUpper().PadLeft(8, 'F');
                                }
                                fontColors.Push(c);
                                fontNo++;
                                i += endOfFont - i;
                            }
                            else if (fontNo > 0 && line.Substring(i).StartsWith("</font>"))
                            {
                                if (txt.Length > 0)
                                {
                                    XmlNode fontNode = xml.CreateElement("dcst:Font", "dcst");

                                    XmlAttribute fontColor = xml.CreateAttribute("Color");
                                    fontColor.InnerText = fontColors.Pop();
                                    fontNode.Attributes.Append(fontColor);

                                    if (line.Length > i + 9 && line.Substring(i + 7).StartsWith("</i>"))
                                    {
                                        XmlAttribute italic = xml.CreateAttribute("Italic");
                                        italic.InnerText = "yes";
                                        fontNode.Attributes.Append(italic);
                                        isItalic = false;
                                        i       += 4;
                                    }

                                    fontNode.InnerText = HtmlUtil.RemoveHtmlTags(txt.ToString());
                                    html.Append(fontNode.OuterXml);
                                    txt = new StringBuilder();
                                }
                                fontNo--;
                                i += 6;
                            }
                            else
                            {
                                txt.Append(line[i]);
                            }
                            i++;
                        }

                        if (fontNo > 0)
                        {
                            if (txt.Length > 0)
                            {
                                XmlNode fontNode = xml.CreateElement("dcst:Font", "dcst");

                                XmlAttribute fontColor = xml.CreateAttribute("Color");
                                fontColor.InnerText = fontColors.Peek();
                                fontNode.Attributes.Append(fontColor);

                                if (isItalic)
                                {
                                    XmlAttribute italic = xml.CreateAttribute("Italic");
                                    italic.InnerText = "yes";
                                    fontNode.Attributes.Append(italic);
                                }

                                fontNode.InnerText = HtmlUtil.RemoveHtmlTags(txt.ToString());
                                html.Append(fontNode.OuterXml);
                            }
                            else if (html.Length > 0 && html.ToString().StartsWith("<dcst:Font "))
                            {
                                XmlDocument temp = new XmlDocument();
                                temp.LoadXml("<root>" + html.ToString().Replace("dcst:Font", "Font") + "</root>");
                                XmlNode fontNode = xml.CreateElement("dcst:Font");
                                fontNode.InnerXml = temp.DocumentElement.SelectSingleNode("Font").InnerXml;
                                foreach (XmlAttribute a in temp.DocumentElement.SelectSingleNode("Font").Attributes)
                                {
                                    XmlAttribute newA = xml.CreateAttribute(a.Name);
                                    newA.InnerText = a.InnerText;
                                    fontNode.Attributes.Append(newA);
                                }

                                XmlAttribute fontColor = xml.CreateAttribute("Color");
                                fontColor.InnerText = fontColors.Peek();
                                fontNode.Attributes.Append(fontColor);

                                html = new StringBuilder();
                                html.Append(fontNode.OuterXml);
                            }
                        }
                        else if (isItalic)
                        {
                            if (txt.Length > 0)
                            {
                                XmlNode fontNode = xml.CreateElement("dcst:Font", "dcst");

                                XmlAttribute italic = xml.CreateAttribute("Italic");
                                italic.InnerText = "yes";
                                fontNode.Attributes.Append(italic);

                                fontNode.InnerText = HtmlUtil.RemoveHtmlTags(line);
                                html.Append(fontNode.OuterXml);
                            }
                        }
                        else
                        {
                            if (txt.Length > 0)
                            {
                                nodeTemp.InnerText = txt.ToString();
                                html.Append(nodeTemp.InnerXml);
                            }
                        }
                        textNode.InnerXml = html.ToString();

                        subNode.AppendChild(textNode);
                        if (alignVTop)
                        {
                            vPos += vPosFactor;
                        }
                        else
                        {
                            vPos -= vPosFactor;
                        }
                    }
                    if (subNode.InnerXml.Length == 0)
                    { // Empty text is just one space
                        XmlNode textNode = xml.CreateElement("dcst:Text", "dcst");
                        textNode.InnerXml = " ";
                        subNode.AppendChild(textNode);

                        XmlAttribute vPosition = xml.CreateAttribute("Vposition");
                        vPosition.InnerText = vPos.ToString();
                        textNode.Attributes.Append(vPosition);

                        XmlAttribute vAlign = xml.CreateAttribute("Valign");
                        vAlign.InnerText = "bottom";
                        textNode.Attributes.Append(vAlign);
                    }
                    mainListFont.AppendChild(subNode);
                    no++;
                }
            }
            string result = ToUtf8XmlString(xml).Replace("encoding=\"utf-8\"", "encoding=\"UTF-8\"").Replace(" xmlns:dcst=\"dcst\"", string.Empty);

            const string res = "Nikse.SubtitleEdit.Resources.SMPTE-428-7-2007-DCST.xsd.gz";

            System.Reflection.Assembly asm = System.Reflection.Assembly.GetExecutingAssembly();
            Stream strm = asm.GetManifestResourceStream(res);

            if (strm != null)
            {
                try
                {
                    var xmld = new XmlDocument();
                    var rdr  = new StreamReader(strm);
                    var zip  = new GZipStream(rdr.BaseStream, CompressionMode.Decompress);
                    xmld.LoadXml(result);
                    using (var xr = XmlReader.Create(zip))
                    {
                        xmld.Schemas.Add(null, xr);
                        xmld.Validate(ValidationCallBack);
                    }
                }
                catch (Exception exception)
                {
                    if (!BatchMode)
                    {
                        System.Windows.Forms.MessageBox.Show("SMPTE-428-7-2007-DCST.xsd: " + exception.Message);
                    }
                }
            }
            return(result);
        }
Пример #46
0
        static IList <KeyValuePair <XmlName, INode> > ParseXamlAttributes(XmlReader reader, out IList <KeyValuePair <string, string> > xmlns)
        {
            Debug.Assert(reader.NodeType == XmlNodeType.Element);
            var attributes = new List <KeyValuePair <XmlName, INode> >();

            xmlns = new List <KeyValuePair <string, string> >();
            for (var i = 0; i < reader.AttributeCount; i++)
            {
                reader.MoveToAttribute(i);

                //skip xmlns
                if (reader.NamespaceURI == "http://www.w3.org/2000/xmlns/")
                {
                    xmlns.Add(new KeyValuePair <string, string>(reader.LocalName, reader.Value));
                    continue;
                }

                var namespaceUri = reader.NamespaceURI;
                if (reader.LocalName.Contains(".") && namespaceUri == "")
                {
                    namespaceUri = ((IXmlNamespaceResolver)reader).LookupNamespace("");
                }
                var propertyName = new XmlName(namespaceUri, reader.LocalName);

                object value = reader.Value;

                if (reader.NamespaceURI == X2006Uri)
                {
                    switch (reader.LocalName)
                    {
                    case "Key":
                        propertyName = XmlName.xKey;
                        break;

                    case "Name":
                        propertyName = XmlName.xName;
                        break;

                    case "Class":
                    case "FieldModifier":
                        continue;

                    default:
                        Debug.WriteLine("Unhandled attribute {0}", reader.Name);
                        continue;
                    }
                }

                if (reader.NamespaceURI == X2009Uri)
                {
                    switch (reader.LocalName)
                    {
                    case "Key":
                        propertyName = XmlName.xKey;
                        break;

                    case "Name":
                        propertyName = XmlName.xName;
                        break;

                    case "TypeArguments":
                        propertyName = XmlName.xTypeArguments;
                        value        = TypeArgumentsParser.ParseExpression((string)value, (IXmlNamespaceResolver)reader, (IXmlLineInfo)reader);
                        break;

                    case "DataType":
                        propertyName = XmlName.xDataType;
                        break;

                    case "Class":
                    case "FieldModifier":
                        continue;

                    case "FactoryMethod":
                        propertyName = XmlName.xFactoryMethod;
                        break;

                    case "Arguments":
                        propertyName = XmlName.xArguments;
                        break;

                    default:
                        Debug.WriteLine("Unhandled attribute {0}", reader.Name);
                        continue;
                    }
                }

                var propertyNode = GetValueNode(value, reader);
                attributes.Add(new KeyValuePair <XmlName, INode>(propertyName, propertyNode));
            }
            reader.MoveToElement();
            return(attributes);
        }
Пример #47
0
        async Task <int> AnalyzeProjectAsync(string projectFile)
        {
            var defaultForegroundColor = Console.ForegroundColor;

            if (!File.Exists(projectFile))
            {
                Console.ForegroundColor = ConsoleColor.Red;

                Console.WriteLine($"Project file \"{projectFile}\" does not exist");

                Console.ForegroundColor = defaultForegroundColor;

                return(1);
            }

            Console.ForegroundColor = ConsoleColor.Blue;

            Console.WriteLine($"» Project: {projectFile}");

            Console.ForegroundColor = defaultForegroundColor;

            Console.WriteLine();
            Console.WriteLine("  Getting packages".PadRight(64));
            Console.SetCursorPosition(Console.CursorLeft, Console.CursorTop - 1);

            var coordinates     = new List <string>();
            var skippedPackages = new List <(string packageName, string reason)>();

            try
            {
                using (XmlReader reader = XmlReader.Create(projectFile))
                {
                    while (reader.Read())
                    {
                        if (reader.IsStartElement())
                        {
                            switch (reader.Name)
                            {
                            case "PackageReference":
                                var packageName    = reader["Include"];
                                var packageVersion = reader["Version"];

                                if (string.IsNullOrEmpty(packageVersion))
                                {
                                    skippedPackages.Add(($"pkg:nuget/{packageName}", "Package is referenced without version"));
                                }
                                else
                                {
                                    coordinates.Add($"pkg:nuget/{packageName}@{packageVersion}");
                                }

                                break;
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;

                Console.WriteLine($"  An unhandled exception occurred while getting the packages: {ex.Message}");

                Console.ForegroundColor = defaultForegroundColor;

                return(1);
            }

            if (skippedPackages.Any())
            {
                Console.WriteLine($"  {skippedPackages.Count()} package(s) skipped".PadRight(64));
                Console.WriteLine();

                foreach (var(packageName, reason) in skippedPackages)
                {
                    Console.WriteLine($"          Package: {packageName}");
                    Console.WriteLine($"           Reason: {reason}");
                    Console.WriteLine();
                }
            }

            if (!coordinates.Any())
            {
                Console.WriteLine("  No packages found".PadRight(64));

                return(0);
            }

            Console.WriteLine("  Checking for vulnerabilities".PadRight(64));
            Console.SetCursorPosition(Console.CursorLeft, Console.CursorTop - 1);

            var client = new HttpClient();

            client.DefaultRequestHeaders.Accept.Clear();
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

            if (!string.IsNullOrEmpty(Username) && !string.IsNullOrEmpty(ApiToken))
            {
                var bytes = Encoding.UTF8.GetBytes($"{Username}:{ApiToken}");
                var value = Convert.ToBase64String(bytes);

                client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", value);
            }

            var request = new
            {
                coordinates = coordinates
            };

            var requestAsString        = JsonConvert.SerializeObject(request);
            var requestAsStringContent = new StringContent(requestAsString, Encoding.UTF8, "application/json");

            HttpResponseMessage response;

            try
            {
                response = await client.PostAsync("https://ossindex.sonatype.org/api/v3/component-report", requestAsStringContent);
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;

                Console.WriteLine($"  An unhandled exception occurred while checking for vulnerabilities: {ex.Message}");

                Console.ForegroundColor = defaultForegroundColor;

                return(1);
            }

            var contentAsString = await response.Content.ReadAsStringAsync();

            if (!response.IsSuccessStatusCode)
            {
                Console.ForegroundColor = ConsoleColor.Red;

                Console.WriteLine($"  An unhandled exception occurred while checking for vulnerabilities: {(int)response.StatusCode} {response.StatusCode} {contentAsString}");

                Console.ForegroundColor = defaultForegroundColor;

                return(1);
            }

            Component[] components;

            try
            {
                components = JsonConvert.DeserializeObject <Component[]>(contentAsString);
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;

                Console.WriteLine($"  An unhandled exception occurred while checking for vulnerabilities: {ex.Message}");

                Console.ForegroundColor = defaultForegroundColor;

                return(1);
            }

            var affectedComponents = components.Where(c => c.Vulnerabilities.Length > 0);

            if (!affectedComponents.Any())
            {
                Console.WriteLine("  No packages affected".PadRight(64));

                return(0);
            }

            Console.WriteLine($"  {affectedComponents.Count()} package(s) affected".PadRight(64));

            foreach (var component in affectedComponents)
            {
                Console.WriteLine();
                Console.WriteLine($"          Package: {component.Coordinates}");
                Console.WriteLine($"        Reference: {component.Reference}");
                Console.Write("  Vulnerabilities:");

                foreach (var vulnerability in component.Vulnerabilities.OrderByDescending(v => v.CVSSScore))
                {
                    Console.SetCursorPosition(19, Console.CursorTop);

                    // Severity scale
                    // https://www.first.org/cvss/specification-document#5-Qualitative-Severity-Rating-Scale
                    var severity = "NONE";
                    var severityForegroundColor = defaultForegroundColor;

                    if (vulnerability.CVSSScore >= 0.1 && vulnerability.CVSSScore <= 3.9)
                    {
                        severity = "LOW";
                    }

                    if (vulnerability.CVSSScore >= 4.0 && vulnerability.CVSSScore <= 6.9)
                    {
                        severity = "MEDIUM";
                        severityForegroundColor = ConsoleColor.Yellow;
                    }

                    if (vulnerability.CVSSScore >= 7.0 && vulnerability.CVSSScore <= 8.9)
                    {
                        severity = "HIGH";
                        severityForegroundColor = ConsoleColor.Red;
                    }

                    if (vulnerability.CVSSScore >= 9.0)
                    {
                        severity = "CRITICAL";
                        severityForegroundColor = ConsoleColor.Red;
                    }

                    Console.ForegroundColor = severityForegroundColor;

                    Console.WriteLine("- {0,-8} {1}", severity, vulnerability.Title);

                    Console.ForegroundColor = defaultForegroundColor;
                }
            }

            return(0);
        }
        /// <summary>
        /// Request this cell load and update state.
        /// </summary>
        /// <param name="workspace">Reference to owning workspace instance.</param>
        /// <param name="xmlReader">Xml reader for loading information.</param>
        /// <param name="existingPages">Dictionary on existing pages before load.</param>
        public void LoadFromXml(KryptonWorkspace workspace,
                                XmlReader xmlReader,
                                UniqueNameToPage existingPages)
        {
            // Load the cell details and return the unique name of the selected page for the cell
            string      selectedPageUniqueName = workspace.ReadCellElement(xmlReader, this);
            KryptonPage selectedPage           = null;

            // If the cell contains nothing then exit immediately
            if (!xmlReader.IsEmptyElement)
            {
                do
                {
                    // Read the next Element
                    if (!xmlReader.Read())
                    {
                        throw new ArgumentException("An element was expected but could not be read in.");
                    }

                    // Is this the end of the cell
                    if (xmlReader.NodeType == XmlNodeType.EndElement)
                    {
                        break;
                    }

                    if (xmlReader.Name == "KP")
                    {
                        // Load the page details and optionally recreate the page
                        string      uniqueName = CommonHelper.XmlAttributeToText(xmlReader, "UN");
                        KryptonPage page       = workspace.ReadPageElement(xmlReader, uniqueName, existingPages);

                        if (xmlReader.Name != "CPD")
                        {
                            throw new ArgumentException("Expected 'CPD' element was not found");
                        }

                        bool finished = xmlReader.IsEmptyElement;

                        // Generate event so custom data can be loaded and/or the page to be added can be modified
                        PageLoadingEventArgs plea = new PageLoadingEventArgs(workspace, page, xmlReader);
                        workspace.OnPageLoading(plea);
                        page = plea.Page;

                        // Read everything until we get the end of custom data marker
                        while (!finished)
                        {
                            // Check it has the expected name
                            if (xmlReader.NodeType == XmlNodeType.EndElement)
                            {
                                finished = (xmlReader.Name == "CPD");
                            }

                            if (!finished)
                            {
                                if (!xmlReader.Read())
                                {
                                    throw new ArgumentException("An element was expected but could not be read in.");
                                }
                            }
                        }

                        // Read past the end of page element
                        if (!xmlReader.Read())
                        {
                            throw new ArgumentException("An element was expected but could not be read in.");
                        }

                        // Check it has the expected name
                        if (xmlReader.NodeType != XmlNodeType.EndElement)
                        {
                            throw new ArgumentException("End of 'KP' element expected but missing.");
                        }

                        // PageLoading event might have nulled the page value to prevent it being added
                        if (page != null)
                        {
                            // Remember the page that should become selected
                            if (!string.IsNullOrEmpty(page.UniqueName) && (page.UniqueName == selectedPageUniqueName))
                            {
                                // Can only selected a visible page
                                if (page.LastVisibleSet)
                                {
                                    selectedPage = page;
                                }
                            }

                            Pages.Add(page);
                        }
                    }
                    else
                    {
                        throw new ArgumentException("Unknown element was encountered.");
                    }
                }while (true);
            }

            // Did we find a matching page that should become selected?
            // (and we are allowed to have selected tabs)
            if ((selectedPage != null) && AllowTabSelect)
            {
                SelectedPage = selectedPage;
            }
        }
Пример #49
0
        public UpdateDetails UpdateInfo()
        {
            lock (this)
            {
                Version            = null;
                InstallUrl         = null;
                this.LastCheckTime = DateTime.Now;
                IsFaulted          = true;
                Log.Info("Reading update xml");
                var url = AppConfig.UpdateInfoPath;
                try
                {
                    Log.InfoFormat("Downloading info from {0}", url);
                    var wr = WebRequest.Create(url);
                    wr.Timeout = 15000;
                    var resp = wr.GetResponse();
                    var rgrp = resp.GetResponseStream();
                    Log.Info("Got stream");
                    if (rgrp != null)
                    {
                        Log.Info("Creating reader");
                        using (var reader = XmlReader.Create(rgrp))
                        {
                            Log.Info("Created reader...reading");

                            while (reader.Read())
                            {
                                if (!reader.IsStartElement())
                                {
                                    continue;
                                }
                                if (reader.IsEmptyElement)
                                {
                                    continue;
                                }
                                switch (reader.Name.ToLowerInvariant())
                                {
                                case "version":
                                    if (reader.Read())
                                    {
                                        Log.InfoFormat("Reading version {0}", reader.Value);
                                        Version = Version.Parse(reader.Value);
                                    }
                                    break;

                                case "installpath":
                                    if (reader.Read())
                                    {
                                        Log.InfoFormat("Reading paths {0} {1}", reader.Value, reader.Value);
#if (Release_Test)
                                        InstallUrl = "https://s3.amazonaws.com/octgn/releases/test/" + reader.Value.Replace("downloadtest/", "");
#else
                                        InstallUrl = "https://s3.amazonaws.com/octgn/releases/live/" + reader.Value.Replace("download/", "");
#endif
                                    }
                                    break;
                                }
                            }
                        }
                    }
                    if (!String.IsNullOrWhiteSpace(InstallUrl) && Version != null)
                    {
                        IsFaulted = false;
                    }
                }
                catch (WebException e)
                {
                    Log.Warn("", e);
                    IsFaulted = true;
                }
                catch (Exception e)
                {
                    Log.Warn("", e);
                    IsFaulted = true;
                }
                return(this);
            }
        }
Пример #50
0
 public LogEntry(XmlReader reader)
 {
     FileName = reader.GetAttribute("fileName");
     Ignore = Convert.ToBoolean(reader.GetAttribute("ignore").ToLower());
     Error = reader.GetAttribute("error");
 }
 protected static AlgebraicExpressionCategory InnerDeserialize(Context context, XmlReader reader)
 {
     return(Instance);
 }
Пример #52
0
    public void ReadXml(XmlReader reader) {

    }
Пример #53
0
        /// <summary>
        /// 读取 摇乳是否开启 6人伤害统计是否开启
        /// </summary>
        /// <param name="path">xmlFilePath路径</param>
        /// <param name="breast">摇乳是否开启,是为true(bool)</param>
        /// <param name="damage">6人伤害统计是否开启,是为true(bool)</param>
        public void xmlWrite(string path, bool breast, bool damage, bool autoBUFF, bool backRun, bool fight, int GCD)
        {
            if (!File.Exists(path + "xml.dat.files\\client.config2.xml"))
            {
                MessageBox.Show("找不到 client.config2.xml 请重新解包");
                return;
            }

            XmlDocument       xmlDoc   = new XmlDocument();
            XmlReaderSettings settings = new XmlReaderSettings();

            settings.IgnoreComments = true;//忽略文档里面的注释

            #region client.config2.xml 修改区
            /*  client.config2.xml  修改区 开始 */
            XmlReader reader = XmlReader.Create(path + "xml.dat.files\\client.config2.xml", settings);
            xmlDoc.Load(reader);

            XmlNodeList nodeList = xmlDoc.SelectSingleNode("config").ChildNodes; //获取config节点的所有子节点

            foreach (XmlNode xn in nodeList)                                     //遍历所有子节点
            {
                XmlElement xe = (XmlElement)xn;                                  //将子节点类型转换为XmlElement类型

                #region 摇乳
                if (xe.GetAttribute("name") == "uncategorized")                  //如果name属性值为“skill”
                {
                    XmlNodeList nls = xe.ChildNodes;                             //继续获取xe子节点的所有子节点
                    foreach (XmlNode xn1 in nls)                                 //遍历
                    {
                        XmlElement xe2 = (XmlElement)xn1;                        //转换类型
                        if (xe2.GetAttribute("name") == "no-use-breast-physics") //如果找到
                        {
                            try
                            {
                                if (breast == true)
                                {
                                    xe2.SetAttribute("value", "false");
                                }                                                            //Set当前节点值
                                else
                                {
                                    xe2.SetAttribute("value", "true");
                                }
                            }
                            catch (Exception e)
                            {
                                MessageBox.Show(e.ToString());
                            }
                        }
                    }
                }
                #endregion

                #region 六人伤害统计
                if (xe.GetAttribute("name") == "damage-meter")                           //如果name属性值为“skill”
                {
                    XmlNodeList nls = xe.ChildNodes;                                     //继续获取xe子节点的所有子节点
                    foreach (XmlNode xn1 in nls)                                         //遍历
                    {
                        XmlElement xe2 = (XmlElement)xn1;                                //转换类型
                        if (xe2.GetAttribute("name") == "show-party-6-dungeon-and-cave") //如果找到
                        {
                            try
                            {
                                if (damage == true)
                                {
                                    xe2.SetAttribute("value", "y");
                                }                                                        //Set当前节点值
                                else
                                {
                                    xe2.SetAttribute("value", "n");
                                }
                            }
                            catch (Exception e)
                            {
                                MessageBox.Show(e.ToString());
                            }
                        }
                    }
                }
                #endregion

                #region BUFF自动排序
                if (xe.GetAttribute("name") == "hud")             //如果name属性值为“skill”
                {
                    XmlNodeList nls = xe.ChildNodes;              //继续获取xe子节点的所有子节点
                    foreach (XmlNode xn1 in nls)                  //遍历
                    {
                        XmlElement xe2 = (XmlElement)xn1;         //转换类型
                        if (xe2.GetAttribute("name") == "effect") //如果找到
                        {
                            XmlNodeList nls2 = xe2.ChildNodes;
                            foreach (XmlNode xn2 in nls2)
                            {
                                XmlElement xe3 = (XmlElement)xn2;
                                if (xe3.GetAttribute("name") == "use-passive-effect-auto-sort")
                                {
                                    try
                                    {
                                        if (autoBUFF == true)
                                        {
                                            xe3.SetAttribute("value", "y");
                                        }                                                          //Set当前节点值
                                        else
                                        {
                                            xe3.SetAttribute("value", "n");
                                        }
                                    }
                                    catch (Exception e)
                                    {
                                        MessageBox.Show(e.ToString());
                                    }
                                }
                            }
                        }
                    }
                }
                #endregion

                #region 移动加速
                if (xe.GetAttribute("name") == "move")    //如果name属性值为“move”
                {
                    XmlNodeList nls = xe.ChildNodes;      //继续获取xe子节点的所有子节点
                    foreach (XmlNode xn1 in nls)          //遍历
                    {
                        XmlElement xe2 = (XmlElement)xn1; //转换类型

                        #region 后退加速
                        if (xe2.GetAttribute("name") == "backrun-velocity-pct")//如果找到
                        {
                            try
                            {
                                if (backRun == true)
                                {
                                    xe2.SetAttribute("value", "1.400000");
                                }
                                else
                                {
                                    xe2.SetAttribute("value", "0.400000");
                                }
                            }
                            catch (Exception e)
                            {
                                MessageBox.Show(e.ToString());
                            }
                        }

                        if (xe2.GetAttribute("name") == "walking-velocity-pct")//如果找到
                        {
                            try
                            {
                                if (backRun == true)
                                {
                                    xe2.SetAttribute("value", "1.400000");
                                }
                                else
                                {
                                    xe2.SetAttribute("value", "0.300000");
                                }
                            }
                            catch (Exception e)
                            {
                                MessageBox.Show(e.ToString());
                            }
                        }

                        if (xe2.GetAttribute("name") == "backwalking-velocity-pct")//如果找到
                        {
                            try
                            {
                                if (backRun == true)
                                {
                                    xe2.SetAttribute("value", "1.300000");
                                }
                                else
                                {
                                    xe2.SetAttribute("value", "0.150000");
                                }
                            }
                            catch (Exception e)
                            {
                                MessageBox.Show(e.ToString());
                            }
                        }
                        #endregion

                        #region 战斗状态加速
                        if (xe2.GetAttribute("name") == "combat-velocity-pct")//如果找到
                        {
                            try
                            {
                                if (fight == true)
                                {
                                    xe2.SetAttribute("value", "1.200000");
                                }
                                else
                                {
                                    xe2.SetAttribute("value", "0.800000");
                                }
                            }
                            catch (Exception e)
                            {
                                MessageBox.Show(e.ToString());
                            }
                        }
                        #endregion
                    }
                }
                #endregion

                #region GCD
                if (xe.GetAttribute("name") == "skill")                                   //如果name属性值为
                {
                    XmlNodeList nls = xe.ChildNodes;                                      //继续获取xe子节点的所有子节点
                    foreach (XmlNode xn1 in nls)                                          //遍历
                    {
                        XmlElement xe2 = (XmlElement)xn1;                                 //转换类型
                        if (xe2.GetAttribute("name") == "skill-global-cool-latency-time") //如果找到
                        {
                            try
                            {
                                xe2.SetAttribute("value", GCD.ToString()); //Set当前节点值
                            }
                            catch (Exception e)
                            {
                                MessageBox.Show(e.ToString());
                            }
                        }
                    }
                }
                #endregion
            }//foreach 遍历所有子节点 结束

            reader.Close();
            xmlDoc.Save(path + "xml.dat.files\\client.config2.xml");
            /*  client.config2.xml  修改区 结束  */
            #endregion
        }//xmlWrite结束
Пример #54
0
 public T ReadXml(XmlReader reader)
 {
     return(ReadXml(reader, null));
 }
Пример #55
0
 public XmlRecordReader(XmlReader reader)
 {
     Reader = reader;
 }
Пример #56
0
        }//xmlWrite结束

        #endregion

        #region xmlRead
        /// <summary>
        /// 读取 摇乳是否开启 6人伤害统计是否开启
        /// </summary>
        /// <param name="path">xmlFilePath路径</param>
        /// <param name="breast">摇乳是否开启,是为true(bool)</param>
        /// <param name="damage">6人伤害统计是否开启,是为true(bool)</param>
        public void xmlRead(string path, out bool breast, out bool damage, out bool autoBUFF, out bool backRun, out bool fight, out bool JLG, out bool ZJXN, out int GCD)
        {
            breast   = false;
            damage   = false;
            autoBUFF = true;
            backRun  = false;
            fight    = false;
            JLG      = false;
            ZJXN     = false;
            GCD      = 100;

            string[]          returnValues = new string[4];
            string[]          returnMoves  = new string[4];
            string[]          returnJLG    = new string[2];
            XmlDocument       xmlDoc       = new XmlDocument();
            XmlReaderSettings settings     = new XmlReaderSettings();

            settings.IgnoreComments = true;//忽略文档里面的注释
            if (!File.Exists(path + "xml.dat.files\\client.config2.xml"))
            {
                MessageBox.Show("找不到 client.config2.xml 请重新解包");
                return;
            }

            /*  client.config2.xml  修改区 开始 */
            XmlReader reader = XmlReader.Create(path + "xml.dat.files\\client.config2.xml", settings);

            xmlDoc.Load(reader);

            XmlNodeList nodeList = xmlDoc.SelectSingleNode("config").ChildNodes; //获取config节点的所有子节点

            foreach (XmlNode xn in nodeList)                                     //遍历所有子节点
            {
                XmlElement xe = (XmlElement)xn;                                  //将子节点类型转换为XmlElement类型

                #region 摇乳
                if (xe.GetAttribute("name") == "uncategorized")                  //如果name属性值为
                {
                    XmlNodeList nls = xe.ChildNodes;                             //继续获取xe子节点的所有子节点
                    foreach (XmlNode xn1 in nls)                                 //遍历
                    {
                        XmlElement xe2 = (XmlElement)xn1;                        //转换类型
                        if (xe2.GetAttribute("name") == "no-use-breast-physics") //如果找到
                        {
                            try
                            {
                                returnValues[1] = xe2.GetAttribute("value"); //获取当前节点值
                            }
                            catch (Exception e)
                            {
                                MessageBox.Show("摇乳" + e.ToString());
                            }
                        }
                    }
                }
                #endregion

                #region 六人伤害统计
                if (xe.GetAttribute("name") == "damage-meter")                           //如果name属性值为“skill”
                {
                    XmlNodeList nls = xe.ChildNodes;                                     //继续获取xe子节点的所有子节点
                    foreach (XmlNode xn1 in nls)                                         //遍历
                    {
                        XmlElement xe2 = (XmlElement)xn1;                                //转换类型
                        if (xe2.GetAttribute("name") == "show-party-6-dungeon-and-cave") //如果找到
                        {
                            try
                            {
                                returnValues[2] = xe2.GetAttribute("value"); //获取当前节点值
                            }
                            catch (Exception e)
                            {
                                MessageBox.Show("六人伤害统计" + e.ToString());
                            }
                        }
                    }
                }
                #endregion

                #region BUFF自动排序
                if (xe.GetAttribute("name") == "hud")             //如果name属性值为
                {
                    XmlNodeList nls = xe.ChildNodes;              //继续获取xe子节点的所有子节点
                    foreach (XmlNode xn1 in nls)                  //遍历
                    {
                        XmlElement xe2 = (XmlElement)xn1;         //转换类型
                        if (xe2.GetAttribute("name") == "effect") //如果找到
                        {
                            XmlNodeList nls2 = xe2.ChildNodes;

                            foreach (XmlNode xn2 in nls2)
                            {
                                XmlElement xe3 = (XmlElement)xn2;
                                if (xe3.GetAttribute("name") == "use-passive-effect-auto-sort")
                                {
                                    try
                                    {
                                        returnValues[0] = xe3.GetAttribute("value"); //获取当前节点值
                                    }
                                    catch (Exception e)
                                    {
                                        MessageBox.Show("BUFF自动排序" + e.ToString());
                                    }
                                }
                            }
                        }
                    }
                }
                #endregion

                #region 移动速度
                if (xe.GetAttribute("name") == "move")                          //如果name属性值为
                {
                    XmlNodeList nls = xe.ChildNodes;                            //继续获取xe子节点的所有子节点
                    foreach (XmlNode xn1 in nls)                                //遍历
                    {
                        XmlElement xe2 = (XmlElement)xn1;                       //转换类型
                        if (xe2.GetAttribute("name") == "backrun-velocity-pct") //如果找到
                        {
                            try
                            {
                                returnMoves[0] = xe2.GetAttribute("value"); //获取当前节点值
                            }
                            catch (Exception e)
                            {
                                MessageBox.Show("后退加速0" + e.ToString());
                            }
                        }

                        if (xe2.GetAttribute("name") == "walking-velocity-pct")//如果找到
                        {
                            try
                            {
                                returnMoves[1] = xe2.GetAttribute("value"); //获取当前节点值
                            }
                            catch (Exception e)
                            {
                                MessageBox.Show("后退加速1" + e.ToString());
                            }
                        }

                        if (xe2.GetAttribute("name") == "backwalking-velocity-pct")//如果找到
                        {
                            try
                            {
                                returnMoves[2] = xe2.GetAttribute("value"); //获取当前节点值
                            }
                            catch (Exception e)
                            {
                                MessageBox.Show("后退加速2" + e.ToString());
                            }
                        }

                        if (xe2.GetAttribute("name") == "combat-velocity-pct")//如果找到
                        {
                            try
                            {
                                returnMoves[3] = xe2.GetAttribute("value"); //获取当前节点值
                            }
                            catch (Exception e)
                            {
                                MessageBox.Show("后退加速3" + e.ToString());
                            }
                        }
                    }
                }
                #endregion

                #region 聚灵阁加速
                if (xe.GetAttribute("name") == "random-store")               //如果name属性值为“skill”
                {
                    XmlNodeList nls = xe.ChildNodes;                         //继续获取xe子节点的所有子节点
                    foreach (XmlNode xn1 in nls)                             //遍历
                    {
                        XmlElement xe2 = (XmlElement)xn1;                    //转换类型
                        if (xe2.GetAttribute("name") == "progress-duration") //如果找到
                        {
                            try
                            {
                                returnJLG[0] = xe2.GetAttribute("value"); //获取当前节点值
                            }
                            catch (Exception e)
                            {
                                MessageBox.Show("聚灵阁" + e.ToString());
                            }
                        }
                        if (xe2.GetAttribute("name") == "slot-update-delay")//如果找到
                        {
                            try
                            {
                                returnJLG[1] = xe2.GetAttribute("value"); //获取当前节点值
                            }
                            catch (Exception e)
                            {
                                MessageBox.Show("聚灵阁" + e.ToString());
                            }
                        }
                    }
                }
                #endregion

                #region 最佳性能模式
                if (xe.GetAttribute("name") == "option")
                {
                    XmlNodeList nls = xe.ChildNodes;                                           //继续获取xe子节点的所有子节点
                    foreach (XmlNode xn1 in nls)                                               //遍历
                    {
                        XmlElement xe2 = (XmlElement)xn1;                                      //转换类型
                        if (xe2.GetAttribute("name") == "use-optimal-performance-mode-option") //如果找到
                        {
                            try
                            {
                                returnValues[3] = xe2.GetAttribute("value"); //获取当前节点值
                            }
                            catch (Exception e)
                            {
                                MessageBox.Show("最佳性能模式" + e.ToString());
                            }
                        }
                    }
                }
                #endregion
            }//foreach 遍历所有子节点 结束

            /*  client.config2.xml  修改区 结束 */



            /*  返回摇乳是否开启,开启返回true,未开启返回false  */
            if (returnValues[1] == "true")
            {
                breast = false;
            }
            else
            {
                breast = true;
            }

            /*  返回6人伤害统计是否开启,开启返回true,未开启返回false */
            if (returnValues[2] == "y")
            {
                damage = true;
            }
            else
            {
                damage = false;
            }

            /*  返回技能自动排序是否开启,开启返回true,未开启返回false */
            if (returnValues[0] == "n")
            {
                autoBUFF = false;
            }
            else
            {
                autoBUFF = true;
            }

            /*  返回最佳性能模式是否开启,开启返回true,未开启返回false */
            if (returnValues[3] == "true")
            {
                ZJXN = true;
            }
            else
            {
                ZJXN = false;
            }

            /* 返回后退加速是否开启 */
            if (Convert.ToDouble(returnMoves[0]) > 0.4 || Convert.ToDouble(returnMoves[1]) > 0.3 || Convert.ToDouble(returnMoves[2]) > 0.15)
            {
                backRun = true;
            }
            else
            {
                backRun = false;
            }

            /* 返回战斗加速是否开启 */
            if (Convert.ToDouble(returnMoves[3]) > 0.8)
            {
                fight = true;
            }
            else
            {
                fight = false;
            }

            /* 返回聚灵阁加速是否开启 */
            if (Convert.ToDouble(returnJLG[0]) < 2.0 || Convert.ToDouble(returnJLG[1]) < 0.2)
            {
                JLG = true;
            }
            else
            {
                JLG = false;
            }


            reader.Close();
        }
Пример #57
0
        private static XDocument CreateAnnotatedXDocument(XmlReader reader)
        {
            Debug.Assert(reader != null, "reader != null");

            return(new AnnotatedTreeBuilder().Build(reader));
        }
Пример #58
0
        private static void CreateArticle(XmlWriter xmlWriter, Meaning meaning, IEnumerable <Definition> definitions)
        {
            // Article
            xmlWriter.WriteStartElement("ar");

            // Main keyword
            xmlWriter.WriteStartElement("k");
            xmlWriter.WriteRaw(meaning.Word);
            xmlWriter.WriteEndElement();

            // Alternate keywords
            foreach (string word in meaning.AlternateWords)
            {
                xmlWriter.WriteStartElement("k");
                xmlWriter.WriteRaw(word);
                xmlWriter.WriteEndElement();
            }

            // Re-order definitions
            List <Definition> orderedDefinitions =
                definitions
                .OrderBy(d => d.MeaningId)
                .ThenBy(d => d.Position)
                .Distinct()
                .ToList();

            // Definitions
            foreach (Definition definition in orderedDefinitions)
            {
                xmlWriter.WriteStartElement("def");

                // Grammar (already in the def as an "&emdash; verb"
                //XmlElement gr = xml.CreateElement("gr");
                //gr.InnerText = definition.WordType;
                //def.InsertBefore(gr, first);

                // Transcription/pronunciation
                if (!string.IsNullOrWhiteSpace(meaning.PronounciationIpa))
                {
                    xmlWriter.WriteStartElement("tr");
                    xmlWriter.WriteAttributeString("format", "IPA");
                    xmlWriter.WriteRaw($"IPA: /{meaning.PronounciationIpa}");
                    xmlWriter.WriteEndElement();
                }
                if (!string.IsNullOrWhiteSpace(meaning.PronounciationSpell))
                {
                    xmlWriter.WriteStartElement("tr");
                    xmlWriter.WriteAttributeString("format", "Spelling");
                    xmlWriter.WriteRaw($"Spell: [{meaning.PronounciationSpell}]");
                    xmlWriter.WriteEndElement();
                }
                if (!string.IsNullOrWhiteSpace(meaning.Syllable))
                {
                    xmlWriter.WriteStartElement("tr");
                    xmlWriter.WriteAttributeString("format", "Syllable");
                    xmlWriter.WriteRaw($"Syllable: {meaning.Syllable}");
                    xmlWriter.WriteEndElement();
                }

                // Internet ressource shows in the definition, not good for now
                //XmlElement iref = xml.CreateElement("rref");
                //iref.SetAttribute("lctn", word.AudioFile);
                //iref.SetAttribute("type", "audio/opus");
                //iref.InnerText = "Audio";
                //def.InsertBefore(iref, defTop);

                // TODO Add <sr> antonyms and shit from thesaurus?

                // Write definition as a DOM structure
                using (StringReader stringReader = new StringReader(definition.DefinitionHtml))
                {
                    using (XmlReader reader = XmlReader.Create(stringReader, DefinitionReaderSettings))
                    {
                        xmlWriter.WriteNode(reader, true);
                    }
                }

                xmlWriter.WriteEndElement();
            }

            xmlWriter.WriteEndElement();
            xmlWriter.Flush();
        }
Пример #59
0
        private static mvdXML Deserialize(XmlReader xreader)
        {
            var ser = (mvdXML)(Serializer.Deserialize(xreader));

            return(ser);
        }
Пример #60
0
 public static bool CheckAvaloniaRoot(string content)
 {
     return(CheckAvaloniaRoot(XmlReader.Create(new StringReader(content), XmlSettings)));
 }