Ejemplo n.º 1
0
        public static int Main(string[] args)
        {
            ThisAssembly = Assembly.GetExecutingAssembly();
            XmlSchemaSet           set = new XmlSchemaSet();
            ValidationEventHandler veh = new ValidationEventHandler(ValidationCallback);

            set.ValidationEventHandler += veh;
            string csFileName          = string.Empty;
            string configFileName      = null;
            string assemblyName        = string.Empty;
            bool   fSourceNameProvided = false;
            bool   xmlSerializable     = false;
            bool   nameMangler2        = false;

            if (args.Length == 0)
            {
                PrintHelp();
                return(0);
            }
            for (int i = 0; i < args.Length; i++)
            {
                string arg      = args[i];
                string value    = string.Empty;
                bool   argument = false;

                if (arg.StartsWith("/") || arg.StartsWith("-"))
                {
                    argument = true;
                    int colonPos = arg.IndexOf(":");
                    if (colonPos != -1)
                    {
                        value = arg.Substring(colonPos + 1);
                        arg   = arg.Substring(0, colonPos);
                    }
                }
                arg = arg.ToLower(CultureInfo.InvariantCulture);
                if (!argument)
                {
                    try
                    {
                        set.Add(null, CreateReader(arg));
                    }
                    catch (Exception e) {
                        PrintErrorMessage(e.ToString());
                        return(1);
                    }
                    if (csFileName == string.Empty)
                    {
                        csFileName = Path.ChangeExtension(arg, "cs");
                    }
                }
                else if (ArgumentMatch(arg, "?") || ArgumentMatch(arg, "help"))
                {
                    PrintHelp();
                    return(0);
                }
                else if (ArgumentMatch(arg, "config"))
                {
                    configFileName = value;
                }
                else if (ArgumentMatch(arg, "filename"))
                {
                    csFileName          = value;
                    fSourceNameProvided = true;
                }
                else if (ArgumentMatch(arg, "enableservicereference"))
                {
                    xmlSerializable = true;
                }
                else if (ArgumentMatch(arg, "lib"))
                {
                    assemblyName = value;
                }
                else if (ArgumentMatch(arg, "namemangler2"))
                {
                    nameMangler2 = true;
                }
            }
            if (assemblyName != string.Empty && !fSourceNameProvided)
            {
                //only generate assembly
                csFileName = string.Empty;
            }
            set.Compile();
            set.ValidationEventHandler -= veh;
            if (set.Count > 0 && set.IsCompiled)
            {
                /*
                 * GenerateXObjects(
                 *  set, csFileName, configFileName, assemblyName, xmlSerializable, nameMangler2);
                 */
                try
                {
                    GenerateXObjects(
                        set, csFileName, configFileName, assemblyName, xmlSerializable, nameMangler2);
                }
                catch (Exception e)
                {
                    PrintErrorMessage(e.ToString());
                    return(1);
                }
            }
            return(0);
        }
    public static void Main()
    {
        XmlSchema schema = new XmlSchema();

        // <xs:simpleType name="RatingType">
        XmlSchemaSimpleType RatingType = new XmlSchemaSimpleType();

        RatingType.Name = "RatingType";

        // <xs:restriction base="xs:number">
        XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction();

        restriction.BaseTypeName = new XmlQualifiedName("decimal", "http://www.w3.org/2001/XMLSchema");

        // <xs:totalDigits value="2"/>
        XmlSchemaTotalDigitsFacet totalDigits = new XmlSchemaTotalDigitsFacet();

        totalDigits.Value = "2";
        restriction.Facets.Add(totalDigits);

        // <xs:fractionDigits value="1"/>
        XmlSchemaFractionDigitsFacet fractionDigits = new XmlSchemaFractionDigitsFacet();

        fractionDigits.Value = "1";
        restriction.Facets.Add(fractionDigits);

        RatingType.Content = restriction;

        schema.Items.Add(RatingType);

        // <xs:element name="movie">
        XmlSchemaElement element = new XmlSchemaElement();

        element.Name = "movie";

        // <xs:complexType>
        XmlSchemaComplexType complexType = new XmlSchemaComplexType();

        // <xs:attribute name="rating" type="RatingType"/>
        XmlSchemaAttribute ratingAttribute = new XmlSchemaAttribute();

        ratingAttribute.Name           = "rating";
        ratingAttribute.SchemaTypeName = new XmlQualifiedName("RatingType", "");
        complexType.Attributes.Add(ratingAttribute);

        element.SchemaType = complexType;

        schema.Items.Add(element);

        XmlSchemaSet schemaSet = new XmlSchemaSet();

        schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallbackOne);
        schemaSet.Add(schema);
        schemaSet.Compile();

        XmlSchema compiledSchema = null;

        foreach (XmlSchema schema1 in schemaSet.Schemas())
        {
            compiledSchema = schema1;
        }

        XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable());

        nsmgr.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema");
        compiledSchema.Write(Console.Out, nsmgr);
    }
Ejemplo n.º 3
0
        static void Main(string[] args)
        {
            Assembly rimworld = Assembly.Load("Assembly-CSharp, Version=1.0.6955.24033, Culture=neutral, PublicKeyToken=null");

            var defs =
                from type in rimworld.GetExportedTypes()
                where type.IsClass && !type.IsAbstract && typeof(Def).IsAssignableFrom(type)
                select type;

            XmlSchema schema = new XmlSchema
            {
                TargetNamespace    = "https://github.com/kfish610/RimWorldSchema",
                ElementFormDefault = XmlSchemaForm.Qualified
            };

            var defsRoot = new XmlSchemaElement
            {
                Name = "Defs"
            };

            var defsType = new XmlSchemaComplexType();

            defsRoot.SchemaType = defsType;

            var defsChoice = new XmlSchemaChoice()
            {
                MinOccurs       = 1,
                MaxOccursString = "unbounded"
            };

            defsType.Particle = defsChoice;

            schema.Items.Add(defsRoot);

            foreach (var def in defs)
            {
                Aliases.Add(def, "string");
            }

            foreach (var def in defs)
            {
                defsChoice.Items.Add(new XmlSchemaElement()
                {
                    Name       = def.Name,
                    SchemaType = Derive(def)
                });
            }

            defsChoice.Items.Add(new XmlSchemaAny()
            {
                MinOccurs       = 0,
                MaxOccursString = "unbounded",
                ProcessContents = XmlSchemaContentProcessing.Skip
            });

            foreach (var type in types)
            {
                schema.Items.Insert(0, type);
            }

            XmlSchemaSet schemaSet = new XmlSchemaSet();

            schemaSet.ValidationEventHandler += new ValidationEventHandler((_, e) => Console.WriteLine(e.Message));
            schemaSet.Add(schema);
            schemaSet.Compile();

            XmlSchema compiledSchema = null;

            foreach (XmlSchema schema1 in schemaSet.Schemas())
            {
                compiledSchema = schema1;
            }

            XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable());

            nsmgr.AddNamespace(string.Empty, "https://github.com/kfish610/RimWorldSchema");
            nsmgr.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema");

            File.WriteAllText(@"schema.xsd", string.Empty);
            using StreamWriter file = new StreamWriter(@"schema.xsd");
            compiledSchema.Write(file, nsmgr);
        }
Ejemplo n.º 4
0
        [Test]         // part of bug #670945
        public void TwoSchemasInSameDocumentUri()
        {
            string xsd1 = @"
    <xs:schema
    targetNamespace='http://www.onvif.org/ver10/schema'
    elementFormDefault='qualified'
    xmlns:xs='http://www.w3.org/2001/XMLSchema'
    xmlns:tt='http://www.onvif.org/ver10/schema'>

      <xs:complexType name='SystemDateTime'>
        <xs:sequence>
          <xs:element name='foobar' type='xs:string' minOccurs='0' />
          <xs:element name='Extension' type='tt:SystemDateTimeExtension' minOccurs='0'/>
        </xs:sequence>
        <!-- xs:anyAttribute processContents='lax'/ -->
      </xs:complexType>

      <xs:complexType name='SystemDateTimeExtension'>
        <xs:sequence>
          <xs:any namespace='##any' processContents='lax' minOccurs='0' maxOccurs='unbounded'/>
        </xs:sequence>
      </xs:complexType>

    </xs:schema>";

            string xsd2 = @"
    <xs:schema
      targetNamespace='http://www.onvif.org/ver10/device/wsdl'
      xmlns:xs='http://www.w3.org/2001/XMLSchema'
      xmlns:tt='http://www.onvif.org/ver10/schema'
      xmlns:tds='http://www.onvif.org/ver10/device/wsdl' 
      elementFormDefault='qualified'>
      <xs:element name='GetSystemDateAndTime'>
        <xs:complexType>
          <xs:sequence/>

        </xs:complexType>
      </xs:element>
      <xs:element name='GetSystemDateAndTimeResponse'>
        <xs:complexType>
          <xs:sequence>
            <xs:element name='SystemDateAndTime' type='tt:SystemDateTime' />
          </xs:sequence>
        </xs:complexType>
      </xs:element>
    </xs:schema>";

            var xss = new XmlSchemaSet();
            var xs1 = XmlSchema.Read(new StringReader(xsd1), null);

            xs1.SourceUri  = "http://localhost:8080/dummy.wsdl";
            xs1.LineNumber = 5;
            xss.Add(xs1);
            var xs2 = XmlSchema.Read(new StringReader(xsd2), null);

            xs2.SourceUri  = "http://localhost:8080/dummy.wsdl";
            xs2.LineNumber = 50;
            xss.Add(xs2);
            xss.Compile();
            Assert.IsNotNull(xss.GlobalElements [new XmlQualifiedName("GetSystemDateAndTimeResponse", "http://www.onvif.org/ver10/device/wsdl")], "#1");
        }
Ejemplo n.º 5
0
        private void RetrieveSerializableSchema()
        {
            if (_needSchema)
            {
                _needSchema = false;
                if (_getSchemaMethod != null)
                {
                    // get the type info
                    if (_schemas == null)
                    {
                        _schemas = new XmlSchemaSet();
                    }
                    object typeInfo = _getSchemaMethod.Invoke(null, new object[] { _schemas });
                    _xsiType = XmlQualifiedName.Empty;

                    if (typeInfo != null)
                    {
                        if (typeof(XmlSchemaType).IsAssignableFrom(_getSchemaMethod.ReturnType))
                        {
                            _xsdType = (XmlSchemaType)typeInfo;
                            // check if type is named
                            _xsiType = _xsdType.QualifiedName;
                        }
                        else if (typeof(XmlQualifiedName).IsAssignableFrom(_getSchemaMethod.ReturnType))
                        {
                            _xsiType = (XmlQualifiedName)typeInfo;
                            if (_xsiType.IsEmpty)
                            {
                                throw new InvalidOperationException(SR.Format(SR.XmlGetSchemaEmptyTypeName, _type.FullName, _getSchemaMethod.Name));
                            }
                        }
                        else
                        {
                            throw new InvalidOperationException(SR.Format(SR.XmlGetSchemaMethodReturnType, _type.Name, _getSchemaMethod.Name, typeof(XmlSchemaProviderAttribute).Name, typeof(XmlQualifiedName).FullName));
                        }
                    }
                    else
                    {
                        _any = true;
                    }

                    // make sure that user-specified schemas are valid
                    _schemas.ValidationEventHandler += new ValidationEventHandler(ValidationCallbackWithErrorCode);
                    _schemas.Compile();
#if !XMLSERIALIZERGENERATOR
                    // at this point we verified that the information returned by the IXmlSerializable is valid
                    // Now check to see if the type was referenced before:
                    // UNDONE check for the duplcate types
                    if (!_xsiType.IsEmpty)
                    {
                        // try to find the type in the schemas collection
                        if (_xsiType.Namespace != XmlSchema.Namespace)
                        {
                            ArrayList srcSchemas = (ArrayList)_schemas.Schemas(_xsiType.Namespace);

                            if (srcSchemas.Count == 0)
                            {
                                throw new InvalidOperationException(SR.Format(SR.XmlMissingSchema, _xsiType.Namespace));
                            }
                            if (srcSchemas.Count > 1)
                            {
                                throw new InvalidOperationException(SR.Format(SR.XmlGetSchemaInclude, _xsiType.Namespace, _getSchemaMethod.DeclaringType.FullName, _getSchemaMethod.Name));
                            }
                            XmlSchema s = (XmlSchema)srcSchemas[0];
                            if (s == null)
                            {
                                throw new InvalidOperationException(SR.Format(SR.XmlMissingSchema, _xsiType.Namespace));
                            }
                            _xsdType = (XmlSchemaType)s.SchemaTypes[_xsiType];
                            if (_xsdType == null)
                            {
                                throw new InvalidOperationException(SR.Format(SR.XmlGetSchemaTypeMissing, _getSchemaMethod.DeclaringType.FullName, _getSchemaMethod.Name, _xsiType.Name, _xsiType.Namespace));
                            }
                            _xsdType = _xsdType.Redefined != null ? _xsdType.Redefined : _xsdType;
                        }
                    }
#endif
                }
                else
                {
                    IXmlSerializable serializable = (IXmlSerializable)Activator.CreateInstance(_type);
                    _schema = serializable.GetSchema();

                    if (_schema != null)
                    {
                        if (_schema.Id == null || _schema.Id.Length == 0)
                        {
                            throw new InvalidOperationException(SR.Format(SR.XmlSerializableNameMissing1, _type.FullName));
                        }
                    }
                }
            }
        }
