public CqrsDataModelBuilder SetCurrentNamespace(string namespaceName) { var currentProject = GetOrCreateNamespaceModel(CurrentProjectModel, namespaceName); CurrentNamespaceModel = currentProject; return(this); }
private MarkdownTemplateModel InitNamespaceTemplateModel(NamespaceModel item) { var @namespace = InitBaseTemplateModel(item); @namespace.Classes = _models .Values .Where(model => item.Classes.FirstOrDefault(s => model.FullName == s) != null) .ToList(); @namespace.Interfaces = _models .Values .Where(model => item.Interfaces.FirstOrDefault(s => model.FullName == s) != null) .ToList(); @namespace.Structs = _models .Values .Where(model => item.Structs.FirstOrDefault(s => model.FullName == s) != null) .ToList(); @namespace.Enums = _models .Values .Where(model => item.Enums.FirstOrDefault(s => model.FullName == s) != null) .ToList(); @namespace.Delegates = _models .Values .Where(model => item.Delegates.FirstOrDefault(s => model.FullName == s) != null) .ToList(); @namespace.Attributes = _models .Values .Where(model => item.Attributes.FirstOrDefault(s => model.FullName == s) != null) .ToList(); @namespace.FilePath = $"{@namespace.Name.Replace('.', '/')}/{@namespace.Name}.md"; return(@namespace); }
/// <summary> /// Builds the specified assembly name. /// </summary> /// <param name="assemblyName">Name of the assembly.</param> /// <returns></returns> public NamespaceModel Build(string assemblyName) { var alternateName = GetAlternateName(assemblyName); var nm = new NamespaceModel { Name = assemblyName, }; var exclude = this.GetType().Assembly; var xml = LoadXml(assemblyName); var NSIgnoreList = ConfigurationManager.AppSettings["site:NamespacesIgnoreList"].Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries); DocumentationAssemblies.Where(a => a != exclude && (a.GetName().Name.Equals(alternateName, StringComparison.InvariantCultureIgnoreCase) || a.GetName().Name.Equals(assemblyName, StringComparison.InvariantCultureIgnoreCase)) ).ForEach(a => { a.GetTypes() .Where(t => ((t.IsInNamespace(alternateName) || t.IsInNamespace(assemblyName)) || (t.IsInChildNamespace(alternateName) || t.IsInChildNamespace(assemblyName))) && !NSIgnoreList.Contains(t.Namespace)) .Select(t => t.Namespace) .Distinct() .ForEach(ns => { if (string.IsNullOrWhiteSpace(nm.AssemblyVersion)) { nm.AssemblyVersion = a.GetName().Version.ToString(); } var processedNS = ProcessNamespace(ns, xml); if (processedNS != null && processedNS.Classes.Count > 0) { nm.Namespaces.Add(processedNS); } }); }); return(nm); }
public void OpenNamespaceTestCase() { string namespaceCode = "ExampleNamespaceCode"; NamespaceModel selectedModel = null; GivenShowEmptyPage() .And("Open settings.", viewModel => viewModel.UiServices.GetUiService <IUiSettings>().OpenSettingsAsync(null)) .AndWait(Timeouts.Second.One) .When("Open namespace.", () => { var page = CheckTypeAndGetPage <ContextPage>(); var list = page.FindChildByName <ListBox>("listNamespaces"); selectedModel = page .CheckTypeAndDataContext <ContextViewModel>() .Context .Namespaces .First(n => n.Code.EqualsOrdinalIgnoreCase(namespaceCode)); list.SelectedItem = selectedModel; }) .ThenWait(Timeouts.Second.One) .And("Check page.", () => { NamespaceModel namespaceModel = CheckTypeAndGetPage <NamespacePage>() .CheckTypeAndDataContext <NamespaceViewModel>() .Namespace; Assert.AreEqual(selectedModel, namespaceModel, "Expected another namespaceModel"); }) .RunTestWindow(Timeouts.Minute.One); }
public static NamespaceBase NamespaceBase(NamespaceModel namespaceModel) { return(new NamespaceBase() { Name = namespaceModel.Name, Types = namespaceModel.Types?.Select(GetOrAdd).ToList() }); }
private IEnumerable <CodeNamespace> GenerateCode() { var hierarchy = NamespaceHierarchyItem.Build(Namespaces.Values.GroupBy(x => x.Name).SelectMany(x => x)) .MarkAmbiguousNamespaceTypes(); return(hierarchy.Flatten() .Select(nhi => NamespaceModel.Generate(nhi.FullName, nhi.Models))); }
public NamespaceModel ToModel() { NamespaceModel namespaceModel = new NamespaceModel(); namespaceModel.NamespaceName = NamespaceName; namespaceModel.Types = Types.Select(model => model.ToModel()); return(namespaceModel); }
public NamespaceViewModel(NamespaceModel namespaceModel, TreeNodeViewModel parent) : base(namespaceModel.Name, parent) { NamespaceModel = namespaceModel; if (NamespaceModel.Namespaces?.Count > 0 || NamespaceModel?.Types.Count > 0) { AddDummyChild(); } }
private async Task GenerateNamespace(NamespaceModel @namespace, DirectoryInfo di) { foreach (var type in @namespace.Types) { await GenerateCodeFile(type, di); } foreach (var ns in @namespace.Namespaces) { await GenerateNamespace(ns, di.CreateSubdirectory(ns.Name)); } }
internal static NamespaceModel MapToNamespaceModel(this SettingNamespace settingNamespace, string namespacesPath, GrViewModelBase viewModel) { var result = new NamespaceModel { NamespacePath = namespacesPath, Namespace = settingNamespace, Settings = new ObservableCollection <SettingModel>(), }; viewModel.BindModel(result); return(result); }
public static string GetUniqueTypeName(this NamespaceModel model, string name) { var n = name; var i = 2; while (model.Types.ContainsKey(n) && !(model.Types[n] is SimpleModel)) { n = name + i; i++; } return(n); }
private void PropertyModel_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e) { NamespaceModel namespaceModel = sender as NamespaceModel; if (namespaceModel.Selected) { _iswixNamespaces.Add(namespaceModel.Prefix, namespaceModel.Uri); } else { _iswixNamespaces.Remove(namespaceModel.Prefix); } }
public BaseNamespaceModel MapDown(NamespaceModel model, Type namespaceModelType) { object namespaceModel = Activator.CreateInstance(namespaceModelType); PropertyInfo nameProperty = namespaceModelType.GetProperty("Name"); PropertyInfo namespaceModelsProperty = namespaceModelType.GetProperty("Types", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); nameProperty?.SetValue(namespaceModel, model.Name); namespaceModelsProperty?.SetValue(namespaceModel, HelperClass.ConvertList(namespaceModelsProperty.PropertyType.GetGenericArguments()[0], model.Types.Select(t => new TypeModelMapper().MapDown(t, namespaceModelsProperty.PropertyType.GetGenericArguments()[0])).ToList())); return((BaseNamespaceModel)namespaceModel); }
public override void GenerateModule(Module module, NamespaceModel @namespace, ITypeModelRegistry registry) { if (GetTypes(module).Any()) { var @class = @namespace.AddClass($"{module.Name}DbContext"); foreach (var aggregate in module.GetTypes <Aggregate>()) { @class.AddProperty($"{aggregate.Name}Set", SystemTypes.DbSet(registry.Resolve(Layer, aggregate))); } registry.Register(Layer, module, @class); } }
public void SetValueTestCase() { string namespaceCode = "SubExampleNamespaceCode"; string settingCode = "SettingInt"; string invalidValue = "1234"; NamespaceModel selectedModel = null; ValueTask <List <Setting> > openSettingsTask = default; GivenShowEmptyPage() .And("Open settings.", viewModel => openSettingsTask = viewModel.UiServices.GetUiService <IUiSettings>().OpenSettingsAsync(null)) .AndWait(Timeouts.Second.One) .And("Open namespace.", () => { var page = CheckTypeAndGetPage <ContextPage>(); var list = page.FindChildByName <ListBox>("listNamespaces"); selectedModel = page .CheckTypeAndDataContext <ContextViewModel>() .Context .Namespaces .First(n => n.Code.EqualsOrdinalIgnoreCase(namespaceCode)); list.SelectedItem = selectedModel; }) .AndWait(Timeouts.Second.One) .And("Set value", () => { var settingModel = selectedModel.Settings.First(s => s.Code.EqualsOrdinalIgnoreCase(settingCode)); settingModel.Value = invalidValue; }) .AndWait(Timeouts.Second.One) .And("Close Namespace page.", () => CheckTypeAndGetPage <NamespacePage>().FindChildByName <Button>("btnOk").OnClick()) .AndWait(Timeouts.Second.One) .WhenAsync("Close Context page.", async() => { CheckTypeAndGetPage <ContextPage>().FindChildByName <Button>("btnOk").OnClick(); return(await openSettingsTask); }) .Then("Check result", settings => { Setting setting = settings.Single(); Assert.AreEqual(settingCode, setting.Code, "Expected another code."); var expectedSetting = GetAdapter <SettingsAdapter>().GetSetting(setting.FullCode); Assert.AreEqual(expectedSetting.Value, setting.Value, "Expected another value."); }) .RunTestWindow(Timeouts.Minute.One); }
/// <summary> /// Processes the namespace. /// </summary> /// <param name="namespace">The namespace.</param> /// <param name="xml">The XML.</param> /// <returns></returns> private NamespaceModel ProcessNamespace(string @namespace, XmlDocument xml) { var nm = new NamespaceModel { Name = @namespace }; DocumentationAssemblies.ForEach(a => { var classes = new List <ClassModel>(); a.GetTypes().Where(t => t.IsPublic && t.IsClass && t.IsInNamespace(@namespace)).ForEach(t => { var pclass = ProcessType(t, xml); nm.Classes.Add(pclass); }); }); return(nm); }
public NamespaceModel MapUp(BaseNamespaceModel model) { NamespaceModel namespaceModel = new NamespaceModel(); namespaceModel.Name = model.Name; Type type = model.GetType(); PropertyInfo typesProperty = type.GetProperty("Types", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); List <BaseTypeModel> types = (List <BaseTypeModel>)HelperClass.ConvertList(typeof(BaseTypeModel), (IList)typesProperty?.GetValue(model)); if (types != null) { namespaceModel.Types = types.Select(n => TypeModelMapper.EmitType(n)).ToList(); } return(namespaceModel); }
public void SetInvalidValueTestCase() { string namespaceCode = "SubExampleNamespaceCode"; string settingCode = "SettingInt"; string invalidValue = "Hey!"; var settingValueError = new SettingValueError { ErrorMessage = "Error Errrorroororororor", SettingFullCode = $"ExampleNamespaceCode.{namespaceCode}.{settingCode}" }; NamespaceModel selectedModel = null; GivenShowEmptyPage() .And("Open settings.", viewModel => viewModel.UiServices.GetUiService <IUiSettings>().OpenSettingsAsync(new List <SettingValueError> { settingValueError })) .AndWait(Timeouts.Second.Two) .And("Open namespace.", () => { var page = CheckTypeAndGetPage <ContextPage>(); var list = page.FindChildByName <ListBox>("listNamespaces"); selectedModel = page .CheckTypeAndDataContext <ContextViewModel>() .Context .Namespaces .First(n => n.Code.EqualsOrdinalIgnoreCase(namespaceCode)); list.SelectedItem = selectedModel; }) .AndWait(Timeouts.Second.One) .When("Set value", () => { var settingModel = selectedModel.Settings.First(s => s.Code.EqualsOrdinalIgnoreCase(settingCode)); settingModel.Value = invalidValue; }) .ThenWait(Timeouts.Second.One) .And("Check notification", () => { var viewModel = CheckTypeAndGetPageSubFrame <NotificationWindowPage>().CheckTypeAndDataContext <NotificationWindowViewModel>(); Assert.AreEqual(NotificationTypes.Warning, viewModel.Type, "Expected another notification type."); Assert.AreEqual($"- {settingValueError.ErrorMessage}", viewModel.Message, "Expected another notification message."); }) .RunTestWindow(Timeouts.Minute.One); }
private NamespaceModel CreateNamespaceModel(Uri source, XmlQualifiedName qualifiedName) { NamespaceModel namespaceModel = null; if (!qualifiedName.IsEmpty && qualifiedName.Namespace != XmlSchema.Namespace) { var key = new NamespaceKey(source, qualifiedName.Namespace); if (!Namespaces.TryGetValue(key, out namespaceModel)) { var namespaceName = BuildNamespace(source, qualifiedName.Namespace); namespaceModel = new NamespaceModel(key, _configuration) { Name = namespaceName }; Namespaces.Add(key, namespaceModel); } } return(namespaceModel); }
private void PrepareModule(Module module, NamespaceModel @namespace, IEnumerable <ILayerCodeGenerator> generators) { foreach (var generator in generators) { foreach (var type in generator.GetTypes(module)) { var name = generator.GetTypeName(type); if (name != null) { var model = generator.PrepareType(@namespace, type); Register(generator.Layer, type, model.WithDescription(type.Description)); } } } module.Modules.ForEach(m => { PrepareModule(m, @namespace.AddNamespace(m.Name), generators); }); }
public void LoadData() { ObservableCollection <NamespaceModel> namespaces = new ObservableCollection <NamespaceModel>(); _iswixNamespaces = new WiXNamespaces(); foreach (var iswixNamespace in _iswixNamespaces.PossibleNamespaces) { NamespaceModel namespaceModel = new NamespaceModel(); if (_documentManager.Document.NameSpaces().ContainsKey(iswixNamespace.Key)) { namespaceModel.Selected = true; } namespaceModel.Prefix = iswixNamespace.Key; namespaceModel.Uri = iswixNamespace.Value; namespaceModel.PropertyChanged += PropertyModel_PropertyChanged; namespaces.Add(namespaceModel); } Namespaces = namespaces; }
private TypeModel CreateTypeModel(Uri source, XmlSchemaGroup group, NamespaceModel namespaceModel, XmlQualifiedName qualifiedName, List <DocumentationModel> docs) { var name = "I" + _configuration.NamingProvider.GroupTypeNameFromQualifiedName(qualifiedName); if (namespaceModel != null) { name = namespaceModel.GetUniqueTypeName(name); } var interfaceModel = new InterfaceModel(_configuration) { Name = name, Namespace = namespaceModel, XmlSchemaName = qualifiedName }; interfaceModel.Documentation.AddRange(docs); if (namespaceModel != null) { namespaceModel.Types[name] = interfaceModel; } if (!qualifiedName.IsEmpty) { var key = BuildKey(group, qualifiedName); Types[key] = interfaceModel; } var particle = group.Particle; var items = GetElements(particle); var properties = CreatePropertiesForElements(source, interfaceModel, particle, items.Where(i => !(i.XmlParticle is XmlSchemaGroupRef))); interfaceModel.Properties.AddRange(properties); var interfaces = items.Select(i => i.XmlParticle).OfType <XmlSchemaGroupRef>() .Select(i => (InterfaceModel)CreateTypeModel(CodeUtilities.CreateUri(i.SourceUri), Groups[i.RefName], i.RefName)); interfaceModel.AddInterfaces(interfaces); return(interfaceModel); }
internal static IReadOnlyCollection <MessageModel> SetupNamespaceList(XmlNodeList namespaces, ref int count) { var messageModels = new List <MessageModel>(namespaces.Count); foreach (XmlNode @namespace in namespaces) { var namespaceModel = new NamespaceModel { Name = XmlNodeHelper.GetNodeAttributeValue(@namespace, "Name") }; // Get the list of messages messageModels.AddRange(MessageModelHelper.BuildListOfMessages(@namespace, namespaceModel, ref count)); var list = XmlNodeHelper.NodeListHelper(@namespace, ref count); messageModels.AddRange(list); } return(messageModels); }
private void GenerateModule(Module module, NamespaceModel model, IEnumerable <ILayerCodeGenerator> generators) { foreach (var generator in generators) { generator.GenerateModule(module, model, this); foreach (var type in generator.GetTypes(module)) { var resolved = Resolve(generator.Layer, type, generator.GetTypeName(type)); if (resolved != null) { generator.GenerateType(type, resolved, this); } } } module.Modules.ForEach(m => { GenerateModule(m, model.AddNamespace(m.Name), generators); }); }
public void CircuralReferenceTest() { reflector.Reflect(path); IMapper _mapper = Mapper.Initialize(); AssemblyModel assemblyModel = reflector.AssemblyModel; AssemblyDto assemblyDto = _mapper.Map <AssemblyDto>(assemblyModel); NamespaceModel circuralNamespaceModel = assemblyModel.Namespaces[1].Namespaces[0]; NamespaceDto circuralNamespaceDto = assemblyDto.Namespaces[1].Namespaces[0]; TypeModel typeModel_A = circuralNamespaceModel.Types[0]; TypeModel typemodel_A_ref = circuralNamespaceModel.Types[1].Fields[0].TypeModel; TypeModel typeModel_B = circuralNamespaceModel.Types[1]; TypeDto typeDto_A = circuralNamespaceDto.Types[0]; TypeDto typeDto_A_ref = circuralNamespaceDto.Types[1].Fields[0].TypeModel; TypeDto typeDto_B = circuralNamespaceDto.Types[1]; Assert.AreEqual(typeModel_A.Name, typemodel_A_ref.Name); Assert.AreSame(typeModel_A, typemodel_A_ref); Assert.AreNotEqual(typeModel_A.Name, typeModel_B.Name); Assert.AreNotSame(typeModel_A, typeModel_B); Assert.AreEqual(typeDto_A.Name, typeDto_A_ref.Name); Assert.AreSame(typeDto_A, typeDto_A_ref); Assert.AreNotEqual(typeDto_A.Name, typeDto_B.Name); Assert.AreNotSame(typeDto_A, typeDto_B); }
public void TestIfReflectorReturnsAppropriateNamespace() { string path = @"..\..\..\ExampleDll\obj\Debug\netstandard2.0\ExampleDll.dll"; Reflector reflector = new Reflector(); reflector.GetAssemblyModel(path); Assert.AreEqual(17, reflector.Beans.Count); Assert.AreEqual(1, reflector.AssemblyModel.Namespaces.Count); NamespaceModel testedNamespace = reflector.AssemblyModel.Namespaces.Find(n => n.Name == "ExampleDll.Home"); Assert.AreEqual(3, testedNamespace.Namespaces.Count); NamespaceModel testedNamespace2 = testedNamespace .Namespaces .Find(n => n.Name == "ExampleDll.Home.NestedNamespace") .Namespaces .Find(n => n.Name == "ExampleDll.Home.NestedNamespace.InnerNestedNamespace"); TypeModel testedClass = testedNamespace2 .Types .Find(t => t.Name == "ClassImplementingInterfaces"); Assert.AreEqual(2, testedClass.Interfaces.Count); }
private TypeModel CreateTypeModel(XmlSchemaSimpleType simpleType, NamespaceModel namespaceModel, XmlQualifiedName qualifiedName, List <DocumentationModel> docs) { var restrictions = new List <RestrictionModel>(); if (simpleType.Content is XmlSchemaSimpleTypeRestriction typeRestriction) { var enumFacets = typeRestriction.Facets.OfType <XmlSchemaEnumerationFacet>().ToList(); // If there's a pattern restriction mixed into the enumeration values, we'll generate a string to play it safe. var isEnum = enumFacets.Count > 0 && !typeRestriction.Facets.OfType <XmlSchemaPatternFacet>().Any(); if (isEnum) { // we got an enum var name = _configuration.NamingProvider.EnumTypeNameFromQualifiedName(qualifiedName); if (namespaceModel != null) { name = namespaceModel.GetUniqueTypeName(name); } var enumModel = new EnumModel(_configuration) { Name = name, Namespace = namespaceModel, XmlSchemaName = qualifiedName, XmlSchemaType = simpleType, IsAnonymous = string.IsNullOrEmpty(simpleType.QualifiedName.Name), }; enumModel.Documentation.AddRange(docs); foreach (var facet in enumFacets.DistinctBy(f => f.Value)) { var value = new EnumValueModel { Name = _configuration.NamingProvider.EnumMemberNameFromValue(enumModel.Name, facet.Value), Value = facet.Value }; var valueDocs = GetDocumentation(facet); value.Documentation.AddRange(valueDocs); var deprecated = facet.Annotation != null && facet.Annotation.Items.OfType <XmlSchemaAppInfo>() .Any(a => a.Markup.Any(m => m.Name == "annox:annotate" && m.HasChildNodes && m.FirstChild.Name == "jl:Deprecated")); value.IsDeprecated = deprecated; enumModel.Values.Add(value); } enumModel.Values = EnsureEnumValuesUnique(enumModel.Values); if (namespaceModel != null) { namespaceModel.Types[enumModel.Name] = enumModel; } if (!qualifiedName.IsEmpty) { var key = BuildKey(simpleType, qualifiedName); Types[key] = enumModel; } return(enumModel); } restrictions = GetRestrictions(typeRestriction.Facets.Cast <XmlSchemaFacet>(), simpleType).Where(r => r != null).Sanitize().ToList(); } var simpleModelName = _configuration.NamingProvider.SimpleTypeNameFromQualifiedName(qualifiedName); if (namespaceModel != null) { simpleModelName = namespaceModel.GetUniqueTypeName(simpleModelName); } var simpleModel = new SimpleModel(_configuration) { Name = simpleModelName, Namespace = namespaceModel, XmlSchemaName = qualifiedName, XmlSchemaType = simpleType, ValueType = simpleType.Datatype.GetEffectiveType(_configuration, restrictions), }; simpleModel.Documentation.AddRange(docs); simpleModel.Restrictions.AddRange(restrictions); if (namespaceModel != null) { namespaceModel.Types[simpleModel.Name] = simpleModel; } if (!qualifiedName.IsEmpty) { var key = BuildKey(simpleType, qualifiedName); Types[key] = simpleModel; } return(simpleModel); }
private TypeModel CreateTypeModel(Uri source, XmlSchemaAttributeGroup attributeGroup, NamespaceModel namespaceModel, XmlQualifiedName qualifiedName, List <DocumentationModel> docs) { var name = "I" + _configuration.NamingProvider.AttributeGroupTypeNameFromQualifiedName(qualifiedName); if (namespaceModel != null) { name = namespaceModel.GetUniqueTypeName(name); } var interfaceModel = new InterfaceModel(_configuration) { Name = name, Namespace = namespaceModel, XmlSchemaName = qualifiedName }; interfaceModel.Documentation.AddRange(docs); if (namespaceModel != null) { namespaceModel.Types[name] = interfaceModel; } if (!qualifiedName.IsEmpty) { var key = BuildKey(attributeGroup, qualifiedName); Types[key] = interfaceModel; } var items = attributeGroup.Attributes; var properties = CreatePropertiesForAttributes(source, interfaceModel, items.OfType <XmlSchemaAttribute>()); interfaceModel.Properties.AddRange(properties); var interfaces = items.OfType <XmlSchemaAttributeGroupRef>() .Select(a => (InterfaceModel)CreateTypeModel(CodeUtilities.CreateUri(a.SourceUri), AttributeGroups[a.RefName], a.RefName)); interfaceModel.AddInterfaces(interfaces); return(interfaceModel); }
private TypeModel CreateTypeModel(Uri source, XmlSchemaComplexType complexType, NamespaceModel namespaceModel, XmlQualifiedName qualifiedName, List <DocumentationModel> docs) { var name = _configuration.NamingProvider.ComplexTypeNameFromQualifiedName(qualifiedName); if (namespaceModel != null) { name = namespaceModel.GetUniqueTypeName(name); } var classModel = new ClassModel(_configuration) { Name = name, Namespace = namespaceModel, XmlSchemaName = qualifiedName, XmlSchemaType = complexType, IsAbstract = complexType.IsAbstract, IsAnonymous = string.IsNullOrEmpty(complexType.QualifiedName.Name), IsMixed = complexType.IsMixed, IsSubstitution = complexType.Parent is XmlSchemaElement && !((XmlSchemaElement)complexType.Parent).SubstitutionGroup.IsEmpty }; classModel.Documentation.AddRange(docs); if (namespaceModel != null) { namespaceModel.Types[classModel.Name] = classModel; } if (!qualifiedName.IsEmpty) { var key = BuildKey(complexType, qualifiedName); Types[key] = classModel; } if (complexType.BaseXmlSchemaType != null && complexType.BaseXmlSchemaType.QualifiedName != AnyType) { var baseModel = CreateTypeModel(source, complexType.BaseXmlSchemaType, complexType.BaseXmlSchemaType.QualifiedName); classModel.BaseClass = baseModel; if (baseModel is ClassModel baseClassModel) { baseClassModel.DerivedTypes.Add(classModel); } } XmlSchemaParticle particle = null; if (classModel.BaseClass != null) { if (complexType.ContentModel.Content is XmlSchemaComplexContentExtension complexContent) { particle = complexContent.Particle; } // If it's a restriction, do not duplicate elements on the derived class, they're already in the base class. // See https://msdn.microsoft.com/en-us/library/f3z3wh0y.aspx } else { particle = complexType.Particle ?? complexType.ContentTypeParticle; } var items = GetElements(particle, complexType).ToList(); if (_configuration.GenerateInterfaces) { var interfaces = items.Select(i => i.XmlParticle).OfType <XmlSchemaGroupRef>() .Select(i => (InterfaceModel)CreateTypeModel(CodeUtilities.CreateUri(i.SourceUri), Groups[i.RefName], i.RefName)).ToList(); classModel.AddInterfaces(interfaces); } var properties = CreatePropertiesForElements(source, classModel, particle, items); classModel.Properties.AddRange(properties); XmlSchemaObjectCollection attributes = null; if (classModel.BaseClass != null) { if (complexType.ContentModel.Content is XmlSchemaComplexContentExtension complexContent) { attributes = complexContent.Attributes; } else if (complexType.ContentModel.Content is XmlSchemaSimpleContentExtension simpleContent) { attributes = simpleContent.Attributes; } // If it's a restriction, do not duplicate attributes on the derived class, they're already in the base class. // See https://msdn.microsoft.com/en-us/library/f3z3wh0y.aspx } else { attributes = complexType.Attributes; } if (attributes != null) { var attributeProperties = CreatePropertiesForAttributes(source, classModel, attributes.Cast <XmlSchemaObject>()); classModel.Properties.AddRange(attributeProperties); if (_configuration.GenerateInterfaces) { var attributeInterfaces = attributes.OfType <XmlSchemaAttributeGroupRef>() .Select(i => (InterfaceModel)CreateTypeModel(CodeUtilities.CreateUri(i.SourceUri), AttributeGroups[i.RefName], i.RefName)); classModel.AddInterfaces(attributeInterfaces); } } if (complexType.AnyAttribute != null) { var property = new PropertyModel(_configuration) { OwningType = classModel, Name = "AnyAttribute", Type = new SimpleModel(_configuration) { ValueType = typeof(XmlAttribute), UseDataTypeAttribute = false }, IsAttribute = true, IsCollection = true, IsAny = true }; var attributeDocs = GetDocumentation(complexType.AnyAttribute); property.Documentation.AddRange(attributeDocs); classModel.Properties.Add(property); } return(classModel); }
private TypeModel CreateTypeModel(Uri source, XmlSchemaSimpleType simpleType, NamespaceModel namespaceModel, XmlQualifiedName qualifiedName, List <DocumentationModel> docs) { var restrictions = new List <RestrictionModel>(); if (simpleType.Content is XmlSchemaSimpleTypeRestriction typeRestriction) { var enumFacets = typeRestriction.Facets.OfType <XmlSchemaEnumerationFacet>().ToList(); var isEnum = (enumFacets.Count == typeRestriction.Facets.Count && enumFacets.Count != 0) || (EnumTypes.Contains(typeRestriction.BaseTypeName.Name) && enumFacets.Any()); if (isEnum) { // we got an enum var name = ToTitleCase(qualifiedName.Name); if (namespaceModel != null) { name = namespaceModel.GetUniqueTypeName(name); } var enumModel = new EnumModel(_configuration) { Name = name, Namespace = namespaceModel, XmlSchemaName = qualifiedName, XmlSchemaType = simpleType, }; enumModel.Documentation.AddRange(docs); foreach (var facet in enumFacets.DistinctBy(f => f.Value)) { var value = new EnumValueModel { Name = _configuration.NamingProvider.EnumMemberNameFromValue(enumModel.Name, facet.Value), Value = facet.Value }; var valueDocs = GetDocumentation(facet); value.Documentation.AddRange(valueDocs); var deprecated = facet.Annotation != null && facet.Annotation.Items.OfType <XmlSchemaAppInfo>() .Any(a => a.Markup.Any(m => m.Name == "annox:annotate" && m.HasChildNodes && m.FirstChild.Name == "jl:Deprecated")); value.IsDeprecated = deprecated; enumModel.Values.Add(value); } if (namespaceModel != null) { namespaceModel.Types[enumModel.Name] = enumModel; } if (!qualifiedName.IsEmpty) { Types[qualifiedName] = enumModel; } return(enumModel); } restrictions = GetRestrictions(typeRestriction.Facets.Cast <XmlSchemaFacet>(), simpleType).Where(r => r != null).Sanitize().ToList(); } var simpleModelName = ToTitleCase(qualifiedName.Name); if (namespaceModel != null) { simpleModelName = namespaceModel.GetUniqueTypeName(simpleModelName); } var simpleModel = new SimpleModel(_configuration) { Name = simpleModelName, Namespace = namespaceModel, XmlSchemaName = qualifiedName, XmlSchemaType = simpleType, ValueType = simpleType.Datatype.GetEffectiveType(_configuration), }; simpleModel.Documentation.AddRange(docs); simpleModel.Restrictions.AddRange(restrictions); if (namespaceModel != null) { namespaceModel.Types[simpleModel.Name] = simpleModel; } if (!qualifiedName.IsEmpty) { Types[qualifiedName] = simpleModel; } return(simpleModel); }