Ejemplo n.º 6
0
    public static void Main()
    {
        XmlSchema schema = new XmlSchema();

        // <xs:simpleType name="ZipCodeType">
        XmlSchemaSimpleType ZipCodeType = new XmlSchemaSimpleType();

        ZipCodeType.Name = "ZipCodeType";

        // <xs:restriction base="xs:string">
        XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction();

        restriction.BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");

        // <xs:pattern value="[0-9]{5}(-[0-9]{4})?"/>
        XmlSchemaPatternFacet pattern = new XmlSchemaPatternFacet();

        pattern.Value = "[0-9]{5}(-[0-9]{4})?";
        restriction.Facets.Add(pattern);

        ZipCodeType.Content = restriction;

        schema.Items.Add(ZipCodeType);

        // <xs:element name="Address">
        XmlSchemaElement element = new XmlSchemaElement();

        element.Name = "Address";

        // <xs:complexType>
        XmlSchemaComplexType complexType = new XmlSchemaComplexType();

        // <xs:attribute name="ZipCode" type="ZipCodeType"/>
        XmlSchemaAttribute ZipCodeAttribute = new XmlSchemaAttribute();

        ZipCodeAttribute.Name           = "ZipCode";
        ZipCodeAttribute.SchemaTypeName = new XmlQualifiedName("ZipCodeType", "");
        complexType.Attributes.Add(ZipCodeAttribute);

        element.SchemaType = complexType;

        schema.Items.Add(element);

        XmlSchemaSet schemaSet = new XmlSchemaSet();

        schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallbackOne);
        schemaSet.Add(schema);
        schemaSet.Compile();

        XmlSchema compiledSchema = null;

        foreach (XmlSchema schema1 in schemaSet.Schemas())
        {
            compiledSchema = schema1;
        }

        XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable());

        nsmgr.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema");
        compiledSchema.Write(Console.Out, nsmgr);
    }
Ejemplo n.º 7
0
        public void Generate(UblGeneratorOptions options)
        {
            _options = options;
            options.Validate();

            var baseInputDirectory = options.XsdBasePath;
            var commonDirectory    = Path.Combine(baseInputDirectory, "common");
            var xmldsigFilename    = new DirectoryInfo(commonDirectory).GetFiles("UBL-xmldsig-core-schema-*.xsd").Single().FullName;
            var maindocDirectory   = Path.Combine(baseInputDirectory, "maindoc");
            var maindocfiles       = new DirectoryInfo(maindocDirectory).GetFiles("*.xsd").ToList();
            // var extrafiles = new DirectoryInfo(commonDirectory).GetFiles("UBL-CommonSignatureComponents*.xsd").ToList();
            // var maindocfiles = new DirectoryInfo(maindocDirectory).GetFiles("UBL-Order-2.1.xsd").ToList();
            // maindocfiles.Add(new DirectoryInfo(maindocDirectory).GetFiles("UBL-BaseDocument-*.xsd").Single());

            var maindocSchemaSet = new XmlSchemaSet();

            var nameTable      = new NameTable();
            var readerSettings = new XmlReaderSettings
            {
                ValidationType = ValidationType.Schema,
                DtdProcessing  = DtdProcessing.Parse,
                NameTable      = nameTable,
            };

            using (var reader = XmlReader.Create(xmldsigFilename, readerSettings))
            {
                var schema = XmlSchema.Read(reader, null);
                maindocSchemaSet.Add(schema);
            }

            foreach (var maindocfile in maindocfiles)
            {
                using (var reader = XmlReader.Create(maindocfile.FullName, readerSettings))
                {
                    var schema = XmlSchema.Read(reader, null);
                    maindocSchemaSet.Add(schema);
                }
            }

            //foreach (var extrafile in extrafiles)
            //{
            //    using (var reader = XmlReader.Create(extrafile.FullName, readerSettings))
            //    {
            //        var schema = XmlSchema.Read(reader, null);
            //        maindocSchemaSet.Add(schema);
            //    }
            //}

            maindocSchemaSet.Compile();

            foreach (var schemaFixer in _schemaFixers)
            {
                schemaFixer(maindocSchemaSet);
                maindocSchemaSet.Compile();
            }

            var rootNamespaces = maindocSchemaSet.Schemas().OfType <XmlSchema>()
                                 .Where(x => x.SourceUri.Contains("maindoc"))
                                 .Select(x => x.TargetNamespace)
                                 .Concat(new[]
            {
                Namespaces.Xmldsig,
                Namespaces.Sac,
                Namespaces.Csc,
                Namespaces.Xades141,
            });

            var tempCodeNamespace = CreateCodeNamespace(maindocSchemaSet, rootNamespaces.ToArray());

            _globalCodeFixer.Fix(tempCodeNamespace);

            var codeDeclsBySchema = (from t in tempCodeNamespace.Types.Cast <CodeTypeDeclaration>()
                                     group t by t.GetSchema() into g
                                     select g)
                                    .ToDictionary(k => k.Key, v => v.ToArray());

            var codeProvider   = new Microsoft.CodeDom.Providers.DotNetCompilerPlatform.CSharpCodeProvider();
            var codegenOptions = new CodeGeneratorOptions()
            {
                BracingStyle             = "C",
                IndentString             = "    ",
                BlankLinesBetweenMembers = true,
                VerbatimOrder            = true
            };

            var namespaceProvider = new CodeNamespaceProvider(maindocSchemaSet, options);

            foreach (var schema in maindocSchemaSet.Schemas().Cast <XmlSchema>())
            {
                var codeNamespace = namespaceProvider.CreateCodeNamespace(schema.TargetNamespace);
                if (codeDeclsBySchema.ContainsKey(schema))
                {
                    codeNamespace.Types.AddRange(codeDeclsBySchema[schema]);
                }

                if (codeNamespace.Types.Count == 0)
                {
                    continue;
                }

                _namespacedCodeFixer.Fix(codeNamespace);

                var sb = new StringBuilder();
                using (var sw = new StringWriter(sb))
                {
                    codeProvider.GenerateCodeFromNamespace(codeNamespace, sw, codegenOptions);
                }

                sb = sb.Replace("Namespace=\"", "Namespace = \"");

                var fileContent = sb.ToString();
                var lines       = fileContent.Split(new[] { Environment.NewLine }, StringSplitOptions.None).ToList();

                foreach (var fixer in _conditionalFeatureFixers)
                {
                    int lineNum = 0;
                    while (true)
                    {
                        lineNum = fixer(lines, lineNum);
                        if (lineNum < 0)
                        {
                            break;
                        }
                    }
                }

                sb = new StringBuilder(string.Join(Environment.NewLine, lines));

                var    xsdFilename = new Uri(schema.SourceUri).LocalPath;
                var    fi          = new FileInfo(xsdFilename);
                var    foldername  = namespaceProvider.GetNamespaceFolderName(schema);
                string targetPath  = Path.Combine(options.OutputPath, foldername);
                if (!Directory.Exists(targetPath))
                {
                    Directory.CreateDirectory(targetPath);
                }
                var outputFile = Path.Combine(targetPath, Path.ChangeExtension(fi.Name, ".generated.cs"));

                using (var ofile = File.CreateText(outputFile))
                {
                    ofile.Write(sb);
                }
            }
        }
Ejemplo n.º 8
0
    static void Main(string[] args)
    {
        // Add the customer schema to a new XmlSchemaSet and compile it.
        // Any schema validation warnings and errors encountered reading or
        // compiling the schema are handled by the ValidationEventHandler delegate.
        XmlSchemaSet schemaSet = new XmlSchemaSet();

        schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallback);
        schemaSet.Add("http://www.tempuri.org", "customer.xsd");
        schemaSet.Compile();

        // Retrieve the compiled XmlSchema object from the XmlSchemaSet
        // by iterating over the Schemas property.
        XmlSchema customerSchema = null;

        foreach (XmlSchema schema in schemaSet.Schemas())
        {
            customerSchema = schema;
        }

        // Create the PhoneNumber element.
        XmlSchemaElement phoneElement = new XmlSchemaElement();

        phoneElement.Name = "PhoneNumber";

        // Create the xs:string simple type restriction.
        XmlSchemaSimpleType            phoneType   = new XmlSchemaSimpleType();
        XmlSchemaSimpleTypeRestriction restriction =
            new XmlSchemaSimpleTypeRestriction();

        restriction.BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");

        // Add a pattern facet to the restriction.
        XmlSchemaPatternFacet phonePattern = new XmlSchemaPatternFacet();

        phonePattern.Value = "\\d{3}-\\d{3}-\\d(4)";
        restriction.Facets.Add(phonePattern);

        // Add the restriction to the Content property of the simple type
        // and the simple type to the SchemaType of the PhoneNumber element.
        phoneType.Content       = restriction;
        phoneElement.SchemaType = phoneType;

        // Iterate over each XmlSchemaElement in the Values collection
        // of the Elements property.
        foreach (XmlSchemaElement element in customerSchema.Elements.Values)
        {
            // If the qualified name of the element is "Customer",
            // get the complex type of the Customer element
            // and the sequence particle of the complex type.
            if (element.QualifiedName.Name.Equals("Customer"))
            {
                XmlSchemaComplexType customerType =
                    element.ElementSchemaType as XmlSchemaComplexType;
                XmlSchemaSequence sequence =
                    customerType.Particle as XmlSchemaSequence;

                // Add the new PhoneNumber element to the sequence.
                sequence.Items.Add(phoneElement);
            }
        }

        // Reprocess and compile the modified XmlSchema object and write it to the console.
        schemaSet.Reprocess(customerSchema);
        schemaSet.Compile();
        customerSchema.Write(Console.Out);
    }
Ejemplo n.º 9
0
        public bool Validate(out string tedXml)
        {
            if (_notice.IsCorrigendum)
            {
                if (_notice.Parent == null)
                {
                    _validationErrors.Add("Corrigendum notice should have parent set. Parent is null.");
                    tedXml = string.Empty;
                    return(false);
                }

                // Validate that the notice is not expired
                bool isWindows            = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
                var  localFinnishTimezone = isWindows ? TimeZoneInfo.FindSystemTimeZoneById("E. Europe Standard Time") : TimeZoneInfo.FindSystemTimeZoneById("Europe/Helsinki");
                var  timeInLocalTimezone  = TimeZoneInfo.ConvertTime(DateTime.UtcNow, localFinnishTimezone);
                var  expirationTime       = _notice.Parent.TenderingInformation?.TendersOrRequestsToParticipateDueDateTime;

                if (expirationTime.HasValue && expirationTime.Value <= timeInLocalTimezone)
                {
                    _validationErrors.Add($"Corrigendum notice cannot be made to notice that has expired TendersOrRequestsToParticipateDueDateTime: ExpirationTime: {expirationTime}, Current local time: {timeInLocalTimezone}");

                    tedXml = string.Empty;
                    return(false);
                }
            }

            if (_notice.Type.IsNational())
            {
                // Do not validate national notices
                tedXml = null;
                return(true);
            }


            var path   = Path.GetFullPath(AppDomain.CurrentDomain.BaseDirectory);
            var schema = new XmlSchemaSet {
                XmlResolver = new XmlUrlResolver()
            };
            var nameSpace = XmlnsGeneral;
            var isDefence = _notice.Type.IsDefence();

            if (isDefence)
            {
                schema.Add(XmlnsDefence.ToString(), Path.Combine(path, "Validators", "TedSchema", "208Defence", "TED_ESENDERS.xsd"));
                nameSpace = XmlnsDefence;
            }
            else
            {
                schema.Add(XmlnsGeneral.ToString(), Path.Combine(path, "Validators", "TedSchema", "209General", "TED_ESENDERS.xsd"));
            }
            schema.Compile();

            var noticeContract = _mapper.Map <NoticeContract>(_notice);
            var parent         = _notice.Parent != null?_mapper.Map <NoticeContract>(_notice.Parent) : new NoticeContract();

            var xDoc = new TedNoticeFactory(noticeContract, parent, "Validator", "*****@*****.**", "TEDEXXXX", _translationProvider).CreateDocument();
            var copy = new XDocument(xDoc);

            if (isDefence)
            {
                // Add namespace attribute to fix the validation
                copy = TedHelpers.SetRootNamespace(copy);
            }

            copy.Validate(schema, (sender, e) => { _validationErrors.Add(e.Message + "\n"); });



            // We don't want to send the login part in the response.
            if (isDefence)
            {
                // defense version does not use root namespace in ted xml
                var descendants = xDoc.Descendants("FORM_SECTION");
                tedXml = string.Join("\n", descendants);
            }
            else
            {
                var descendants = xDoc.Descendants(nameSpace + "FORM_SECTION");
                tedXml = string.Join("\n", descendants);
            }

            var teSchemaValid = Valid(!_validationErrors.Any(), "TED message formed:\n" + tedXml);

            return(ValidateAll(teSchemaValid, ValidateValueFields(noticeContract)));
        }
Ejemplo n.º 10
0
        /// <summary>
        /// Initiate code generation process
        /// </summary>
        /// <param name="generatorParams">Generator parameters</param>
        /// <returns></returns>
        internal static Result <CodeNamespace> Process(GeneratorParams generatorParams)
        {
            var ns = new CodeNamespace();

            XmlReader reader = null;

            try
            {
                #region Set generation context

                GeneratorContext.GeneratorParams = generatorParams;

                #endregion

                #region Get XmlTypeMapping

                XmlSchema xsd;
                var       schemas = new XmlSchemas();

                reader = XmlReader.Create(generatorParams.InputFilePath);
                xsd    = XmlSchema.Read(reader, new ValidationEventHandler(Validate));

                var schemaSet = new XmlSchemaSet();
                schemaSet.Add(xsd);
                schemaSet.Compile();

                foreach (XmlSchema schema in schemaSet.Schemas())
                {
                    schemas.Add(schema);
                }

                const CodeGenerationOptions generationOptions = CodeGenerationOptions.GenerateOrder;
                var exporter = new XmlCodeExporter(ns);
                var importer = new XmlSchemaImporter(schemas, generationOptions, new ImportContext(new CodeIdentifiers(), false));

                foreach (XmlSchemaElement element in xsd.Elements.Values)
                {
                    var mapping = importer.ImportTypeMapping(element.QualifiedName);
                    exporter.ExportTypeMapping(mapping);
                }

                //Fixes/handles http://xsd2code.codeplex.com/WorkItem/View.aspx?WorkItemId=6941
                foreach (XmlSchemaComplexType complex in xsd.Items.OfType <XmlSchemaComplexType>())
                {
                    var mapping = importer.ImportSchemaType(complex.QualifiedName);
                    exporter.ExportTypeMapping(mapping);
                }

                #endregion

                #region Execute extensions

                var getExtensionResult = GeneratorFactory.GetCodeExtension(generatorParams);
                if (!getExtensionResult.Success)
                {
                    return(new Result <CodeNamespace>(ns, false, getExtensionResult.Messages));
                }

                var ext = getExtensionResult.Entity;
                ext.Process(ns, xsd);

                #endregion Execute extensions

                return(new Result <CodeNamespace>(ns, true));
            }
            catch (Exception e)
            {
                return(new Result <CodeNamespace>(ns, false, e.Message, MessageType.Error));
            }
            finally
            {
                if (reader != null)
                {
                    reader.Close();
                }
            }
        }
Ejemplo n.º 11
0
        /// <include file='doc\XmlSchemas.uex' path='docs/doc[@for="XmlSchemas.Compile"]/*' />
        public void Compile(ValidationEventHandler handler, bool fullCompile)
        {
            if (isCompiled)
            {
                return;
            }

            foreach (XmlSchema s in delayedSchemas.Values)
            {
                Merge(s);
            }
            delayedSchemas.Clear();

            if (fullCompile)
            {
                schemaSet                         = new XmlSchemaSet();
                schemaSet.XmlResolver             = null;
                schemaSet.ValidationEventHandler += handler;

                foreach (XmlSchema s in References.Values)
                {
                    schemaSet.Add(s);
                }
                int schemaCount = schemaSet.Count;

                foreach (XmlSchema s in List)
                {
                    if (!SchemaSet.Contains(s))
                    {
                        schemaSet.Add(s);
                        schemaCount++;
                    }
                }

                if (!SchemaSet.Contains(XmlSchema.Namespace))
                {
                    AddReference(XsdSchema);
                    schemaSet.Add(XsdSchema);
                    schemaCount++;
                }

                if (!SchemaSet.Contains(XmlReservedNs.NsXml))
                {
                    AddReference(XmlSchema);
                    schemaSet.Add(XmlSchema);
                    schemaCount++;
                }
                schemaSet.Compile();
                schemaSet.ValidationEventHandler -= handler;
                isCompiled = schemaSet.IsCompiled && schemaCount == schemaSet.Count;
            }
            else
            {
                try {
                    XmlNameTable nameTable = new System.Xml.NameTable();
                    Preprocessor prep      = new Preprocessor(nameTable, new SchemaNames(nameTable), null);
                    prep.XmlResolver      = null;
                    prep.SchemaLocations  = new Hashtable();
                    prep.ChameleonSchemas = new Hashtable();
                    foreach (XmlSchema schema in SchemaSet.Schemas())
                    {
                        prep.Execute(schema, schema.TargetNamespace, true);
                    }
                }
                catch (XmlSchemaException e) {
                    throw CreateValidationException(e, e.Message);
                }
            }
        }
        private static void Main(string[] args)
        {
            XmlSchemaSet schemaSet = new XmlSchemaSet();

            schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallback);
            schemaSet.Add("http://www.w3.org/2001/XMLSchema", "C:\\Chandan\\myxsdfile.xsd");
            schemaSet.Compile();
            XmlSchema xmlSchema = null;

            foreach (XmlSchema schema in schemaSet.Schemas())
            {
                xmlSchema = schema;
            }
            DataSet myDS = new DataSet();

            myDS.ReadXmlSchema("C:\\Chandan\\myxsdfile.xsd");
            foreach (object item in xmlSchema.Items)
            {
                XmlSchemaElement     schemaElement = item as XmlSchemaElement;
                XmlSchemaComplexType complexType   = item as XmlSchemaComplexType;
                if (schemaElement != null)
                {
                    Console.Out.WriteLine("Schema Element: {0}", schemaElement.Name);
                    XmlSchemaType        schemaType        = schemaElement.SchemaType;
                    XmlSchemaComplexType schemaComplexType = schemaType as XmlSchemaComplexType;
                    if (schemaComplexType != null)
                    {
                        XmlSchemaParticle particle = schemaComplexType.Particle;
                        XmlSchemaSequence sequence = particle as XmlSchemaSequence;
                        if (sequence != null)
                        {
                            foreach (XmlSchemaElement childElement in sequence.Items)
                            {
                                Console.Out.WriteLine("    Element/Type: {0}:{1}", childElement.Name,
                                                      childElement.SchemaTypeName.Name);
                            }
                        }
                        if (schemaComplexType.AttributeUses.Count > 0)
                        {
                            IDictionaryEnumerator enumerator = schemaComplexType.AttributeUses.GetEnumerator();
                            while (enumerator.MoveNext())
                            {
                                XmlSchemaAttribute attribute = (XmlSchemaAttribute)enumerator.Value;
                                Console.Out.WriteLine("      Attribute/Type: {0}", attribute.Name);
                            }
                        }
                    }
                }
                else if (complexType != null)
                {
                    Console.Out.WriteLine("Complex Type: {0}", complexType.Name);
                    OutputElements(complexType.Particle);
                    if (complexType.AttributeUses.Count > 0)
                    {
                        IDictionaryEnumerator enumerator = complexType.AttributeUses.GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            XmlSchemaAttribute attribute = (XmlSchemaAttribute)enumerator.Value;
                            Console.Out.WriteLine("      Attribute/Type: {0}", attribute.Name);
                        }
                    }
                }
                Console.Out.WriteLine();
            }
            Console.Out.WriteLine();
            Console.In.ReadLine();
        }
Ejemplo n.º 13
0
        public void v51(object param0, object param1, object param2, object param3)
        {
            bWarningCallback = false;
            bErrorCallback   = false;

            string mainFile = TestData._Root + param0.ToString();
            string include1 = TestData._Root + param1.ToString();
            string include2 = TestData._Root + param2.ToString();
            string xmlFile  = TestData._Root + "bug382119.xml";
            bool   IsImport = (bool)param3;

            XmlSchemaSet set1 = new XmlSchemaSet();

            set1.XmlResolver             = new XmlUrlResolver();
            set1.ValidationEventHandler += new ValidationEventHandler(ValidationCallback);
            XmlSchema includedSchema = set1.Add(null, include1);

            set1.Compile();

            XmlSchemaSet set = new XmlSchemaSet();

            set.XmlResolver             = new XmlUrlResolver();
            set.ValidationEventHandler += new ValidationEventHandler(ValidationCallback);
            XmlSchema mainSchema = set.Add(null, mainFile);

            set.Compile();

            _output.WriteLine("First validation ***************");
            XmlReaderSettings settings = new XmlReaderSettings();

            settings.ValidationEventHandler += new ValidationEventHandler(ValidationCallback);
            settings.ValidationType          = ValidationType.Schema;
            settings.Schemas = set;
            XmlReader reader = XmlReader.Create(xmlFile, settings);

            while (reader.Read())
            {
            }

            CError.Compare(bWarningCallback, false, "Warning count mismatch");
            CError.Compare(bErrorCallback, true, "Error count mismatch");

            if (IsImport == true)
            {
                set.Remove(((XmlSchemaExternal)mainSchema.Includes[0]).Schema);
            }
            _output.WriteLine("re-setting include");
            XmlSchema reParsedInclude = LoadSchema(include2, include1);

            ((XmlSchemaExternal)mainSchema.Includes[0]).Schema = reParsedInclude;

            _output.WriteLine("Calling reprocess");

            set.Reprocess(mainSchema);
            set.Compile();

            bWarningCallback = false;
            bErrorCallback   = false;
            _output.WriteLine("Second validation ***************");
            settings.Schemas = set;
            reader           = XmlReader.Create(xmlFile, settings);
            while (reader.Read())
            {
            }

            CError.Compare(bWarningCallback, false, "Warning count mismatch");
            CError.Compare(bErrorCallback, false, "Error count mismatch");

            //Editing the include again
            _output.WriteLine("Re-adding include to set1");
            XmlSchema reParsedInclude2 = LoadSchema(include1, include1);

            set1.Remove(includedSchema);
            set1.Add(reParsedInclude2);
            set1.Compile();

            if (IsImport == true)
            {
                set.Remove(((XmlSchemaExternal)mainSchema.Includes[0]).Schema);
            }

            ((XmlSchemaExternal)mainSchema.Includes[0]).Schema = reParsedInclude2;
            set.Reprocess(mainSchema);
            set.Compile();

            bWarningCallback = false;
            bErrorCallback   = false;

            _output.WriteLine("Third validation, Expecting errors ***************");
            settings.Schemas = set;
            reader           = XmlReader.Create(xmlFile, settings);
            while (reader.Read())
            {
            }

            CError.Compare(bWarningCallback, false, "Warning count mismatch");
            CError.Compare(bErrorCallback, true, "Error count mismatch");

            return;
        }
Ejemplo n.º 14
0
    public static void Main()
    {
        XmlSchema schema = new XmlSchema();

        // <xs:simpleType name="OrderQuantityType">
        XmlSchemaSimpleType OrderQuantityType = new XmlSchemaSimpleType();

        OrderQuantityType.Name = "OrderQuantityType";

        // <xs:restriction base="xs:int">
        XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction();

        restriction.BaseTypeName = new XmlQualifiedName("int", "http://www.w3.org/2001/XMLSchema");

        // <xs:minInclusive value="5"/>
        XmlSchemaMinInclusiveFacet minInclusive = new XmlSchemaMinInclusiveFacet();

        minInclusive.Value = "5";
        restriction.Facets.Add(minInclusive);

        OrderQuantityType.Content = restriction;

        schema.Items.Add(OrderQuantityType);

        // <xs:element name="item">
        XmlSchemaElement element = new XmlSchemaElement();

        element.Name = "item";

        // <xs:complexType>
        XmlSchemaComplexType complexType = new XmlSchemaComplexType();

        // <xs:attribute name="OrderQuantity" type="OrderQuantityType"/>
        XmlSchemaAttribute OrderQuantityAttribute = new XmlSchemaAttribute();

        OrderQuantityAttribute.Name           = "OrderQuantity";
        OrderQuantityAttribute.SchemaTypeName = new XmlQualifiedName("OrderQuantityType", "");
        complexType.Attributes.Add(OrderQuantityAttribute);

        element.SchemaType = complexType;

        schema.Items.Add(element);

        XmlSchemaSet schemaSet = new XmlSchemaSet();

        schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallbackOne);
        schemaSet.Add(schema);
        schemaSet.Compile();

        XmlSchema compiledSchema = null;

        foreach (XmlSchema schema1 in schemaSet.Schemas())
        {
            compiledSchema = schema1;
        }

        XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable());

        nsmgr.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema");
        compiledSchema.Write(Console.Out, nsmgr);
    }
Ejemplo n.º 15
0
        //[Variation(Desc = "TFS_470021 Unexpected local particle qualified name when chameleon schema is added to set")]
        public void TFS_470021()
        {
            string cham = @"<?xml version='1.0' encoding='utf-8' ?>
<xs:schema id='a0'
                  elementFormDefault='qualified'
                  xmlns:xs='http://www.w3.org/2001/XMLSchema'>
  <xs:complexType name='ctseq1_a'>
    <xs:sequence>
      <xs:element name='foo'/>
    </xs:sequence>
    <xs:attribute name='abt0' type='xs:string'/>
  </xs:complexType>
  <xs:element name='gect1_a' type ='ctseq1_a'/>
</xs:schema>";
            string main = @"<?xml version='1.0' encoding='utf-8' ?>
<xs:schema id='m0'
                  targetNamespace='http://tempuri.org/chameleon1'
                  elementFormDefault='qualified'
                  xmlns='http://tempuri.org/chameleon1'
                  xmlns:mstns='http://tempuri.org/chameleon1'
                  xmlns:xs='http://www.w3.org/2001/XMLSchema'>
  <xs:include schemaLocation='cham.xsd' />

  <xs:element name='root'>
    <xs:complexType>
      <xs:sequence maxOccurs='unbounded'>
        <xs:any namespace='##any' processContents='lax'/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>";

            using (var tempDirectory = new TempDirectory())
            {
                string chamPath          = Path.Combine(tempDirectory.Path, "cham.xsd");
                string tempDirectoryPath = tempDirectory.Path[tempDirectory.Path.Length - 1] == Path.DirectorySeparatorChar ?
                                           tempDirectory.Path :
                                           tempDirectory.Path + Path.DirectorySeparatorChar;

                using (XmlWriter w = XmlWriter.Create(chamPath))
                {
                    using (XmlReader r = XmlReader.Create(new StringReader(cham)))
                        w.WriteNode(r, true);
                }
                XmlSchemaSet ss = new XmlSchemaSet();
                ss.ValidationEventHandler += new ValidationEventHandler(ValidationCallback);

                ss.Add(null, XmlReader.Create(new StringReader(cham)));
                // TempDirectory path must end with a DirectorySeratorChar, otherwise it will throw in the Xml validation.
                var settings = new XmlReaderSettings()
                {
                    XmlResolver = new XmlUrlResolver()
                };
                ss.Add(null, XmlReader.Create(new StringReader(main), settings, tempDirectoryPath));
                ss.Compile();

                Assert.Equal(2, ss.Count);
                foreach (XmlSchemaElement e in ss.GlobalElements.Values)
                {
                    _output.WriteLine(e.QualifiedName.ToString());
                    XmlSchemaComplexType type = e.ElementSchemaType as XmlSchemaComplexType;
                    XmlSchemaSequence    seq  = type.ContentTypeParticle as XmlSchemaSequence;
                    foreach (XmlSchemaObject child in seq.Items)
                    {
                        if (child is XmlSchemaElement)
                        {
                            _output.WriteLine("\t" + (child as XmlSchemaElement).QualifiedName);
                        }
                    }
                }
                Assert.Equal(0, warningCount);
                Assert.Equal(0, errorCount);
            }
        }
Ejemplo n.º 16
0
        public void v10()
        {
            XmlCachedSchemaSetResolver resolver = new XmlCachedSchemaSetResolver();
            XmlTextReader r = new XmlTextReader(TestData._Root + @"RedefineEmployee.xsd");
            XmlSchema     s = XmlSchema.Read(r, null);

            resolver.Add(new Uri(s.SourceUri), s);

            XmlTextReader r2 = new XmlTextReader(TestData._Root + @"BaseEmployee2.xsd");
            XmlSchema     s2 = XmlSchema.Read(r2, null);

            resolver.Add(new Uri(s2.SourceUri), s2);

            XmlSchemaSet set = new XmlSchemaSet();

            set.ValidationEventHandler += new ValidationEventHandler(callback);
            set.XmlResolver             = resolver;

            set.Add(s2);
            Assert.Equal(set.Count, 1);
            Assert.Equal(set.Contains(s2), true);
            Assert.Equal(set.IsCompiled, false);

            set.Add(s);
            Assert.Equal(set.Count, 2);
            Assert.Equal(set.Contains(s), true);
            Assert.Equal(set.IsCompiled, false);

            set.Compile();
            Assert.Equal(set.Count, 2);
            Assert.Equal(set.Contains(s2), true);
            Assert.Equal(set.Contains(s), true);
            Assert.Equal(set.IsCompiled, true);

            XmlTextReader r3 = new XmlTextReader(TestData._Root + @"BaseEmployee2.xsd");
            XmlSchema     s3 = XmlSchema.Read(r3, null);

            resolver.Add(new Uri(s3.SourceUri), s3);

            //Clear includes in S
            foreach (XmlSchemaExternal ext in s.Includes)
            {
                ext.Schema = null;
            }
            XmlSchemaSet set2 = new XmlSchemaSet();

            set2.ValidationEventHandler += new ValidationEventHandler(callback);
            set2.XmlResolver             = resolver;
            set2.Add(s3);
            Assert.Equal(set2.Count, 1);
            Assert.Equal(set2.Contains(s2), false);
            Assert.Equal(set2.Contains(s), false);
            Assert.Equal(set2.Contains(s3), true);
            Assert.Equal(set2.IsCompiled, false);

            set2.Add(s);
            Assert.Equal(set2.Count, 2);
            Assert.Equal(set2.Contains(s2), false);
            Assert.Equal(set2.Contains(s), true);
            Assert.Equal(set2.Contains(s3), true);
            Assert.Equal(set2.IsCompiled, false);

            set2.Compile();
            Assert.Equal(set2.Count, 2);
            Assert.Equal(set2.Contains(s2), false);
            Assert.Equal(set2.Contains(s), true);
            Assert.Equal(set2.Contains(s3), true);
            Assert.Equal(set2.IsCompiled, true);

            Assert.Equal(errorCount, 0);
        }
Ejemplo n.º 17
0
        /// <summary>
        /// Converts schemas to NodeTypes, AttributeTypes, and root elements</summary>
        /// <param name="schemaSet">Schemas to register</param>
        public void Load(XmlSchemaSet schemaSet)
        {
            if (!schemaSet.IsCompiled)
            {
                schemaSet.Compile();
            }

            System.Collections.ICollection schemas = schemaSet.Schemas();
            foreach (XmlSchema schema in schemas)
            {
                string targetNamespace = schema.TargetNamespace;
                if (string.IsNullOrEmpty(targetNamespace))
                {
                    throw new InvalidOperationException("Schema has no target namespace");
                }

                // only register the schema once; targetNamespaces must be globally unique
                if (!m_typeCollections.ContainsKey(targetNamespace))
                {
                    XmlQualifiedName[]      nameSpaces     = schema.Namespaces.ToArray();
                    XmlSchemaTypeCollection typeCollection = new XmlSchemaTypeCollection(nameSpaces, targetNamespace, this);
                    m_typeCollections.Add(targetNamespace, typeCollection);
                }
            }

            try
            {
                m_annotations     = new Dictionary <NamedMetadata, IList <XmlNode> >();
                m_typeNameSet     = new HashSet <string>();
                m_localElementSet = new Dictionary <XmlSchemaElement, XmlQualifiedName>();
                // collect global element & type names so we do not generate local type names that collides with those
                foreach (XmlSchemaElement element in schemaSet.GlobalElements.Values)
                {
                    m_typeNameSet.Add(element.QualifiedName.Name);
                }

                foreach (XmlSchemaType type in schemaSet.GlobalTypes.Values)
                {
                    if (type is XmlSchemaComplexType)
                    {
                        m_typeNameSet.Add(type.Name);
                    }
                }

                var substitutionGroups = new Multimap <XmlQualifiedName, ChildInfo>();

                // Get types reachable from global elements
                foreach (XmlSchemaElement element in schemaSet.GlobalElements.Values)
                {
                    XmlSchemaType type      = element.ElementSchemaType;
                    DomNodeType   nodeType  = GetNodeType(type, element);
                    ChildInfo     childInfo = new ChildInfo(GetFieldName(element.QualifiedName), nodeType);
                    m_annotations.Add(childInfo, GetAnnotation(element));

                    // Keep list of substitution groups
                    if (!element.SubstitutionGroup.IsEmpty)
                    {
                        substitutionGroups.Add(element.SubstitutionGroup, childInfo);
                    }

                    // only add root elements once; root element names must be globally unique
                    string name = element.QualifiedName.ToString();
                    if (!m_rootElements.ContainsKey(name))
                    {
                        m_rootElements[name] = childInfo;
                    }
                }

                // Get global complex type definitions
                foreach (XmlSchemaType type in schemaSet.GlobalTypes.Values)
                {
                    if (type is XmlSchemaComplexType)
                    {
                        GetNodeType(type, null);
                    }
                }

                // Parse substitution groups
                foreach (var kvp in m_refElements)
                {
                    XmlQualifiedName refName   = kvp.Value;
                    ChildInfo        childInfo = kvp.Key;

                    var substitutions = substitutionGroups.Find(refName).ToArray();
                    if (substitutions.Length > 0)
                    {
                        childInfo.AddRule(new SubstitutionGroupChildRule(substitutions));
                    }
                }

                // Preserve annotation from any types that were redefined
                foreach (XmlSchema schema in schemas)
                {
                    foreach (XmlSchemaObject schemaInclude in schema.Includes)
                    {
                        XmlSchemaRedefine schemaRedefine = schemaInclude as XmlSchemaRedefine;
                        if (schemaRedefine != null)
                        {
                            MergeRedefinedTypeAnnotations(schemaRedefine);
                        }
                    }
                }

                // Sort DomNodeTypes, so that base types are always before derived types
                // Bucket sort by depth in the inheritance tree
                // Time: O(n * d) with n = number of DomNodeTypes, d = depth of inheritance tree
                var sortedTypes = new List <List <DomNodeType> >();
                foreach (DomNodeType type in GetNodeTypes())
                {
                    // Get inheritance depth of current type
                    int         depth   = 0;
                    DomNodeType curType = type;
                    while (curType != null && curType != DomNodeType.BaseOfAllTypes)
                    {
                        depth++;
                        curType = curType.BaseType;
                    }

                    // We don't need to merge annotations for BaseAllTypes (level 0)
                    // and its immediate child types (level 1)
                    int idx = depth - 2;
                    if (idx >= 0)
                    {
                        while (sortedTypes.Count <= idx)
                        {
                            sortedTypes.Add(new List <DomNodeType>());
                        }
                        sortedTypes[idx].Add(type);
                    }
                }

                // Merge type annotations with base type annotations
                foreach (var list in sortedTypes)
                {
                    foreach (DomNodeType type in list)
                    {
                        if (type.BaseType != null && type.BaseType != DomNodeType.BaseOfAllTypes)
                        {
                            IList <XmlNode> baseAnnotations;
                            IList <XmlNode> annotations;
                            if (m_annotations.TryGetValue(type.BaseType, out baseAnnotations) &&
                                m_annotations.TryGetValue(type, out annotations))
                            {
                                // Call protected virtual merge method - allowing clients to define if & how annotations are being merged
                                IEnumerable <XmlNode> mergedAnnotations = MergeInheritedTypeAnnotations(baseAnnotations, annotations);
                                m_annotations[type] = mergedAnnotations as IList <XmlNode> ?? mergedAnnotations.ToList();
                            }
                        }
                    }
                }

                // Call before the DomNodeTypes are frozen. Note that iterating through Attributes or
                //  calling 'SetIdAttribute' freezes the attributes on DomNodeType.
                OnSchemaSetLoaded(schemaSet);

                // Set up ID attributes where xs:ID has been specified
                foreach (DomNodeType nodeType in GetNodeTypes())
                {
                    foreach (var attribute in nodeType.Attributes.OfType <XmlAttributeInfo>())
                    {
                        if (((XmlAttributeType)attribute.Type).XmlTypeCode == XmlTypeCode.Id)
                        {
                            nodeType.SetIdAttribute(attribute.Name);
                        }
                    }
                }

                // Attach annotation as metadata to the associated type so that other classes can find it
                foreach (var keyValuePair in m_annotations)
                {
                    if (keyValuePair.Value.Count > 0)
                    {
                        keyValuePair.Key.SetTag <IEnumerable <XmlNode> >(keyValuePair.Value);
                    }
                }
                ParseAnnotations(schemaSet, m_annotations);

                // Call this after the ID attributes have been set and after the DomNodeTypes are frozen.
                OnDomNodeTypesFrozen(schemaSet);
            }
            finally
            {
                m_annotations     = null;
                m_typeNameSet     = null;
                m_localElementSet = null;
            }
        }
Ejemplo n.º 18
0
        public void v11()
        {
            XmlCachedSchemaSetResolver resolver = new XmlCachedSchemaSetResolver();

            XmlTextReader r = new XmlTextReader(TestData._Root + @"RedefineEmployee.xsd");
            XmlSchema     s = XmlSchema.Read(r, null);

            resolver.Add(new Uri(s.SourceUri), s);

            XmlTextReader r2 = new XmlTextReader(TestData._Root + @"BaseEmployee2.xsd");
            XmlSchema     s2 = XmlSchema.Read(r2, null);

            resolver.Add(new Uri(s2.SourceUri), s2);

            XmlSchemaSet set = new XmlSchemaSet();

            set.XmlResolver = resolver;
            set.Add(s2);
            Assert.Equal(set.Count, 1);
            Assert.Equal(set.Contains(s2), true);
            Assert.Equal(set.IsCompiled, false);

            set.Add(s);
            Assert.Equal(set.Count, 2);
            Assert.Equal(set.Contains(s), true);
            Assert.Equal(set.IsCompiled, false);

            set.Compile();
            Assert.Equal(set.Count, 2);
            Assert.Equal(set.Contains(s2), true);
            Assert.Equal(set.Contains(s), true);
            Assert.Equal(set.IsCompiled, true);

            XmlReaderSettings settings = new XmlReaderSettings();

            settings.ValidationType = ValidationType.Schema;
            settings.Schemas        = set;

            using (XmlReader reader = XmlReader.Create(TestData._Root + "EmployeesDefaultPrefix.xml", settings))
            {
                while (reader.Read())
                {
                    ;
                }
            }
            XmlTextReader r3 = new XmlTextReader(TestData._Root + @"BaseEmployee2.xsd");
            XmlSchema     s3 = XmlSchema.Read(r3, null);

            resolver.Add(new Uri(s3.SourceUri), s3);

            XmlSchemaSet set2 = new XmlSchemaSet();

            set2.XmlResolver = resolver;
            set2.Add(s3);
            Assert.Equal(set2.Count, 1);
            Assert.Equal(set2.Contains(s2), false);
            Assert.Equal(set2.Contains(s), false);
            Assert.Equal(set2.Contains(s3), true);
            Assert.Equal(set2.IsCompiled, false);

            foreach (XmlSchemaRedefine redefine in s.Includes)
            {
                redefine.Schema = null;
            }

            set2.Add(s);
            Assert.Equal(set2.Count, 2);
            Assert.Equal(set2.Contains(s2), false);
            Assert.Equal(set2.Contains(s), true);
            Assert.Equal(set2.Contains(s3), true);
            Assert.Equal(set2.IsCompiled, false);

            set2.Compile();
            Assert.Equal(set2.Count, 2);
            Assert.Equal(set2.Contains(s2), false);
            Assert.Equal(set2.Contains(s), true);
            Assert.Equal(set2.Contains(s3), true);
            Assert.Equal(set2.IsCompiled, true);

            settings.Schemas = set2;

            using (XmlReader reader = XmlReader.Create(TestData._Root + "EmployeesDefaultPrefix.xml", settings))
            {
                while (reader.Read())
                {
                    ;
                }
            }
            Assert.Equal(errorCount, 0);
        }
Ejemplo n.º 19
0
        /// <summary>
        /// Gets the XML schemas for generating data contracts.
        /// </summary>
        /// <param name="options">The metadata resolving options.</param>
        /// <returns>A collection of the XML schemas.</returns>
        public static XmlSchemas GetXmlSchemas(MetadataResolverOptions options)
        {
            if (options.DataContractFiles == null)
            {
                throw new ArgumentNullException("options");
            }

            // Resolve the schemas.
            XmlSchemas schemas = new XmlSchemas();

            for (int fi = 0; fi < options.DataContractFiles.Length; fi++)
            {
                // Skip the non xsd/wsdl files.
                string lowext = Path.GetExtension(options.DataContractFiles[fi]).ToLower();
                if (lowext == ".xsd")                 // This is an XSD file.
                {
                    XmlTextReader xmltextreader = null;

                    try
                    {
                        xmltextreader = new XmlTextReader(options.DataContractFiles[fi]);
                        XmlSchema    schema    = XmlSchema.Read(xmltextreader, null);
                        XmlSchemaSet schemaset = new XmlSchemaSet();
                        schemaset.Add(schema);
                        RemoveDuplicates(ref schemaset);
                        schemaset.Compile();
                        schemas.Add(schema);
                    }
                    finally
                    {
                        if (xmltextreader != null)
                        {
                            xmltextreader.Close();
                        }
                    }
                }
                else if (lowext == ".wsdl")                 // This is a WSDL file.
                {
                    XmlSchemaSet            schemaset         = new XmlSchemaSet();
                    XmlSchemaSet            embeddedschemaset = new XmlSchemaSet();
                    DiscoveryClientProtocol dcp = new DiscoveryClientProtocol();
                    dcp.AllowAutoRedirect = true;
                    dcp.Credentials       = CredentialCache.DefaultCredentials;
                    dcp.DiscoverAny(options.DataContractFiles[fi]);
                    dcp.ResolveAll();
                    foreach (object document in dcp.Documents.Values)
                    {
                        if (document is XmlSchema)
                        {
                            schemaset.Add((XmlSchema)document);
                            schemas.Add((XmlSchema)document);
                        }
                        if (document is WebServiceDescription)
                        {
                            schemas.Add(((WebServiceDescription)document).Types.Schemas);
                            foreach (XmlSchema schema in ((WebServiceDescription)document).Types.Schemas)
                            {
                                embeddedschemaset.Add(schema);
                                schemas.Add(schema);
                            }
                        }
                    }
                    RemoveDuplicates(ref schemaset);
                    schemaset.Add(embeddedschemaset);
                    schemaset.Compile();
                }
            }
            return(schemas);
        }
Ejemplo n.º 20
0
    public static void Main()
    {
        XmlSchema schema = new XmlSchema();

        // <xs:element name="cat" type="xs:string"/>
        XmlSchemaElement elementCat = new XmlSchemaElement();

        schema.Items.Add(elementCat);
        elementCat.Name           = "cat";
        elementCat.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");

        // <xs:element name="dog" type="xs:string"/>
        XmlSchemaElement elementDog = new XmlSchemaElement();

        schema.Items.Add(elementDog);
        elementDog.Name           = "dog";
        elementDog.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");

        // <xs:element name="redDog" substitutionGroup="dog" />
        XmlSchemaElement elementRedDog = new XmlSchemaElement();

        schema.Items.Add(elementRedDog);
        elementRedDog.Name = "redDog";
        elementRedDog.SubstitutionGroup = new XmlQualifiedName("dog");

        // <xs:element name="brownDog" substitutionGroup ="dog" />
        XmlSchemaElement elementBrownDog = new XmlSchemaElement();

        schema.Items.Add(elementBrownDog);
        elementBrownDog.Name = "brownDog";
        elementBrownDog.SubstitutionGroup = new XmlQualifiedName("dog");

        // <xs:element name="pets">
        XmlSchemaElement elementPets = new XmlSchemaElement();

        schema.Items.Add(elementPets);
        elementPets.Name = "pets";

        // <xs:complexType>
        XmlSchemaComplexType complexType = new XmlSchemaComplexType();

        elementPets.SchemaType = complexType;

        // <xs:choice minOccurs="0" maxOccurs="unbounded">
        XmlSchemaChoice choice = new XmlSchemaChoice();

        complexType.Particle   = choice;
        choice.MinOccurs       = 0;
        choice.MaxOccursString = "unbounded";

        // <xs:element ref="cat"/>
        XmlSchemaElement catRef = new XmlSchemaElement();

        choice.Items.Add(catRef);
        catRef.RefName = new XmlQualifiedName("cat");

        // <xs:element ref="dog"/>
        XmlSchemaElement dogRef = new XmlSchemaElement();

        choice.Items.Add(dogRef);
        dogRef.RefName = new XmlQualifiedName("dog");

        XmlSchemaSet schemaSet = new XmlSchemaSet();

        schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallbackOne);
        schemaSet.Add(schema);
        schemaSet.Compile();

        XmlSchema compiledSchema = null;

        foreach (XmlSchema schema1 in schemaSet.Schemas())
        {
            compiledSchema = schema1;
        }

        XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable());

        nsmgr.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema");
        compiledSchema.Write(Console.Out, nsmgr);
    }
Ejemplo n.º 21
0
        void RetrieveSerializableSchema()
        {
            if (needSchema)
            {
                needSchema = false;
                if (getSchemaMethod != null)
                {
                    // get the type info
                    if (schemas == null)
                    {
                        schemas = new XmlSchemaSet();
                    }
                    object typeInfo = getSchemaMethod.Invoke(null, new object[] { schemas });
                    xsiType = XmlQualifiedName.Empty;

                    if (typeInfo != null)
                    {
                        if (typeof(XmlSchemaType).IsAssignableFrom(getSchemaMethod.ReturnType))
                        {
                            xsdType = (XmlSchemaType)typeInfo;
                            // check if type is named
                            xsiType = xsdType.QualifiedName;
                        }
                        else if (typeof(XmlQualifiedName).IsAssignableFrom(getSchemaMethod.ReturnType))
                        {
                            xsiType = (XmlQualifiedName)typeInfo;
                            if (xsiType.IsEmpty)
                            {
                                throw new InvalidOperationException(Res.GetString(Res.XmlGetSchemaEmptyTypeName, type.FullName, getSchemaMethod.Name));
                            }
                        }
                        else
                        {
                            throw new InvalidOperationException(Res.GetString(Res.XmlGetSchemaMethodReturnType, type.Name, getSchemaMethod.Name, typeof(XmlSchemaProviderAttribute).Name, typeof(XmlQualifiedName).FullName));
                        }
                    }
                    else
                    {
                        any = true;
                    }

                    // make sure that user-specified schemas are valid
                    schemas.ValidationEventHandler += new ValidationEventHandler(ValidationCallbackWithErrorCode);
                    schemas.Compile();
                    // at this point we verified that the information returned by the IXmlSerializable is valid
                    // Now check to see if the type was referenced before:
                    //
                    if (!xsiType.IsEmpty)
                    {
                        // try to find the type in the schemas collection
                        if (xsiType.Namespace != XmlSchema.Namespace)
                        {
                            ArrayList srcSchemas = (ArrayList)schemas.Schemas(xsiType.Namespace);

                            if (srcSchemas.Count == 0)
                            {
                                throw new InvalidOperationException(Res.GetString(Res.XmlMissingSchema, xsiType.Namespace));
                            }
                            if (srcSchemas.Count > 1)
                            {
                                throw new InvalidOperationException(Res.GetString(Res.XmlGetSchemaInclude, xsiType.Namespace, getSchemaMethod.DeclaringType.FullName, getSchemaMethod.Name));
                            }
                            XmlSchema s = (XmlSchema)srcSchemas[0];
                            if (s == null)
                            {
                                throw new InvalidOperationException(Res.GetString(Res.XmlMissingSchema, xsiType.Namespace));
                            }
                            xsdType = (XmlSchemaType)s.SchemaTypes[xsiType];
                            if (xsdType == null)
                            {
                                throw new InvalidOperationException(Res.GetString(Res.XmlGetSchemaTypeMissing, getSchemaMethod.DeclaringType.FullName, getSchemaMethod.Name, xsiType.Name, xsiType.Namespace));
                            }
                            xsdType = xsdType.Redefined != null ? xsdType.Redefined : xsdType;
                        }
                    }
                }
                else
                {
                    IXmlSerializable serializable = (IXmlSerializable)Activator.CreateInstance(type);
                    schema = serializable.GetSchema();

                    if (schema != null)
                    {
                        if (schema.Id == null || schema.Id.Length == 0)
                        {
                            throw new InvalidOperationException(Res.GetString(Res.XmlSerializableNameMissing1, type.FullName));
                        }
                    }
                }
            }
        }
Ejemplo n.º 22
0
        /// <summary>
        /// Gets the XML schemas for generating data contracts.
        /// </summary>
        /// <param name="options">The metadata resolving options.</param>
        /// <returns>A collection of the XML schemas.</returns>
        public static XmlSchemas GetXmlSchemaSetFromDataContractFiles(MetadataResolverOptions options)
        {
            if (options.DataContractFiles == null)
            {
                throw new ArgumentNullException("No data contract files provided");
            }

            // Resolve the schemas.
            XmlSchemaSet schemaSet = CreateXmlSchemaSet();

            for (int fi = 0; fi < options.DataContractFiles.Length; fi++)
            {
                // Skip the non xsd/wsdl files.
                string lowext = Path.GetExtension(options.DataContractFiles[fi]).ToLower();
                if (lowext == ".xsd") // This is an XSD file.
                {
                    XmlTextReader xmltextreader = null;

                    try
                    {
                        xmltextreader = new XmlTextReader(options.DataContractFiles[fi]);
                        XmlSchema schema = XmlSchema.Read(xmltextreader, null);
                        if (options.GenerateSeparateFilesEachXsd)
                        {
                            if (string.IsNullOrWhiteSpace(schema.SourceUri))
                            {
                                schema.SourceUri = options.DataContractFiles[fi];
                            }
                            ResolveIncludedSchemas(schemaSet, schema);
                        }
                        schemaSet.Add(schema);
                    }
                    finally
                    {
                        if (xmltextreader != null)
                        {
                            xmltextreader.Close();
                        }
                    }
                }
                else if (lowext == ".wsdl") // This is a WSDL file.
                {
                    AntDiscoveryClientProtocol dcp = new AntDiscoveryClientProtocol();
                    dcp.AllowAutoRedirect = true;
                    dcp.Credentials       = CredentialCache.DefaultCredentials;
                    dcp.DiscoverAny(options.DataContractFiles[fi]);
                    dcp.ResolveAll();
                    foreach (string url in dcp.Documents.Keys)
                    {
                        object document = dcp.Documents[url];
                        if (document is XmlSchema)
                        {
                            XmlSchema xmlSchema = (XmlSchema)document;
                            if (options.GenerateSeparateFilesEachXsd)
                            {
                                if (string.IsNullOrWhiteSpace(xmlSchema.SourceUri))
                                {
                                    xmlSchema.SourceUri = url;
                                }
                                ResolveIncludedSchemas(schemaSet, xmlSchema);
                            }
                            schemaSet.Add(xmlSchema);
                        }
                        if (document is WebServiceDescription)
                        {
                            foreach (XmlSchema schema in ((WebServiceDescription)document).Types.Schemas)
                            {
                                if (!IsEmptySchema(schema))
                                {
                                    if (options.GenerateSeparateFilesEachXsd)
                                    {
                                        if (string.IsNullOrWhiteSpace(schema.SourceUri))
                                        {
                                            schema.SourceUri = url;
                                        }
                                        ResolveIncludedSchemas(schemaSet, schema);
                                    }
                                    schemaSet.Add(schema);
                                }
                            }
                        }
                    }
                }
            }

            RemoveDuplicates(ref schemaSet);
            schemaSet.Compile();

            XmlSchemas schemas = new XmlSchemas();

            foreach (XmlSchema schema in schemaSet.Schemas())
            {
                schemas.Add(schema);
            }

            return(schemas);
        }
Ejemplo n.º 23
0
    public static void Main()
    {
        XmlSchema schema = new XmlSchema();

        // <xs:element name="selected"/>
        XmlSchemaElement xeSelected = new XmlSchemaElement();

        xeSelected.Name = "selected";
        schema.Items.Add(xeSelected);

        // <xs:element name="unselected"/>
        XmlSchemaElement xeUnselected = new XmlSchemaElement();

        xeUnselected.Name = "unselected";
        schema.Items.Add(xeUnselected);

        // <xs:element name="dimpled"/>
        XmlSchemaElement xeDimpled = new XmlSchemaElement();

        xeDimpled.Name = "dimpled";
        schema.Items.Add(xeDimpled);

        // <xs:element name="perforated"/>
        XmlSchemaElement xePerforated = new XmlSchemaElement();

        xePerforated.Name = "perforated";
        schema.Items.Add(xePerforated);

        // <xs:complexType name="chadState">
        XmlSchemaComplexType chadState = new XmlSchemaComplexType();

        schema.Items.Add(chadState);
        chadState.Name = "chadState";

        // <xs:choice minOccurs="1" maxOccurs="1">
        XmlSchemaChoice choice = new XmlSchemaChoice();

        chadState.Particle = choice;
        choice.MinOccurs   = 1;
        choice.MaxOccurs   = 1;

        // <xs:element ref="selected"/>
        XmlSchemaElement elementSelected = new XmlSchemaElement();

        choice.Items.Add(elementSelected);
        elementSelected.RefName = new XmlQualifiedName("selected");

        // <xs:element ref="unselected"/>
        XmlSchemaElement elementUnselected = new XmlSchemaElement();

        choice.Items.Add(elementUnselected);
        elementUnselected.RefName = new XmlQualifiedName("unselected");

        // <xs:element ref="dimpled"/>
        XmlSchemaElement elementDimpled = new XmlSchemaElement();

        choice.Items.Add(elementDimpled);
        elementDimpled.RefName = new XmlQualifiedName("dimpled");

        // <xs:element ref="perforated"/>
        XmlSchemaElement elementPerforated = new XmlSchemaElement();

        choice.Items.Add(elementPerforated);
        elementPerforated.RefName = new XmlQualifiedName("perforated");

        XmlSchemaSet schemaSet = new XmlSchemaSet();

        schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallbackOne);
        schemaSet.Add(schema);
        schemaSet.Compile();

        XmlSchema compiledSchema = null;

        foreach (XmlSchema schema1 in schemaSet.Schemas())
        {
            compiledSchema = schema1;
        }

        XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable());

        nsmgr.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema");
        compiledSchema.Write(Console.Out, nsmgr);
    }
Ejemplo n.º 24
0
        /// <summary>
        /// Gets the XML schemas from a given WSDL document
        /// </summary>
        /// <param name="options">The metadata resolving options.</param>
        /// <returns>A collection of the XML schemas.</returns>
        public static XmlSchemas GetXmlSchemaSetFromWsdlFile(MetadataResolverOptions options)
        {
            if (options == null)
            {
                throw new ArgumentException("MetadataResolverOptions could not be null.");
            }

            if (string.IsNullOrEmpty(options.MetadataLocation))
            {
                throw new ArgumentException("MetadataLocation option could not be null or an empty string.");
            }

            try
            {
                // First download the contracts if they are accessed over the web.
                DownloadContract(options);

                AntDiscoveryClientProtocol dcp = new AntDiscoveryClientProtocol();
                dcp.Credentials       = GetCredentials(options);
                dcp.AllowAutoRedirect = true;
                dcp.DiscoverAny(options.MetadataLocation);
                dcp.ResolveAll();

                XmlSchemaSet schemaSet = CreateXmlSchemaSet();
                foreach (string url in dcp.Documents.Keys)
                {
                    object document = dcp.Documents[url];
                    if (document is System.Web.Services.Description.ServiceDescription)
                    {
                        foreach (XmlSchema schema in ((WebServiceDescription)document).Types.Schemas)
                        {
                            if (!IsEmptySchema(schema))
                            {
                                if (options.GenerateSeparateFilesEachXsd)
                                {
                                    if (string.IsNullOrWhiteSpace(schema.SourceUri))
                                    {
                                        schema.SourceUri = url;
                                    }
                                    ResolveIncludedSchemas(schemaSet, schema);
                                }
                                schemaSet.Add(schema);
                            }
                        }
                        continue;
                    }
                    if (document is XmlSchema)
                    {
                        XmlSchema xmlSchema = (XmlSchema)document;
                        if (options.GenerateSeparateFilesEachXsd)
                        {
                            if (string.IsNullOrWhiteSpace(xmlSchema.SourceUri))
                            {
                                xmlSchema.SourceUri = url;
                            }
                            ResolveIncludedSchemas(schemaSet, xmlSchema);
                        }
                        schemaSet.Add(xmlSchema);
                    }
                }

                RemoveDuplicates(ref schemaSet);
                schemaSet.Compile();

                XmlSchemas schemas = new XmlSchemas();
                foreach (XmlSchema schema in schemaSet.Schemas())
                {
                    schemas.Add(schema);
                }

                return(schemas);
            }
            catch (Exception ex)
            {
                // TODO: Log exception.
                throw new MetadataResolveException("Could not resolve metadata. " + ex, ex);
            }
        }
Ejemplo n.º 25
0
        //[Variation(Desc = "TFS_470021 Unexpected local particle qualified name when chameleon schema is added to set")]
        public void TFS_470021()
        {
            string cham = @"<?xml version='1.0' encoding='utf-8' ?>
<xs:schema id='a0'
                  elementFormDefault='qualified'
                  xmlns:xs='http://www.w3.org/2001/XMLSchema'>
  <xs:complexType name='ctseq1_a'>
    <xs:sequence>
      <xs:element name='foo'/>
    </xs:sequence>
    <xs:attribute name='abt0' type='xs:string'/>
  </xs:complexType>
  <xs:element name='gect1_a' type ='ctseq1_a'/>
</xs:schema>";
            string main = @"<?xml version='1.0' encoding='utf-8' ?>
<xs:schema id='m0'
                  targetNamespace='http://tempuri.org/chameleon1'
                  elementFormDefault='qualified'
                  xmlns='http://tempuri.org/chameleon1'
                  xmlns:mstns='http://tempuri.org/chameleon1'
                  xmlns:xs='http://www.w3.org/2001/XMLSchema'>
  <xs:include schemaLocation='cham.xsd' />

  <xs:element name='root'>
    <xs:complexType>
      <xs:sequence maxOccurs='unbounded'>
        <xs:any namespace='##any' processContents='lax'/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>";

            using (XmlWriter w = XmlWriter.Create("cham.xsd"))
            {
                using (XmlReader r = XmlReader.Create(new StringReader(cham)))
                    w.WriteNode(r, true);
            }
            XmlSchemaSet ss = new XmlSchemaSet();

            ss.ValidationEventHandler += new ValidationEventHandler(ValidationCallback);

            ss.Add(null, XmlReader.Create(new StringReader(cham)));
            ss.Add(null, XmlReader.Create(new StringReader(main)));
            ss.Compile();

            Assert.Equal(ss.Count, 2);
            foreach (XmlSchemaElement e in ss.GlobalElements.Values)
            {
                _output.WriteLine(e.QualifiedName.ToString());
                XmlSchemaComplexType type = e.ElementSchemaType as XmlSchemaComplexType;
                XmlSchemaSequence    seq  = type.ContentTypeParticle as XmlSchemaSequence;
                foreach (XmlSchemaObject child in seq.Items)
                {
                    if (child is XmlSchemaElement)
                    {
                        _output.WriteLine("\t" + (child as XmlSchemaElement).QualifiedName);
                    }
                }
            }
            Assert.Equal(warningCount, 0);
            Assert.Equal(errorCount, 0);
            return;
        }
Ejemplo n.º 26
0
        /// <summary>
        /// CreateSourceFiles - Parse Wsdl Schema and generate DataContract, DataContractSerializer types,
        /// HostedServices and Client Proxies.
        /// </summary>
        /// <remarks>Currently only generates C# source files.</remarks>
        /// <param name="contractFilename">The name of a contract source code (.cs) file.</param>
        /// <param name="hostedServiceFilename">The name of a hosted service source code (.cs) file.</param>
        /// <param name="clientProxyFilename">The name of a client proxy source code (.cs) file.</param>
        /// <param name="targetPlatform">Specifies the target runtime platform.</param>
        public void CreateSourceFiles(string contractFilename, string hostedServiceFilename, string clientProxyFilename, TargetPlatform targetPlatform)
        {
            m_platform = targetPlatform;

            Logger.WriteLine("", LogLevel.Normal);
            Logger.WriteLine("Generating contract source: " + contractFilename + "...", LogLevel.Normal);

            if (contractFilename == null)
            {
                throw new ArgumentNullException("codeFilename", "You must pass a valid code filename.");
            }

            if (m_svcDesc.Types == null)
            {
                throw new Exception("No wsdl types found.");
            }

            string path = Path.GetDirectoryName(contractFilename).Trim();

            if (!string.IsNullOrEmpty(path) && !Directory.Exists(path))
            {
                Directory.CreateDirectory(path);
            }

            // Create code file stream
            FileStream   dcStream       = new FileStream(contractFilename, FileMode.Create, FileAccess.Write, FileShare.None);
            StreamWriter dcStreamWriter = new StreamWriter(dcStream);

            // Write the auto generated header
            dcStreamWriter.Write(AutoGenTextHeader.Message);

            try
            {
                // Set up data contract code generator
                CSharpCodeProvider   cSharpCP       = new CSharpCodeProvider();
                ICodeGenerator       codeGen        = cSharpCP.CreateGenerator(dcStreamWriter);
                CodeGeneratorOptions codeGenOptions = new CodeGeneratorOptions();
                codeGenOptions.BracingStyle = "C";

                // Cobble up a valid .net namespace. Turn any progression that's not a-z or A-Z to a single '.'
                string targetNamespaceName = CodeGenUtils.GenerateDotNetNamespace(m_svcDesc.TargetNamespace);

                // For some reason we have to force schemas to compile. Though it was suppose to automatically. Huh!
                foreach (XmlSchema schema in m_svcDesc.Types.Schemas)
                {
                    XmlSchemaSet schemaSet = new XmlSchemaSet();
                    schemaSet.Add(schema);
                    schemaSet.Compile();
                }

                // Create new code namespace
                CodeNamespace targetNamespace = new CodeNamespace(targetNamespaceName);

                // Add data contract using directives
                CodeSnippetCompileUnit compileUnit = new CodeSnippetCompileUnit("using System;");
                codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
                compileUnit.Value = "using System.Xml;";
                codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
                if (m_platform == TargetPlatform.MicroFramework)
                {
                    compileUnit.Value = "using System.Ext;";
                    codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
                    compileUnit.Value = "using System.Ext.Xml;";
                    codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
                }
                compileUnit.Value = "using Ws.ServiceModel;";
                codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
                compileUnit.Value = "using Ws.Services.Mtom;";
                codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
                compileUnit.Value = "using Ws.Services.Serialization;";
                codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
                compileUnit.Value = "using XmlElement = Ws.Services.Xml.WsXmlNode;";
                codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
                compileUnit.Value = "using XmlAttribute = Ws.Services.Xml.WsXmlAttribute;";
                codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
                compileUnit.Value = "using XmlConvert = Ws.Services.Serialization.WsXmlConvert;";
                codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
                compileUnit.Value = "";
                codeGen.GenerateCodeFromCompileUnit(compileUnit, dcStreamWriter, codeGenOptions);
                compileUnit.Namespaces.Add(targetNamespace);
                m_dcCodeGen.CodeNamespaces = compileUnit.Namespaces;

                Logger.WriteLine("", LogLevel.Normal);

                // Create HostedServices and ClientProxies collections
                HostedServices hostedServices = new HostedServices(targetNamespaceName);
                ClientProxies  clientProxies  = new ClientProxies(targetNamespaceName);

                // For each PortType process
                foreach (PortType portType in m_svcDesc.PortTypes)
                {
                    // For each operation in the port type:
                    // Get input and output message parts.
                    // If the message part is a simple type:
                    //   Build HostedService operation.
                    // Else if the message part is an element:
                    //   Find elements in Schema
                    //   If element type is native xml type:
                    //     Build HostedService operation.
                    //   Else if element references a simple or complex type:
                    //     If simpleType is base xml type with restrictions:
                    //       Build HostedService operation.
                    //     Else
                    //       Build DataContract and DataContractSerializer.
                    //       Build HostedService Operation.
                    //

                    // Create instance of a HostedService to hold the port type details
                    HostedService hostedService = new HostedService(portType.Name, m_svcDesc.TargetNamespace, m_platform);

                    // Create instance of ClientProxyGenerator
                    ClientProxy clientProxy = new ClientProxy(portType.Name, m_platform);

                    // Create service contract interface
                    CodeTypeDeclaration      serviceCodeType = new CodeTypeDeclaration("I" + portType.Name);
                    CodeAttributeArgument    codeAttr        = new CodeAttributeArgument("Namespace", new CodePrimitiveExpression(m_svcDesc.TargetNamespace));
                    CodeAttributeDeclaration codeAttrDecl    = new CodeAttributeDeclaration("ServiceContract", codeAttr);
                    serviceCodeType.CustomAttributes.Add(codeAttrDecl);

                    // Check for Policy assertions. If found add policy assertion attributes. Policy assertion attributes
                    // are required to regenerate policy assertions when converting a service to Wsdl.
                    List <PolicyAssertion> policyAssertions = GetPolicyAssertions();
                    bool OptimizedMimeEncoded = false;
                    foreach (PolicyAssertion assert in policyAssertions)
                    {
                        serviceCodeType.CustomAttributes.Add(CreatePolicyAssertions(assert.Name, assert.Namespace.ToString(), assert.PolicyID));

                        // if Optimized Mime assertion id found set a processing flag
                        if (assert.Name == "OptimizedMimeSerialization")
                        {
                            OptimizedMimeEncoded = true;
                        }
                    }

                    // Add type declaration
                    serviceCodeType.TypeAttributes = TypeAttributes.Public;
                    serviceCodeType.IsInterface    = true;

                    // Create service contract callback client interface
                    CodeTypeDeclaration serviceCallbackCodeType = new CodeTypeDeclaration("I" + portType.Name + "Callback");

                    // Add type declaration
                    serviceCallbackCodeType.TypeAttributes = TypeAttributes.Public;
                    serviceCallbackCodeType.IsInterface    = true;

                    // If the binding contains a ref to Mtom encoding type set the Mtom flag
                    if (OptimizedMimeEncoded)
                    {
                        m_dcCodeGen.EncodingType   = MessageEncodingType.Mtom;
                        hostedService.EncodingType = MessageEncodingType.Mtom;
                        clientProxy.EncodingType   = MessageEncodingType.Mtom;
                    }

                    // Step through port operations, get method names and parse elements.
                    for (int pt_index = 0; pt_index < portType.Operations.Count; ++pt_index)
                    {
                        Operation operation     = portType.Operations[pt_index];
                        string    operationName = operation.Name;

                        string inputMessageName  = null;
                        string outputMessageName = null;
                        MessagePartCollection inputMessageParts  = null;
                        MessagePartCollection outputMessageParts = null;
                        string inAction  = null;
                        string outAction = null;
                        GetAction(portType, operation, m_svcDesc.TargetNamespace, ref inAction, ref outAction);

                        // Oneway request port type
                        if (operation.Messages.Flow == OperationFlow.OneWay)
                        {
                            OperationInput input = operation.Messages.Input;
                            inputMessageName = input.Message.Name;

                            // Add operation for HostedService code generation
                            hostedService.AddOperation(operation, inAction, outAction);

                            // Add method for ClientProxy code generation
                            clientProxy.AddOperation(operation, inAction, outAction);
                        }
                        // Twoway request/response pattern
                        else if (operation.Messages.Flow == OperationFlow.RequestResponse)
                        {
                            OperationInput input = operation.Messages.Input;
                            inputMessageName = input.Message.Name;
                            OperationOutput output = operation.Messages.Output;
                            outputMessageName = output.Message.Name;

                            // Add operation for HostedService code generation
                            hostedService.AddOperation(operation, inAction, outAction);

                            // Add method for ClientProxy code generation
                            clientProxy.AddOperation(operation, inAction, outAction);
                        }
                        // Event pattern
                        else if (operation.Messages.Flow == OperationFlow.Notification)
                        {
                            OperationOutput output = operation.Messages.Output;
                            outputMessageName = output.Message.Name;

                            // Add operation for HostedService code generation
                            hostedService.AddOperation(operation, inAction, outAction);

                            // Add method for ClientProxy code generation
                            clientProxy.AddOperation(operation, inAction, outAction);
                        }

                        // Find input and output message parts collection in messages collection
                        // and store for later.
                        foreach (Message message in m_svcDesc.Messages)
                        {
                            if (inputMessageName != null)
                            {
                                if (message.Name == inputMessageName)
                                {
                                    inputMessageParts = message.Parts;

                                    // Add operation for HostedService code generation
                                    hostedService.Messages.Add(message);

                                    // Add Message to ClientProxy generator for later
                                    clientProxy.Messages.Add(message);
                                }
                            }

                            if (outputMessageName != null)
                            {
                                if (message.Name == outputMessageName)
                                {
                                    outputMessageParts = message.Parts;

                                    // Add operation for HostedService code generation
                                    hostedService.Messages.Add(message);

                                    // Add Message to ClientProxy generator for later
                                    clientProxy.Messages.Add(message);
                                }
                            }
                        }

                        try
                        {
                            // Try to generate Data Contracts and DataContractSerializers
                            GenerateTypeContracts(operation, inputMessageParts, outputMessageParts);

                            // If operation flow is notification (event) add OperationContract to ServiceContractCallback
                            // else add OperationContract to ServiceContract
                            if (operation.Messages.Flow == OperationFlow.Notification)
                            {
                                AddServiceOperationToInterface(operation, outAction, serviceCallbackCodeType);
                            }
                            else
                            {
                                AddServiceOperationToInterface(operation, inAction, serviceCodeType);
                            }
                        }
                        catch (Exception e)
                        {
                            dcStreamWriter.Close();
                            File.Delete(contractFilename);
                            Logger.WriteLine("Failed to generate service code. " + e.Message, LogLevel.Normal);
                            return;
                        }
                    }

                    // Add serviceCodeType Service Contract interface to namespace
                    // A serviceCodeType is added even if the wsdl only contains notifications. In that case
                    // the contract will be empty but the ServiceContract attribute and CallbackContract argument
                    // will be used to point to the notification or callback contract interace
                    targetNamespace.Types.Add(serviceCodeType);

                    // If service contract callback type contains members add callback contract to namespace
                    // and add CallbackContract reference attribute to serviceCodeType contract.
                    if (serviceCallbackCodeType.Members.Count > 0)
                    {
                        // Add the callback argument to the service description attribute
                        CodeAttributeArgument callbackArg = new CodeAttributeArgument("CallbackContract",
                                                                                      new CodeTypeOfExpression(serviceCallbackCodeType.Name)
                                                                                      );
                        serviceCodeType.CustomAttributes[0].Arguments.Add(callbackArg);

                        // Add the callback interface to namespace
                        targetNamespace.Types.Add(serviceCallbackCodeType);
                    }

                    // If the hosted service has opeations add to Hosted Services collection for Code Gen
                    if (hostedService.ServiceOperations.Count > 0)
                    {
                        hostedServices.Add(hostedService);
                    }

                    // If the client Proxy service has opeations add to client proxy collection for Code Gen
                    if (clientProxy.ServiceOperations.Count > 0)
                    {
                        clientProxies.Add(clientProxy);
                    }
                }

                // MOD: 12-02-08 Added code to handle multiple type namespaces
                // Generate contract source file
                foreach (CodeNamespace codeNamespace in compileUnit.Namespaces)
                {
                    codeGen.GenerateCodeFromNamespace(codeNamespace, dcStreamWriter, codeGenOptions);
                }
                dcStreamWriter.Flush();
                dcStreamWriter.Close();

                // Generate Hosted Service code
                Logger.WriteLine("Generating Hosted Service source: " + hostedServiceFilename + "...", LogLevel.Normal);
                HostedServiceGenerator hsGen = new HostedServiceGenerator();
                hsGen.GenerateCode(hostedServiceFilename, hostedServices);

                // Generate Client proxy code
                Logger.WriteLine("Generating Client Proxy source: " + clientProxyFilename + "...", LogLevel.Normal);
                ClientProxyGenerator cpGen = new ClientProxyGenerator();
                cpGen.GenerateCode(clientProxyFilename, clientProxies);
            }
            catch (Exception e)
            {
                dcStreamWriter.Close();
                File.Delete(contractFilename);
                Logger.WriteLine("Failed to generate service code. " + e.Message, LogLevel.Normal);
                throw new Exception("Failed to generate service code. ", e);
            }
        }
Ejemplo n.º 27
0
        private void DeserializeSampleXml(string pattern, Assembly assembly)
        {
            var files = Glob.Glob.ExpandNames(pattern);

            var set = new XmlSchemaSet();

            var schemas = files.Select(f => XmlSchema.Read(XmlReader.Create(f), (s, e) =>
            {
                Assert.True(false, e.Message);
            }));

            foreach (var s in schemas)
            {
                set.Add(s);
            }

            set.Compile();

            foreach (var rootElement in set.GlobalElements.Values.Cast <XmlSchemaElement>().Where(e => !e.IsAbstract))
            {
                var type       = FindType(assembly, rootElement.QualifiedName);
                var serializer = new XmlSerializer(type);
                var generator  = new XmlSampleGenerator(set, rootElement.QualifiedName);
                var sb         = new StringBuilder();
                using (var xw = XmlWriter.Create(sb, new XmlWriterSettings {
                    Indent = true
                }))
                {
                    // generate sample xml
                    generator.WriteXml(xw);
                    var xml = sb.ToString();

                    File.WriteAllText("xml.xml", xml);

                    // deserialize from sample
                    var sr = new StringReader(xml);
                    var o  = serializer.Deserialize(sr);

                    // serialize back to xml
                    var xml2 = Serialize(serializer, o);

                    File.WriteAllText("xml2.xml", xml2);

                    // validate serialized xml
                    XmlReaderSettings settings = new XmlReaderSettings
                    {
                        ValidationType = ValidationType.Schema,
                        Schemas        = set
                    };

                    settings.ValidationEventHandler += (s, e) =>
                    {
                        // generator doesn't generate valid values where pattern restrictions exist, e.g. email
                        if (!e.Message.Contains("The Pattern constraint failed"))
                        {
                            Assert.True(false, e.Message);
                        }
                    };

                    XmlReader reader = XmlReader.Create(new StringReader(xml2), settings);
                    while (reader.Read())
                    {
                        ;
                    }

                    // deserialize again
                    sr = new StringReader(xml2);
                    var o2 = serializer.Deserialize(sr);

                    AssertEx.Equal(o, o2);
                }
            }
        }
Ejemplo n.º 28
0
    public static void Main()
    {
        XmlSchema schema = new XmlSchema();

        // <xs:simpleType name="SizeType">
        XmlSchemaSimpleType SizeType = new XmlSchemaSimpleType();

        SizeType.Name = "SizeType";

        // <xs:restriction base="xs:string">
        XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction();

        restriction.BaseTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema");

        // <xs:enumeration value="Small"/>
        XmlSchemaEnumerationFacet enumerationSmall = new XmlSchemaEnumerationFacet();

        enumerationSmall.Value = "Small";
        restriction.Facets.Add(enumerationSmall);

        // <xs:enumeration value="Medium"/>
        XmlSchemaEnumerationFacet enumerationMedium = new XmlSchemaEnumerationFacet();

        enumerationMedium.Value = "Medium";
        restriction.Facets.Add(enumerationMedium);

        // <xs:enumeration value="Large"/>
        XmlSchemaEnumerationFacet enumerationLarge = new XmlSchemaEnumerationFacet();

        enumerationLarge.Value = "Large";
        restriction.Facets.Add(enumerationLarge);

        SizeType.Content = restriction;

        schema.Items.Add(SizeType);

        // <xs:element name="Item">
        XmlSchemaElement elementItem = new XmlSchemaElement();

        elementItem.Name = "Item";

        // <xs:complexType>
        XmlSchemaComplexType complexType = new XmlSchemaComplexType();

        // <xs:attribute name="Size" type="SizeType"/>
        XmlSchemaAttribute attributeSize = new XmlSchemaAttribute();

        attributeSize.Name           = "Size";
        attributeSize.SchemaTypeName = new XmlQualifiedName("SizeType", "");
        complexType.Attributes.Add(attributeSize);

        elementItem.SchemaType = complexType;

        schema.Items.Add(elementItem);

        XmlSchemaSet schemaSet = new XmlSchemaSet();

        schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallbackOne);
        schemaSet.Add(schema);
        schemaSet.Compile();

        XmlSchema compiledSchema = null;

        foreach (XmlSchema schema1 in schemaSet.Schemas())
        {
            compiledSchema = schema1;
        }

        XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable());

        nsmgr.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema");
        compiledSchema.Write(Console.Out, nsmgr);
    }
Ejemplo n.º 29
0
        public static void Schema(string xsdFile, string outFile)
        {
            XmlSchemaSet schema = new XmlSchemaSet();

            schema.Add("http://www.tcxml.org/Schemas/TCXMLSchema", xsdFile);

            schema.Compile();
            XmlSchemaObjectTable table = schema.GlobalElements;

            System.Xml.XmlWriterSettings settings = new System.Xml.XmlWriterSettings();
            settings.Indent = true;

            using (System.Xml.XmlWriter writer = System.Xml.XmlWriter.Create(outFile, settings))
            {
                writer.WriteStartDocument(true);
                writer.WriteStartElement("BMO");
                //writer.WriteLine("USE Test");

                XmlSchemaElement[] array = new XmlSchemaElement[table.Values.Count];
                table.Values.CopyTo(array, 0);

                foreach (XmlSchemaElement el in array)
                {
                    if (el.ElementSchemaType.BaseXmlSchemaType.GetType().Name.ToString() == "XmlSchemaComplexType")
                    {
                        string elementName = el.Name;

                        XmlSchemaComplexType mType      = (XmlSchemaComplexType)el.ElementSchemaType;
                        XmlSchemaAttribute[] Attributes = mType.AttributeUses.Values.Cast <XmlSchemaAttribute>().Select(e => e).ToArray();

                        if (Attributes.Count() == 0)
                        {
                            continue;
                        }

                        writer.WriteStartElement(elementName);

                        // writer.WriteLine("CREATE TABLE [" + elementName + "] (");

                        XmlSchemaAttribute last = Attributes.Last();
                        foreach (XmlSchemaAttribute attr in Attributes)
                        {
                            string name = attr.Name;
                            // string type = attr.AttributeSchemaType.TypeCode.ToString();
                            string requirement = attr.Use.ToString();
                            requirement = ((requirement == "Required") ? "Y" : "N");


                            writer.WriteStartElement(name);
                            //writer.WriteStartAttribute("req");
                            //writer.WriteValue(requirement);
                            //writer.WriteEndAttribute();

                            //if (attr.Equals(last))
                            //    writer.WriteLine("\t[" + name + "] " + typeReplace + ((requirement == "Required") ? " NOT NULL" : ""));
                            //else
                            //    writer.WriteLine("\t[" + name + "] " + typeReplace + ((requirement == "Required") ? " NOT NULL" : "") + ",");

                            writer.WriteEndElement();
                        }

                        writer.WriteEndElement();
                    }
                }


                writer.WriteEndDocument();
            }
        }
Ejemplo n.º 30
0
        public void Start(string sDirIn, string sDirCppXmlOut, string sDirCppBinOut, string sDirJsBinOut, ValidationEventHandler oValidationEventHandler)
        {
            string sChartNamespace = "http://purl.oclc.org/ooxml/spreadsheetml/main";

            string[]     aFiles    = Directory.GetFiles(sDirIn);
            XmlSchemaSet schemaSet = new XmlSchemaSet();

            schemaSet.ValidationEventHandler += oValidationEventHandler;
            for (int i = 0; i < aFiles.Length; i++)
            {
                string sFile = aFiles[i];
                if (".xsd" == Path.GetExtension(sFile))
                {
                    schemaSet.Add(null, sFile);
                }
            }
            schemaSet.Compile();
            XmlSchema  chartSchema = null;
            XmlSchemas schemas     = new XmlSchemas();

            foreach (XmlSchema schema in schemaSet.Schemas())
            {
                if (schema.TargetNamespace == sChartNamespace)
                {
                    chartSchema = schema;
                    schemas.Add(schema);
                }
            }
            if (null != chartSchema)
            {
                CodeNamespace   ns       = new CodeNamespace();
                XmlCodeExporter exporter = new XmlCodeExporter(ns);

                CodeGenerationOptions generationOptions = CodeGenerationOptions.GenerateProperties;


                XmlSchemaImporter importer = new XmlSchemaImporter(schemas, generationOptions, new ImportContext(new CodeIdentifiers(), false));

                foreach (XmlSchemaElement element in chartSchema.Elements.Values)
                {
                    XmlTypeMapping mapping = importer.ImportTypeMapping(element.QualifiedName);
                    exporter.ExportTypeMapping(mapping);
                }
                CodeGenerator.ValidateIdentifiers(ns);

                ////Microsoft.CSharp.CSharpCodeProvider oProvider;

                //// output the C# code
                //Microsoft.CSharp.CSharpCodeProvider codeProvider = new Microsoft.CSharp.CSharpCodeProvider();

                //using (StringWriter writer = new StringWriter())
                //{
                //    codeProvider.GenerateCodeFromNamespace(ns, writer, new CodeGeneratorOptions());
                //    string sCode = writer.GetStringBuilder().ToString();
                //}

                List <GenClassPivot> aGenClasses = PreProcess(ns, chartSchema);

                aGenClasses = FilterClassesPivot(aGenClasses);

                //(new CodegenCPP()).Process(sDirCppXmlOut, sDirCppBinOut, aGenClasses);
                //(new CodegenJS()).Process(sDirJsBinOut, aGenClasses);
                (new CodegenJSXml()).Process(sDirJsBinOut, aGenClasses);
            }
        }