private bool ReferencesGson(MetadataTypes metadata) { var allTypes = GetAllMetadataTypes(metadata); return(allTypes.Any(x => JavaGeneratorExtensions.JavaKeyWords.Contains(x.Name) || x.Properties.Safe().Any(p => p.DataMember != null && p.DataMember.Name != null) || (x.ReturnMarkerTypeName != null && x.ReturnMarkerTypeName.Name.IndexOf('`') >= 0))); //uses TypeToken<T> }
private bool ReferencesGson(MetadataTypes metadata) { return(metadata.GetAllMetadataTypes() .Any(x => x.Properties.Safe().Any(p => JavaGeneratorExtensions.JavaKeyWords.Contains(p.Name.PropertyStyle())) || x.Properties.Safe().Any(p => p.DataMember?.Name != null) || (x.ReturnMarkerTypeName != null && x.ReturnMarkerTypeName.Name.IndexOf('`') >= 0) //uses TypeToken<T> )); }
private static List <MetadataType> GetAllMetadataTypes(MetadataTypes metadata) { var allTypes = new List <MetadataType>(); allTypes.AddRange(metadata.Types); allTypes.AddRange(metadata.Operations.Where(x => x.Request != null).Select(x => x.Request)); allTypes.AddRange(metadata.Operations.Where(x => x.Response != null).Select(x => x.Request)); return(allTypes); }
private static void AddReferencedTypes(MetadataType metadataType, MetadataTypes metadataTypes, List <MetadataType> types) { if (metadataType.Inherits != null) { var type = FindMetadataType(metadataTypes, metadataType.Inherits.Name, metadataType.Inherits.Namespace); if (type != null && !types.Contains(type)) { types.Add(type); } if (!metadataType.Inherits.GenericArgs.IsEmpty()) { foreach (var arg in metadataType.Inherits.GenericArgs) { type = FindMetadataType(metadataTypes, arg); if (type != null && !types.Contains(type)) { types.Add(type); } } } } if (metadataType.Properties != null) { foreach (var p in metadataType.Properties) { var type = FindMetadataType(metadataTypes, p.Type, p.TypeNamespace); if (type != null && !types.Contains(type)) { types.Add(type); } if (!p.GenericArgs.IsEmpty()) { foreach (var arg in p.GenericArgs) { type = FindMetadataType(metadataTypes, arg); if (type != null && !types.Contains(type)) { types.Add(type); } } } else if (p.IsArray()) { var elType = p.Type.SplitOnFirst('[')[0]; type = FindMetadataType(metadataTypes, elType); if (type != null && !types.Contains(type)) { types.Add(type); } } } } }
internal Metadata(MetadataTypes type, uint soundIndex) { _type = type; _soundIndex = soundIndex; _listIndex = 0; _entryIndex = 0; _languageCode = 0; _word = string.Empty; _label = string.Empty; }
internal Metadata(MetadataTypes type, string word, uint languageCode) { _type = type; _word = word; _languageCode = languageCode; _listIndex = 0; _entryIndex = 0; _soundIndex = 0; _label = string.Empty; }
internal Metadata(MetadataTypes type, uint listIndex, uint entryIndex, string label) { _type = type; _listIndex = listIndex; _entryIndex = entryIndex; _label = label == null ? string.Empty : label; _word = string.Empty; _languageCode = 0; _soundIndex = 0; }
public static List <MetadataType> GetAllMetadataTypes(this MetadataTypes metadata) { var allTypes = new List <MetadataType>(); allTypes.AddRange(metadata.Types); allTypes.AddRange(metadata.Operations.Where(x => x.Request != null).Select(x => x.Request)); allTypes.AddRange(metadata.Operations.Where(x => x.Response != null).Select(x => x.Response)); allTypes.AddRange(metadata.Operations.Where(x => x.Request?.ReturnMarkerTypeName != null).Select( x => x.Request.ReturnMarkerTypeName.ToMetadataType())); return(allTypes); }
public static void RemoveIgnoredTypes(this MetadataTypes metadata, MetadataTypesConfig config) { metadata.Types.RemoveAll(x => x.IgnoreType(config)); metadata.Operations.RemoveAll(x => x.Request.IgnoreType(config)); metadata.Operations.Each(x => { if (x.Response != null && x.Response.IgnoreType(config)) { x.Response = null; } }); }
public static List <string> GetIncludeList(MetadataTypes metadata, MetadataTypesConfig config) { const string wildCard = ".*"; if (config.IncludeTypes == null) { return(null); } var typesToExpand = config.IncludeTypes .Where(s => s.Length > 2 && s.EndsWith(wildCard)) .Map(s => s.Substring(0, s.Length - 2)); if (typesToExpand.Count == 0) { return(config.IncludeTypes); } // From IncludeTypes get the corresponding MetadataTypes var includedMetadataTypes = metadata.Operations .Select(o => o.Request) .Where(t => typesToExpand.Contains(t.Name)) .ToList(); var includeSet = includedMetadataTypes .Where(x => x.ReturnMarkerTypeName != null) .Select(x => x.ReturnMarkerTypeName.Name) .ToHashSet(); var includedResponses = metadata.Operations .Where(t => typesToExpand.Contains(t.Request.Name) && t.Response != null) .Select(o => o.Response) .ToList(); includedResponses.ForEach(x => includeSet.Add(x.Name)); var returnTypesForInclude = metadata.Operations .Where(x => x.Response != null && includeSet.Contains(x.Response.Name)) .Map(x => x.Response); // GetReferencedTypes for both request + response objects var referenceTypes = includedMetadataTypes .Union(returnTypesForInclude) .Where(x => x != null) .SelectMany(x => x.GetReferencedTypeNames()); return(referenceTypes .Union(config.IncludeTypes) .Union(typesToExpand) .Union(returnTypesForInclude.Select(x => x.Name)) .Distinct() .ToList()); }
public static string GenerateSourceCode(this List <MetadataType> metadataTypes, string lang, IRequest req, Action <ILangGenerator> configure = null) { var nativeTypes = HostContext.GetPlugin <NativeTypesFeature>(); var request = new NativeTypesBase { // GlobalNamespace = "dtos", ExportAsTypes = true, }; var types = new MetadataTypes { Config = req.Resolve <INativeTypesMetadata>().GetConfig(request), Types = metadataTypes, }; types.Config.BaseUrl = nativeTypes.MetadataTypesConfig.BaseUrl ?? req.GetBaseUrl(); return(types.GenerateSourceCode(types.Config, lang, req, configure)); }
public virtual void DeserializeAllMetadataAndCacheIt(Stream byteStream) { long initialStreamPostion = byteStream.Position; uint metadataByteCount = byteStream.DeserializeUint32(); long metadataLastBytePosition = metadataByteCount + sizeof(uint) + initialStreamPostion; while (byteStream.Position < metadataLastBytePosition) { MetadataTypes metadataType = byteStream.DeserializeMetadataType(); MetadataBase result = null; switch (metadataType) { case MetadataTypes.AssemblyMetadata: var assemblyMetadata = new AssemblyMetadata(byteStream); _assemblyCache.Add(assemblyMetadata); result = assemblyMetadata; break; case MetadataTypes.ModuleMedatada: var moduleMetadata = new ModuleMetadata(byteStream, _assemblyCache); _moduleCache.Add(moduleMetadata); result = moduleMetadata; break; case MetadataTypes.ClassMedatada: var classMetadata = new ClassMetadata(byteStream, _moduleCache); _classCache.Add(classMetadata); result = classMetadata; break; case MetadataTypes.MethodMedatada: var methodMetadata = new MethodMetadata(byteStream, _classCache, _sourceLocatorFactory); _methodCache.Add(methodMetadata); result = methodMetadata; break; default: throw new ArgumentOutOfRangeException(); } Contract.Assume(result != null); Contract.Assume(result.Id != 0); Contract.Assume(result.MdToken != 0); Contract.Assume(metadataType == result.MetadataType); } }
public static List <MetadataType> GetAllTypes(this MetadataTypes metadata) { var map = new Dictionary <string, MetadataType>(); foreach (var op in metadata.Operations) { if (!(op.Request.Namespace ?? "").StartsWith("System")) { map[op.Request.Name] = op.Request; } if (op.Response != null && !(op.Response.Namespace ?? "").StartsWith("System")) { map[op.Response.Name] = op.Response; } } metadata.Types.Each(x => map[x.Name] = x); return(map.Values.ToList()); }
public static HashSet<string> GetDefaultNamespaces(this MetadataTypesConfig config, MetadataTypes metadata) { var namespaces = config.DefaultNamespaces.ToHashSet(); config.AddNamespaces.Safe().Each(x => namespaces.Add(x)); //Add any ignored namespaces used foreach (var ns in metadata.Namespaces) { //Ignored by IsUserType() if (!ns.StartsWith("System") && !config.IgnoreTypesInNamespaces.Contains(ns)) continue; if (!namespaces.Contains(ns)) { namespaces.Add(ns); } } return namespaces; }
private void RenderText(string text, int styleId, string fullText = null, uint lang = 0) { text = ReplaceSymbolsInText(text); bool needHighlight = false; if (fullText != null) { fullText = ReplaceSymbolsInText(fullText); needHighlight = NeedHighlight(fullText, lang); } else { needHighlight = NeedHighlight(text, lang); } bool isClickable = _renderParameters.Crossrefs && !_isHideControl && !_isHyperlink; if (_linkHandler.IsLink) { MetadataTypes metaType = MetadataTypes.Link; if (_linkHandler.IsPopup) { metaType = MetadataTypes.PopupArticle; } Metadata meta = new Metadata(metaType, _linkHandler.ListIndex, _linkHandler.EntryIndex, _linkHandler.Label); _article.Append(HtmlBuilder.CreateText(text, styleId, isClickable, needHighlight, meta)); return; } if (!string.IsNullOrEmpty(fullText)) { Metadata meta = new Metadata(MetadataTypes.Text, fullText, lang); _article.Append(HtmlBuilder.CreateText(text, styleId, isClickable, needHighlight, meta)); return; } _article.Append(HtmlBuilder.CreateText(text, styleId, false, needHighlight)); }
public void DeserializeMetadataTypesTest() { byte[] bytes = { 0x0B, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00 }; MemoryStream memoryStream = bytes.ConvertToMemoryStream(); MetadataTypes metadataType = memoryStream.DeserializeMetadataType(); Assert.AreEqual(MetadataTypes.AssemblyMetadata, metadataType); metadataType = memoryStream.DeserializeMetadataType(); Assert.AreEqual(MetadataTypes.ModuleMedatada, metadataType); metadataType = memoryStream.DeserializeMetadataType(); Assert.AreEqual(MetadataTypes.ClassMedatada, metadataType); metadataType = memoryStream.DeserializeMetadataType(); Assert.AreEqual(MetadataTypes.MethodMedatada, metadataType); }
static MetadataType FindMetadataType(MetadataTypes metadataTypes, string name, string @namespace) { if (@namespace.StartsWith("System")) { return(null); } var reqType = metadataTypes.Operations.FirstOrDefault(x => x.Request.Name == name); if (reqType != null) { return(reqType.Request); } var resType = metadataTypes.Operations .FirstOrDefault(x => x.Response != null && x.Response.Name == name); if (resType != null) { return(resType.Response); } return(metadataTypes.Types.FirstOrDefault(x => x.Name == name && x.Namespace == @namespace)); }
public MetadataTypes GetMetadataTypes(IRequest req) { var metadata = new MetadataTypes { Config = config, }; var skipTypes = config.IgnoreTypes ?? new HashSet<Type>(); var opTypes = new HashSet<Type>(); var ignoreNamespaces = config.IgnoreTypesInNamespaces ?? new List<string>(); foreach (var operation in meta.Operations) { if (!meta.IsVisible(req, operation)) continue; if (opTypes.Contains(operation.RequestType)) continue; if (skipTypes.Contains(operation.RequestType)) continue; if (ignoreNamespaces.Contains(operation.RequestType.Namespace)) continue; var opType = new MetadataOperationType { Actions = operation.Actions, Request = ToType(operation.RequestType), Response = ToType(operation.ResponseType), }; metadata.Operations.Add(opType); opTypes.Add(operation.RequestType); if (operation.ResponseType != null) { if (skipTypes.Contains(operation.ResponseType)) { //Config.IgnoreTypesInNamespaces in CSharpGenerator opType.Response = null; } else { opTypes.Add(operation.ResponseType); } } } var considered = new HashSet<Type>(opTypes); var queue = new Queue<Type>(opTypes); Func<Type, bool> ignoreTypeFn = t => t == null || considered.Contains(t) || skipTypes.Contains(t) || ignoreNamespaces.Contains(t.Namespace); Action<Type> registerTypeFn = t => { if (t.IsArray || t == typeof(Array)) return; considered.Add(t); queue.Enqueue(t); if (t.IsUserType()) metadata.Types.Add(ToType(t)); }; while (queue.Count > 0) { var type = queue.Dequeue(); foreach (var pi in type.GetSerializableProperties() .Where(pi => !ignoreTypeFn(pi.PropertyType))) { registerTypeFn(pi.PropertyType); } if (!ignoreTypeFn(type.BaseType)) { registerTypeFn(type.BaseType); } if (!type.IsGenericType()) continue; var args = type.GetGenericArguments(); foreach (var arg in args.Where(arg => !ignoreTypeFn(arg))) { registerTypeFn(arg); } } return metadata; }
public static void RemoveIgnoredTypesForNet(this MetadataTypes metadata, MetadataTypesConfig config) { metadata.RemoveIgnoredTypes(config); //Don't include Exported Types in System metadata.Types.RemoveAll(x => x.IgnoreSystemType()); }
private static bool ReferencesStream(MetadataTypes metadata) { return(metadata.GetAllMetadataTypes().Any(x => x.Name == "Stream" && x.Namespace == "System.IO")); }
public string GetCode(MetadataTypes metadata, IRequest request) { var namespaces = Config.GetDefaultNamespaces(metadata); var typeNamespaces = new HashSet <string>(); metadata.RemoveIgnoredTypes(Config); metadata.Types.Each(x => typeNamespaces.Add(x.Namespace)); metadata.Operations.Each(x => typeNamespaces.Add(x.Request.Namespace)); // Look first for shortest Namespace ending with `ServiceModel` convention, else shortest ns var globalNamespace = Config.GlobalNamespace ?? typeNamespaces.Where(x => x.EndsWith("ServiceModel")) .OrderBy(x => x).FirstOrDefault() ?? typeNamespaces.OrderBy(x => x).First(); Func <string, string> defaultValue = k => request.QueryString[k].IsNullOrEmpty() ? "//" : ""; var sb = new StringBuilderWrapper(new StringBuilder()); sb.AppendLine("(* Options:"); sb.AppendLine("Date: {0}".Fmt(DateTime.Now.ToString("s").Replace("T", " "))); sb.AppendLine("Version: {0}".Fmt(metadata.Version)); sb.AppendLine("BaseUrl: {0}".Fmt(Config.BaseUrl)); sb.AppendLine(); sb.AppendLine("{0}GlobalNamespace: {1}".Fmt(defaultValue("GlobalNamespace"), Config.GlobalNamespace)); sb.AppendLine("{0}MakeDataContractsExtensible: {1}".Fmt(defaultValue("MakeDataContractsExtensible"), Config.MakeDataContractsExtensible)); sb.AppendLine("{0}AddReturnMarker: {1}".Fmt(defaultValue("AddReturnMarker"), Config.AddReturnMarker)); sb.AppendLine("{0}AddDescriptionAsComments: {1}".Fmt(defaultValue("AddDescriptionAsComments"), Config.AddDescriptionAsComments)); sb.AppendLine("{0}AddDataContractAttributes: {1}".Fmt(defaultValue("AddDataContractAttributes"), Config.AddDataContractAttributes)); sb.AppendLine("{0}AddIndexesToDataMembers: {1}".Fmt(defaultValue("AddIndexesToDataMembers"), Config.AddIndexesToDataMembers)); sb.AppendLine("{0}AddResponseStatus: {1}".Fmt(defaultValue("AddResponseStatus"), Config.AddResponseStatus)); sb.AppendLine("{0}AddImplicitVersion: {1}".Fmt(defaultValue("AddImplicitVersion"), Config.AddImplicitVersion)); sb.AppendLine("{0}IncludeTypes: {1}".Fmt(defaultValue("IncludeTypes"), Config.IncludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}ExcludeTypes: {1}".Fmt(defaultValue("ExcludeTypes"), Config.ExcludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}InitializeCollections: {1}".Fmt(defaultValue("InitializeCollections"), Config.InitializeCollections)); //sb.AppendLine("{0}AddDefaultXmlNamespace: {1}".Fmt(defaultValue("AddDefaultXmlNamespace"), Config.AddDefaultXmlNamespace)); //sb.AppendLine("{0}DefaultNamespaces: {1}".Fmt(defaultValue("DefaultNamespaces"), Config.DefaultNamespaces.ToArray().Join(", "))); sb.AppendLine("*)"); sb.AppendLine(); //if (Config.AddDataContractAttributes // && Config.AddDefaultXmlNamespace != null) //{ // sb.AppendLine(); // var list = namespaces.Where(x => !Config.DefaultNamespaces.Contains(x)).ToList(); // list.ForEach(x => // sb.AppendLine("[<assembly: ContractNamespace(\"{0}\", ClrNamespace=\"{1}\")>]" // .Fmt(Config.AddDefaultXmlNamespace, x))); // if (list.Count > 0) // { // sb.AppendLine("do()"); //http://scottseely.com/2009/01/23/f-assembly-level-attributes-assemblyinfo-fs-and-do/ // } //} //sb.AppendLine(); string lastNS = null; var existingTypes = new HashSet <string>(); var requestTypes = metadata.Operations.Select(x => x.Request).ToHashSet(); var requestTypesMap = metadata.Operations.ToSafeDictionary(x => x.Request); var responseTypes = metadata.Operations .Where(x => x.Response != null) .Select(x => x.Response).ToHashSet(); var types = metadata.Types.ToHashSet(); var allTypes = new List <MetadataType>(); allTypes.AddRange(types); allTypes.AddRange(responseTypes); allTypes.AddRange(requestTypes); var orderedTypes = allTypes.OrderTypesByDeps(); sb.AppendLine("namespace {0}".Fmt(globalNamespace.SafeToken())); sb.AppendLine(); foreach (var ns in namespaces) { sb.AppendLine("open " + ns); } foreach (var type in orderedTypes) { var fullTypeName = type.GetFullName(); if (requestTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName)) { MetadataType response = null; MetadataOperationType operation; if (requestTypesMap.TryGetValue(type, out operation)) { response = operation.Response; } lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { ImplementsFn = () => { if (!Config.AddReturnMarker && !type.ReturnVoidMarker && type.ReturnMarkerTypeName == null) { return(null); } if (type.ReturnVoidMarker) { return("IReturnVoid"); } if (type.ReturnMarkerTypeName != null) { return(Type("IReturn`1", new[] { Type(type.ReturnMarkerTypeName) })); } return(response != null ? Type("IReturn`1", new[] { Type(response.Name, response.GenericArgs) }) : null); }, IsRequest = true, }); existingTypes.Add(fullTypeName); } } else if (responseTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName) && !Config.IgnoreTypesInNamespaces.Contains(type.Namespace)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsResponse = true, }); existingTypes.Add(fullTypeName); } } else if (types.Contains(type) && !existingTypes.Contains(fullTypeName)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsType = true }); existingTypes.Add(fullTypeName); } } sb.AppendLine(); return(sb.ToString()); }
public MetadataTypes GetMetadataTypes(IRequest req, Func<Operation, bool> predicate = null) { var metadata = new MetadataTypes { Config = config, }; var skipTypes = config.IgnoreTypes ?? new HashSet<Type>(); var opTypes = new HashSet<Type>(); var ignoreNamespaces = config.IgnoreTypesInNamespaces ?? new List<string>(); var exportTypes = config.ExportTypes ?? new HashSet<Type>(); foreach (var operation in meta.Operations) { if (predicate != null && !predicate(operation)) continue; if (!meta.IsVisible(req, operation)) continue; if (opTypes.Contains(operation.RequestType)) continue; if (skipTypes.Contains(operation.RequestType)) continue; if (ignoreNamespaces.Contains(operation.RequestType.Namespace)) continue; var opType = new MetadataOperationType { Actions = operation.Actions, Request = ToType(operation.RequestType), Response = ToType(operation.ResponseType), }; metadata.Operations.Add(opType); opTypes.Add(operation.RequestType); if (operation.ResponseType != null) { if (skipTypes.Contains(operation.ResponseType)) { //Config.IgnoreTypesInNamespaces in CSharpGenerator opType.Response = null; } else { opTypes.Add(operation.ResponseType); } } } var considered = new HashSet<Type>(opTypes); var queue = new Queue<Type>(opTypes); Func<Type, bool> ignoreTypeFn = t => t == null || t.IsGenericParameter || t == typeof(Enum) || considered.Contains(t) || skipTypes.Contains(t) || (ignoreNamespaces.Contains(t.Namespace) && !exportTypes.Contains(t)); Action<Type> registerTypeFn = null; registerTypeFn = t => { if (t.IsArray || t == typeof(Array)) return; considered.Add(t); queue.Enqueue(t); if ((!(t.IsSystemType() && !t.IsTuple()) && (t.IsClass() || t.IsEnum() || t.IsInterface()) && !t.IsGenericParameter) || exportTypes.Contains(t)) { metadata.Types.Add(ToType(t)); foreach (var ns in GetNamespacesUsed(t)) { if (!metadata.Namespaces.Contains(ns)) metadata.Namespaces.Add(ns); } } }; while (queue.Count > 0) { var type = queue.Dequeue(); if (IsSystemCollection(type)) { type = type.GetCollectionType(); if (type != null && !ignoreTypeFn(type)) registerTypeFn(type); continue; } if (type.DeclaringType != null) { if (!ignoreTypeFn(type.DeclaringType)) registerTypeFn(type.DeclaringType); } if (type.HasInterface(typeof(IService)) && type.GetNestedTypes(BindingFlags.Public | BindingFlags.Instance).IsEmpty()) continue; if (!type.IsUserType() && !type.IsInterface() && !exportTypes.Contains(type)) continue; if (!type.HasInterface(typeof(IService))) { foreach (var pi in type.GetSerializableProperties() .Where(pi => !ignoreTypeFn(pi.PropertyType))) { registerTypeFn(pi.PropertyType); //Register Property Array Element Types if (pi.PropertyType.IsArray && !ignoreTypeFn(pi.PropertyType.GetElementType())) { registerTypeFn(pi.PropertyType.GetElementType()); } //Register Property Generic Arg Types if (!pi.PropertyType.IsGenericType()) continue; var propArgs = pi.PropertyType.GetGenericArguments(); foreach (var arg in propArgs.Where(arg => !ignoreTypeFn(arg))) { registerTypeFn(arg); } } } var genericBaseTypeDef = type.BaseType() != null && type.BaseType().IsGenericType() ? type.BaseType().GetGenericTypeDefinition() : null; if (!ignoreTypeFn(type.BaseType()) || genericBaseTypeDef == typeof(QueryBase<,>) || genericBaseTypeDef == typeof(QueryDb<,>) || genericBaseTypeDef == typeof(QueryData<,>)) { if (genericBaseTypeDef != null) { if (!ignoreTypeFn(genericBaseTypeDef)) registerTypeFn(genericBaseTypeDef); foreach (var arg in type.BaseType().GetGenericArguments() .Where(arg => !ignoreTypeFn(arg))) { registerTypeFn(arg); } } else { registerTypeFn(type.BaseType()); } } if (!type.IsGenericType()) continue; //Register Generic Arg Types var args = type.GetGenericArguments(); foreach (var arg in args.Where(arg => !ignoreTypeFn(arg))) { registerTypeFn(arg); } } return metadata; }
internal bool Generate_MetadataReport(MetadataTypes metadataType, string filterNIds, string outputFolder) { bool RetVal; string Query, ColumnName, TargetObjectId, FileName; GenericMetadataType Metadata; DataTable DtTable; RetVal = false; Query = string.Empty; ColumnName = string.Empty; TargetObjectId = string.Empty; FileName = string.Empty; Metadata = null; DtTable = null; try { switch (metadataType) { case MetadataTypes.Area: Query = "SELECT Area_ID FROM UT_Area_" + this._language; if (!string.IsNullOrEmpty(filterNIds)) { Query += " WHERE Area_NId IN (" + filterNIds + ");"; } ColumnName = "Area_ID"; break; case MetadataTypes.Indicator: Query = "SELECT Indicator_GId FROM UT_Indicator_" + this._language; if (!string.IsNullOrEmpty(filterNIds)) { Query += " WHERE Indicator_NId IN (" + filterNIds + ");"; } ColumnName = "Indicator_GId"; break; case MetadataTypes.Source: Query = "SELECT IC_GId FROM UT_Indicator_Classifications_" + this._language + " WHERE IC_Type = 'SR'"; if (!string.IsNullOrEmpty(filterNIds)) { Query += " AND IC_NId IN (" + filterNIds + ");"; } ColumnName = "IC_GId"; break; default: break; } DtTable = this._diConnection.ExecuteDataTable(Regex.Replace(Query, "UT_", this._diConnection.DIDataSetDefault(), RegexOptions.IgnoreCase)); foreach (DataRow DrTable in DtTable.Rows) { TargetObjectId = DrTable[ColumnName].ToString(); Metadata = this.Retrieve_Metadata_From_Database(metadataType, TargetObjectId,null); if (Metadata != null) { FileName = Path.Combine(outputFolder, TargetObjectId + Constants.XmlExtension); Serializer.SerializeToFile(typeof(SDMXObjectModel.Message.GenericMetadataType), Metadata, FileName); } } RetVal = true; } catch (Exception ex) { throw ex; } finally { } return RetVal; }
private GenericMetadataType Retrieve_Metadata_From_Database(MetadataTypes metadataType, string TargetObjectId,SDMXObjectModel.Message.StructureHeaderType Header) { GenericMetadataType RetVal; string StructureRef, ReportStructureId, MetadataTargetId, IdentifiableObjectTargetId, MaintenableParentId, MaintenableParentVersion; ObjectTypeCodelistType TargetObjectType; PackageTypeCodelistType TargetPackageType; RetVal = null; StructureRef = string.Empty; ReportStructureId = string.Empty; MetadataTargetId = string.Empty; IdentifiableObjectTargetId = string.Empty; MaintenableParentId = string.Empty; MaintenableParentVersion = string.Empty; TargetObjectType = ObjectTypeCodelistType.Code; TargetPackageType = PackageTypeCodelistType.codelist; try { switch (metadataType) { case MetadataTypes.Area: StructureRef = Constants.MSD.Area.Id; ReportStructureId = Constants.MSD.Area.ReportStructureId; MetadataTargetId = Constants.MSD.Area.MetadataTargetId; IdentifiableObjectTargetId = Constants.MSD.Area.IdentifiableObjectTargetId; MaintenableParentId = Constants.CodeList.Area.Id; MaintenableParentVersion = Constants.CodeList.Area.Version; TargetObjectType = ObjectTypeCodelistType.Code; TargetPackageType = PackageTypeCodelistType.codelist; break; case MetadataTypes.Indicator: StructureRef = Constants.MSD.Indicator.Id; ReportStructureId = Constants.MSD.Indicator.ReportStructureId; MetadataTargetId = Constants.MSD.Indicator.MetadataTargetId; IdentifiableObjectTargetId = Constants.MSD.Indicator.IdentifiableObjectTargetId; MaintenableParentId = Constants.CodeList.Indicator.Id; MaintenableParentVersion = Constants.CodeList.Indicator.Version; TargetObjectType = ObjectTypeCodelistType.Code; TargetPackageType = PackageTypeCodelistType.codelist; break; case MetadataTypes.Source: StructureRef = Constants.MSD.Source.Id; ReportStructureId = Constants.MSD.Source.ReportStructureId; MetadataTargetId = Constants.MSD.Source.MetadataTargetId; IdentifiableObjectTargetId = Constants.MSD.Source.IdentifiableObjectTargetId; MaintenableParentId = Constants.CategoryScheme.Source.Id; MaintenableParentVersion = Constants.CategoryScheme.Source.Version; TargetObjectType = ObjectTypeCodelistType.Category; TargetPackageType = PackageTypeCodelistType.categoryscheme; break; case MetadataTypes.Layer: StructureRef = Constants.MSD.Area.Id; ReportStructureId = Constants.MSD.Area.ReportStructureId; MetadataTargetId = Constants.MSD.Area.MetadataTargetId; IdentifiableObjectTargetId = Constants.MSD.Area.IdentifiableObjectTargetId; MaintenableParentId = Constants.CodeList.Area.Id; MaintenableParentVersion = Constants.CodeList.Area.Version; TargetObjectType = ObjectTypeCodelistType.Code; TargetPackageType = PackageTypeCodelistType.codelist; break; default: break; } RetVal = new GenericMetadataType(); if (Header != null) { RetVal.Header.ID = Header.ID; RetVal.Header.Name = Header.Name; RetVal.Header.Receiver = Header.Receiver; RetVal.Header.Sender = Header.Sender; RetVal.Header.Test = Header.Test; RetVal.Header.Source = Header.Source; RetVal.Header.Prepared = Header.Prepared; } else { RetVal.Header = this.Get_Appropriate_Header(metadataType); } RetVal.Footer = null; RetVal.MetadataSet = new List<SDMXObjectModel.Metadata.Generic.MetadataSetType>(); RetVal.MetadataSet.Add(new SDMXObjectModel.Metadata.Generic.MetadataSetType()); RetVal.MetadataSet[0].structureRef = StructureRef; RetVal.MetadataSet[0].Annotations = null; RetVal.MetadataSet[0].DataProvider = null; RetVal.MetadataSet[0].Report = new List<SDMXObjectModel.Metadata.Generic.ReportType>(); RetVal.MetadataSet[0].Report.Add(new SDMXObjectModel.Metadata.Generic.ReportType()); RetVal.MetadataSet[0].Report[0].id = ReportStructureId; RetVal.MetadataSet[0].Report[0].Annotations = null; RetVal.MetadataSet[0].Report[0].Target = new SDMXObjectModel.Metadata.Generic.TargetType(); RetVal.MetadataSet[0].Report[0].Target.id = MetadataTargetId; RetVal.MetadataSet[0].Report[0].Target.ReferenceValue = new List<SDMXObjectModel.Metadata.Generic.ReferenceValueType>(); RetVal.MetadataSet[0].Report[0].Target.ReferenceValue.Add(new SDMXObjectModel.Metadata.Generic.ReferenceValueType()); RetVal.MetadataSet[0].Report[0].Target.ReferenceValue[0].id = IdentifiableObjectTargetId; RetVal.MetadataSet[0].Report[0].Target.ReferenceValue[0].Item = new ObjectReferenceType(); ((ObjectReferenceType)RetVal.MetadataSet[0].Report[0].Target.ReferenceValue[0].Item).Items = new List<object>(); ((ObjectReferenceType)RetVal.MetadataSet[0].Report[0].Target.ReferenceValue[0].Item).Items.Add(new ObjectRefType(TargetObjectId, this._agencyId, null, MaintenableParentId, MaintenableParentVersion, TargetObjectType, true, TargetPackageType, true)); RetVal.MetadataSet[0].Report[0].AttributeSet = this.Get_AttributeSet(metadataType); if (RetVal.MetadataSet[0].Report[0].AttributeSet != null && RetVal.MetadataSet[0].Report[0].AttributeSet.ReportedAttribute != null && RetVal.MetadataSet[0].Report[0].AttributeSet.ReportedAttribute.Count > 0) { this.Fill_AttributeSet_Values(RetVal.MetadataSet[0].Report[0].AttributeSet, TargetObjectId, metadataType); } } catch (Exception ex) { throw ex; } finally { } return RetVal; }
public override Task ProcessRequestAsync(IRequest httpReq, IResponse httpRes, string operationName) { var metadata = new MetadataTypes { Config = Config, }; var existingTypes = new HashSet<Type> { typeof(ResponseStatus), typeof(ErrorResponse), }; var meta = HostContext.Metadata; foreach (var operation in meta.Operations) { if (!meta.IsVisible(httpReq, operation)) continue; metadata.Operations.Add(new MetadataOperationType { Actions = operation.Actions, Request = operation.RequestType.ToType(), Response = operation.ResponseType.ToType(), }); existingTypes.Add(operation.RequestType); if (operation.ResponseType != null) { existingTypes.Add(operation.ResponseType); } } foreach (var type in meta.GetAllTypes()) { if (existingTypes.Contains(type)) continue; metadata.Operations.Add(new MetadataOperationType { Request = type.ToType(), }); existingTypes.Add(type); } var considered = new HashSet<Type>(existingTypes); var queue = new Queue<Type>(existingTypes); while (queue.Count > 0) { var type = queue.Dequeue(); foreach (var pi in type.GetSerializableProperties()) { if (pi.PropertyType.IsUserType()) { if (considered.Contains(pi.PropertyType)) continue; considered.Add(pi.PropertyType); queue.Enqueue(pi.PropertyType); metadata.Types.Add(pi.PropertyType.ToType()); } } if (type.BaseType != null && type.BaseType.IsUserType() && !considered.Contains(type.BaseType)) { considered.Add(type.BaseType); queue.Enqueue(type.BaseType); metadata.Types.Add(type.BaseType.ToType()); } } return httpRes.WriteToResponse(httpReq, metadata); }
private AttributeSetType Get_AttributeSet(MetadataTypes metadataTypes) { AttributeSetType RetVal; DataTable DtMetadataCategory; string Query; RetVal = null; DtMetadataCategory = null; Query = string.Empty; try { switch (metadataTypes) { case MetadataTypes.Area: Query = "SELECT * FROM UT_Metadata_Category_" + this._language + " WHERE CategoryType = 'A' ORDER BY CategoryOrder ASC;"; break; case MetadataTypes.Indicator: Query = "SELECT * FROM UT_Metadata_Category_" + this._language + " WHERE CategoryType = 'I' ORDER BY CategoryOrder ASC;"; break; case MetadataTypes.Source: Query = "SELECT * FROM UT_Metadata_Category_" + this._language + " WHERE CategoryType = 'S' ORDER BY CategoryOrder ASC;"; break; case MetadataTypes.Layer: Query = "SELECT * FROM UT_Metadata_Category_" + this._language + " WHERE CategoryType = 'A' ORDER BY CategoryOrder ASC;"; break; default: break; } DtMetadataCategory = this._diConnection.ExecuteDataTable(Regex.Replace(Query, "UT_", this._diConnection.DIDataSetDefault(), RegexOptions.IgnoreCase)); if (DtMetadataCategory != null && DtMetadataCategory.Rows.Count > 0) { RetVal = new AttributeSetType(); this.Fill_AttributeSet_Structure(RetVal, DtMetadataCategory); } } catch (Exception ex) { throw ex; } finally { } return RetVal; }
private string Get_TargetNId(string TargetObjectId, MetadataTypes metadataTypes, string Language) { string RetVal; string Query, AreaNId; DataTable DtTable; RetVal = string.Empty; Query = string.Empty; AreaNId = string.Empty; DtTable = null; try { switch (metadataTypes) { case MetadataTypes.Area: Query = "SELECT Area_NId FROM UT_Area_" + Language + " WHERE Area_ID = '" + TargetObjectId + "'"; DtTable = this._diConnection.ExecuteDataTable(Regex.Replace(Query, "UT_", this._diConnection.DIDataSetDefault(), RegexOptions.IgnoreCase)); if (DtTable != null && DtTable.Rows.Count > 0) { AreaNId = DtTable.Rows[0]["Area_NId"].ToString(); Query = "SELECT Layer_NId FROM UT_Area_Map WHERE Area_NId = " + AreaNId.ToString(); DtTable = this._diConnection.ExecuteDataTable(Regex.Replace(Query, "UT_", this._diConnection.DIDataSetDefault(), RegexOptions.IgnoreCase)); if (DtTable != null && DtTable.Rows.Count > 0) { RetVal = DtTable.Rows[0]["Layer_NId"].ToString(); } } break; case MetadataTypes.Indicator: Query = "SELECT Indicator_NId FROM UT_Indicator_" + Language + " WHERE Indicator_GId = '" + TargetObjectId + "';"; DtTable = this._diConnection.ExecuteDataTable(Regex.Replace(Query, "UT_", this._diConnection.DIDataSetDefault(), RegexOptions.IgnoreCase)); if (DtTable != null && DtTable.Rows.Count > 0) { RetVal = DtTable.Rows[0]["Indicator_NId"].ToString(); } break; case MetadataTypes.Source: Query = "SELECT IC_NId FROM UT_Indicator_Classifications_" + Language + " WHERE IC_GId = '" + TargetObjectId + "' AND IC_Type = 'SR';"; DtTable = this._diConnection.ExecuteDataTable(Regex.Replace(Query, "UT_", this._diConnection.DIDataSetDefault(), RegexOptions.IgnoreCase)); if (DtTable != null && DtTable.Rows.Count > 0) { RetVal = DtTable.Rows[0]["IC_NId"].ToString(); } break; case MetadataTypes.Layer: RetVal = TargetObjectId; break; default: break; } } catch (Exception ex) { throw ex; } finally { } return RetVal; }
private void Fill_AttributeSet_Values(AttributeSetType AttributeSet, string TargetObjectId, MetadataTypes metadataType) { string Language; Language = string.Empty; try { this.Fill_AttributeSet_Language_Specific_Values(AttributeSet, TargetObjectId, metadataType, this._language); if (this._multiLanguageHandlingRequired == true) { foreach (DataRow LanguageRow in this.DIConnection.DILanguages(this.DIQueries.DataPrefix).Rows) { Language = LanguageRow[DevInfo.Lib.DI_LibDAL.Queries.DIColumns.Language.LanguageCode].ToString(); if (Language != this.DIQueries.LanguageCode.Substring(1)) { this.Fill_AttributeSet_Language_Specific_Values(AttributeSet, TargetObjectId, metadataType, Language); } } } } catch (Exception ex) { throw ex; } finally { } }
private void Fill_AttributeSet_Language_Specific_Values(AttributeSetType AttributeSet, string TargetObjectId, MetadataTypes metadataType, string Language) { string Query; string TargetNId; List<string> CategoryGIds, CategoryNIds; Dictionary<string, string> DictCategoryNIdGId, DictCategoryGIdValue,DictCategoryPresentational; DataTable DtMetadataCategory, DtMetadataReport; Query = string.Empty; TargetNId = string.Empty; CategoryGIds = null; CategoryNIds = null; DictCategoryNIdGId = null; DictCategoryGIdValue = null; DtMetadataCategory = null; DtMetadataReport = null; try { TargetNId = this.Get_TargetNId(TargetObjectId, metadataType, Language); if (!string.IsNullOrEmpty(TargetNId)) { CategoryGIds = new List<string>(); CategoryNIds = new List<string>(); DictCategoryNIdGId = new Dictionary<string, string>(); DictCategoryGIdValue = new Dictionary<string, string>(); DictCategoryPresentational = new Dictionary<string, string>(); foreach (ReportedAttributeType ReportedAttribute in AttributeSet.ReportedAttribute) { CategoryGIds.Add(ReportedAttribute.id); CategoryGIds.AddRange(this.Get_ChildAttribute_CategoryGIds(ReportedAttribute)); } Query = "SELECT * FROM UT_Metadata_Category_" + Language; if (CategoryGIds.Count > 0) { Query += " WHERE CategoryGId IN ('" + string.Join("','", CategoryGIds.ToArray()) + "');"; } DtMetadataCategory = this._diConnection.ExecuteDataTable(Regex.Replace(Query, "UT_", this._diConnection.DIDataSetDefault(), RegexOptions.IgnoreCase)); foreach (DataRow DrMetadataCategory in DtMetadataCategory.Rows) { CategoryNIds.Add(DrMetadataCategory["CategoryNId"].ToString()); DictCategoryNIdGId.Add(DrMetadataCategory["CategoryNId"].ToString(), DrMetadataCategory["CategoryGId"].ToString()); if (DrMetadataCategory["IsPresentational"].ToString() == "True") { DictCategoryPresentational.Add(DrMetadataCategory["CategoryNId"].ToString(), DrMetadataCategory["CategoryGId"].ToString()); } } Query = "SELECT * FROM UT_MetadataReport_" + Language + " WHERE Target_NId = " + TargetNId; if (CategoryNIds.Count > 0) { Query += " AND Category_NId IN (" + string.Join(",", CategoryNIds.ToArray()) + ");";//commented to add those rows which doesnt have metadata for metadata category } DtMetadataReport = this._diConnection.ExecuteDataTable(Regex.Replace(Query, "UT_", this._diConnection.DIDataSetDefault(), RegexOptions.IgnoreCase)); foreach (DataRow DrMetadataReport in DtMetadataReport.Rows) { DictCategoryGIdValue.Add(DictCategoryNIdGId[DrMetadataReport["Category_NId"].ToString()], DrMetadataReport["Metadata"].ToString()); } foreach (ReportedAttributeType ReportedAttribute in AttributeSet.ReportedAttribute) { if (ReportedAttribute.Items == null) { ReportedAttribute.Items = new List<object>(); } else if (ReportedAttribute.Items.Count == 0) { ReportedAttribute.Items = new List<object>(); } if (DictCategoryGIdValue.ContainsKey(ReportedAttribute.id)) { ReportedAttribute.Items.Add(new TextType(Language, DictCategoryGIdValue[ReportedAttribute.id])); } else if (DictCategoryPresentational.ContainsValue(ReportedAttribute.id)==false && DictCategoryGIdValue.ContainsKey(ReportedAttribute.id) == false && DictCategoryPresentational.Count>0) { ReportedAttribute.Items.Add(new TextType(Language, string.Empty));//to add empty tag where metadata category doesnt have any description or report } this.Fill_Children_Attribute_Values(ReportedAttribute, DictCategoryGIdValue, Language); } } } catch (Exception ex) { throw ex; } finally { } }
internal XmlDocument Get_MetadataReport(string TargetObjectId, MetadataTypes metadataType) { XmlDocument RetVal; SDMXObjectModel.Message.GenericMetadataType Metadata; RetVal = null; Metadata = null; try { if (!string.IsNullOrEmpty(TargetObjectId)) { Metadata = this.Retrieve_Metadata_From_Database(metadataType, TargetObjectId,null); } if (Metadata != null) { RetVal = Serializer.SerializeToXmlDocument(typeof(SDMXObjectModel.Message.GenericMetadataType), Metadata); } else { RetVal = new XmlDocument(); } } catch (Exception ex) { throw ex; } finally { } return RetVal; }
public string GetCode(MetadataTypes metadata, IRequest request) { var namespaces = Config.GetDefaultNamespaces(metadata); var typeNamespaces = new HashSet<string>(); metadata.RemoveIgnoredTypesForNet(Config); metadata.Types.Each(x => typeNamespaces.Add(x.Namespace)); metadata.Operations.Each(x => typeNamespaces.Add(x.Request.Namespace)); // Look first for shortest Namespace ending with `ServiceModel` convention, else shortest ns var globalNamespace = Config.GlobalNamespace ?? typeNamespaces.Where(x => x.EndsWith("ServiceModel")) .OrderBy(x => x).FirstOrDefault() ?? typeNamespaces.OrderBy(x => x).First(); Func<string, string> defaultValue = k => request.QueryString[k].IsNullOrEmpty() ? "//" : ""; var sb = new StringBuilderWrapper(new StringBuilder()); sb.AppendLine("(* Options:"); sb.AppendLine("Date: {0}".Fmt(DateTime.Now.ToString("s").Replace("T", " "))); sb.AppendLine("Version: {0}".Fmt(Env.ServiceStackVersion)); sb.AppendLine("Tip: {0}".Fmt(HelpMessages.NativeTypesDtoOptionsTip.Fmt("//"))); sb.AppendLine("BaseUrl: {0}".Fmt(Config.BaseUrl)); sb.AppendLine(); sb.AppendLine("{0}GlobalNamespace: {1}".Fmt(defaultValue("GlobalNamespace"), Config.GlobalNamespace)); sb.AppendLine("{0}MakeDataContractsExtensible: {1}".Fmt(defaultValue("MakeDataContractsExtensible"), Config.MakeDataContractsExtensible)); sb.AppendLine("{0}AddReturnMarker: {1}".Fmt(defaultValue("AddReturnMarker"), Config.AddReturnMarker)); sb.AppendLine("{0}AddDescriptionAsComments: {1}".Fmt(defaultValue("AddDescriptionAsComments"), Config.AddDescriptionAsComments)); sb.AppendLine("{0}AddDataContractAttributes: {1}".Fmt(defaultValue("AddDataContractAttributes"), Config.AddDataContractAttributes)); sb.AppendLine("{0}AddIndexesToDataMembers: {1}".Fmt(defaultValue("AddIndexesToDataMembers"), Config.AddIndexesToDataMembers)); sb.AppendLine("{0}AddGeneratedCodeAttributes: {1}".Fmt(defaultValue("AddGeneratedCodeAttributes"), Config.AddGeneratedCodeAttributes)); sb.AppendLine("{0}AddResponseStatus: {1}".Fmt(defaultValue("AddResponseStatus"), Config.AddResponseStatus)); sb.AppendLine("{0}AddImplicitVersion: {1}".Fmt(defaultValue("AddImplicitVersion"), Config.AddImplicitVersion)); sb.AppendLine("{0}IncludeTypes: {1}".Fmt(defaultValue("IncludeTypes"), Config.IncludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}ExcludeTypes: {1}".Fmt(defaultValue("ExcludeTypes"), Config.ExcludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}InitializeCollections: {1}".Fmt(defaultValue("InitializeCollections"), Config.InitializeCollections)); //sb.AppendLine("{0}AddDefaultXmlNamespace: {1}".Fmt(defaultValue("AddDefaultXmlNamespace"), Config.AddDefaultXmlNamespace)); //sb.AppendLine("{0}DefaultNamespaces: {1}".Fmt(defaultValue("DefaultNamespaces"), Config.DefaultNamespaces.ToArray().Join(", "))); sb.AppendLine("*)"); sb.AppendLine(); string lastNS = null; var existingTypes = new HashSet<string>(); var requestTypes = metadata.Operations.Select(x => x.Request).ToHashSet(); var requestTypesMap = metadata.Operations.ToSafeDictionary(x => x.Request); var responseTypes = metadata.Operations .Where(x => x.Response != null) .Select(x => x.Response).ToHashSet(); var types = metadata.Types.ToHashSet(); var allTypes = new List<MetadataType>(); allTypes.AddRange(types); allTypes.AddRange(responseTypes); allTypes.AddRange(requestTypes); var orderedTypes = allTypes.OrderTypesByDeps(); sb.AppendLine("namespace {0}".Fmt(globalNamespace.SafeToken())); sb.AppendLine(); foreach (var ns in namespaces.Where(x => !string.IsNullOrEmpty(x))) { sb.AppendLine("open " + ns); } if (Config.AddGeneratedCodeAttributes) sb.AppendLine("open System.CodeDom.Compiler"); foreach (var type in orderedTypes) { var fullTypeName = type.GetFullName(); if (requestTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName)) { MetadataType response = null; MetadataOperationType operation; if (requestTypesMap.TryGetValue(type, out operation)) { response = operation.Response; } lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { ImplementsFn = () => { if (!Config.AddReturnMarker && !type.ReturnVoidMarker && type.ReturnMarkerTypeName == null) return null; if (type.ReturnVoidMarker) return "IReturnVoid"; if (type.ReturnMarkerTypeName != null) return Type("IReturn`1", new[] { Type(type.ReturnMarkerTypeName) }); return response != null ? Type("IReturn`1", new[] { Type(response.Name, response.GenericArgs) }) : null; }, IsRequest = true, }); existingTypes.Add(fullTypeName); } } else if (responseTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName) && !Config.IgnoreTypesInNamespaces.Contains(type.Namespace)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsResponse = true, }); existingTypes.Add(fullTypeName); } } else if (types.Contains(type) && !existingTypes.Contains(fullTypeName)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsType = true }); existingTypes.Add(fullTypeName); } } sb.AppendLine(); return sb.ToString(); }
static MetadataType FindMetadataType(MetadataTypes metadataTypes, Type type) { return type == null ? null : FindMetadataType(metadataTypes, type.Name, type.Namespace); }
public static string GetCode(MetadataTypes metadata, string defaultBaseUrl = null) { Config = metadata.Config; var namespaces = new HashSet<string>(); Config.DefaultNamespaces.Each(x => namespaces.Add(x)); metadata.Types.Each(x => namespaces.Add(x.Namespace)); metadata.Operations.Each(x => namespaces.Add(x.Request.Namespace)); const bool flag = false; Config.AddReturnMarker = flag; Config.MakeVirtual = Config.MakePartial = flag; Config.AddDescriptionAsComments = flag; Config.AddDefaultXmlNamespace = "http://schemas.servicestack.net/dtogen-types"; Config.AddDataContractAttributes = flag; Config.MakeDataContractsExtensible = flag; Config.AddIndexesToDataMembers = flag; Config.InitializeCollections = flag; Config.AddResponseStatus = flag; Config.AddImplicitVersion = null; var sb = new StringBuilderWrapper(new StringBuilder()); sb.AppendLine("/* Options:"); sb.AppendLine("Version: {0}".Fmt(Version)); sb.AppendLine("BaseUrl: {0}".Fmt(Config.BaseUrl ?? defaultBaseUrl)); sb.AppendLine(); sb.AppendLine("ServerVersion: {0}".Fmt(metadata.Version)); sb.AppendLine("MakePartial: {0}".Fmt(Config.MakePartial)); sb.AppendLine("MakeVirtual: {0}".Fmt(Config.MakeVirtual)); sb.AppendLine("AddReturnMarker: {0}".Fmt(Config.AddReturnMarker)); sb.AppendLine("AddDescriptionAsComments: {0}".Fmt(Config.AddDescriptionAsComments)); sb.AppendLine("AddDataContractAttributes: {0}".Fmt(Config.AddDataContractAttributes)); sb.AppendLine("AddDefaultXmlNamespace: {0}".Fmt(Config.AddDefaultXmlNamespace)); sb.AppendLine("MakeDataContractsExtensible: {0}".Fmt(Config.MakeDataContractsExtensible)); sb.AppendLine("AddIndexesToDataMembers: {0}".Fmt(Config.AddIndexesToDataMembers)); sb.AppendLine("InitializeCollections: {0}".Fmt(Config.InitializeCollections)); sb.AppendLine("AddResponseStatus: {0}".Fmt(Config.AddResponseStatus)); sb.AppendLine("AddImplicitVersion: {0}".Fmt(Config.AddImplicitVersion)); sb.AppendLine("DefaultNamespaces: {0}".Fmt(Config.DefaultNamespaces.ToArray().Join(", "))); sb.AppendLine("*/"); sb.AppendLine(); namespaces.ToList().ForEach(x => sb.AppendLine("using {0};".Fmt(x))); if (Config.AddDataContractAttributes && Config.AddDefaultXmlNamespace != null) { sb.AppendLine(); namespaces.Where(x => !Config.DefaultNamespaces.Contains(x)).ToList() .ForEach(x => sb.AppendLine("[assembly: ContractNamespace(\"{0}\", ClrNamespace=\"{1}\")]" .Fmt(Config.AddDefaultXmlNamespace, x))); } sb.AppendLine(); string lastNS = null; sb.AppendLine("#region Operations"); sb.AppendLine(); foreach (var operation in metadata.Operations .OrderBy(x => x.Request.Namespace) .OrderBy(x => x.Request.Name)) { var request = operation.Request; var response = operation.Response; lastNS = AppendType(ref sb, request, lastNS, new CreateTypeOptions { ImplementsFn = () => { if (!Config.AddReturnMarker && !request.ReturnVoidMarker && request.ReturnMarkerGenericArgs == null) return null; if (request.ReturnVoidMarker) return "IReturnVoid"; if (request.ReturnMarkerGenericArgs != null) return Type("IReturn`1", request.ReturnMarkerGenericArgs); return response != null ? Type("IReturn`1", new[] { response.Name }) : null; }, IsRequest = true, }); lastNS = AppendType(ref sb, operation.Response, lastNS, new CreateTypeOptions { IsResponse = true, }); } if (lastNS != null) sb.AppendLine("}"); sb.AppendLine(); sb.AppendLine("#endregion"); sb.AppendLine(); sb.AppendLine(); lastNS = null; sb.AppendLine("#region Types"); sb.AppendLine(); foreach (var type in metadata.Types .OrderBy(x => x.Namespace) .OrderBy(x => x.Name)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsType = true }); } if (lastNS != null) sb.AppendLine("}"); sb.AppendLine(); sb.AppendLine("#endregion"); return sb.ToString(); }
public string GetCode(MetadataTypes metadata, IRequest request) { var namespaces = Config.GetDefaultNamespaces(metadata); var typeNamespaces = new HashSet <string>(); metadata.RemoveIgnoredTypesForNet(Config); metadata.Types.Each(x => typeNamespaces.Add(x.Namespace)); metadata.Operations.Each(x => { typeNamespaces.Add(x.Request.Namespace); if (x.Response != null) { typeNamespaces.Add(x.Response.Namespace); } }); // Look first for shortest Namespace ending with `ServiceModel` convention, else shortest ns var globalNamespace = Config.GlobalNamespace ?? typeNamespaces.Where(x => x.EndsWith("ServiceModel")) .OrderBy(x => x).FirstOrDefault() ?? typeNamespaces.OrderBy(x => x).First(); Func <string, string> defaultValue = k => request.QueryString[k].IsNullOrEmpty() ? "//" : ""; var sbInner = new StringBuilder(); var sb = new StringBuilderWrapper(sbInner); sb.AppendLine("(* Options:"); sb.AppendLine("Date: {0}".Fmt(DateTime.Now.ToString("s").Replace("T", " "))); sb.AppendLine("Version: {0}".Fmt(Env.VersionString)); sb.AppendLine("Tip: {0}".Fmt(HelpMessages.NativeTypesDtoOptionsTip.Fmt("//"))); sb.AppendLine("BaseUrl: {0}".Fmt(Config.BaseUrl)); if (Config.UsePath != null) { sb.AppendLine("UsePath: {0}".Fmt(Config.UsePath)); } sb.AppendLine(); sb.AppendLine("{0}GlobalNamespace: {1}".Fmt(defaultValue("GlobalNamespace"), Config.GlobalNamespace)); sb.AppendLine("{0}MakeDataContractsExtensible: {1}".Fmt(defaultValue("MakeDataContractsExtensible"), Config.MakeDataContractsExtensible)); sb.AppendLine("{0}AddReturnMarker: {1}".Fmt(defaultValue("AddReturnMarker"), Config.AddReturnMarker)); sb.AppendLine("{0}AddDescriptionAsComments: {1}".Fmt(defaultValue("AddDescriptionAsComments"), Config.AddDescriptionAsComments)); sb.AppendLine("{0}AddDataContractAttributes: {1}".Fmt(defaultValue("AddDataContractAttributes"), Config.AddDataContractAttributes)); sb.AppendLine("{0}AddIndexesToDataMembers: {1}".Fmt(defaultValue("AddIndexesToDataMembers"), Config.AddIndexesToDataMembers)); sb.AppendLine("{0}AddGeneratedCodeAttributes: {1}".Fmt(defaultValue("AddGeneratedCodeAttributes"), Config.AddGeneratedCodeAttributes)); sb.AppendLine("{0}AddResponseStatus: {1}".Fmt(defaultValue("AddResponseStatus"), Config.AddResponseStatus)); sb.AppendLine("{0}AddImplicitVersion: {1}".Fmt(defaultValue("AddImplicitVersion"), Config.AddImplicitVersion)); sb.AppendLine("{0}ExportValueTypes: {1}".Fmt(defaultValue("ExportValueTypes"), Config.ExportValueTypes)); sb.AppendLine("{0}IncludeTypes: {1}".Fmt(defaultValue("IncludeTypes"), Config.IncludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}ExcludeTypes: {1}".Fmt(defaultValue("ExcludeTypes"), Config.ExcludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}InitializeCollections: {1}".Fmt(defaultValue("InitializeCollections"), Config.InitializeCollections)); //sb.AppendLine("{0}AddDefaultXmlNamespace: {1}".Fmt(defaultValue("AddDefaultXmlNamespace"), Config.AddDefaultXmlNamespace)); sb.AppendLine("{0}AddNamespaces: {1}".Fmt(defaultValue("AddNamespaces"), Config.AddNamespaces.Safe().ToArray().Join(","))); sb.AppendLine("*)"); sb.AppendLine(); string lastNS = null; var existingTypes = new HashSet <string>(); var requestTypes = metadata.Operations.Select(x => x.Request).ToHashSet(); var requestTypesMap = metadata.Operations.ToSafeDictionary(x => x.Request); var responseTypes = metadata.Operations .Where(x => x.Response != null) .Select(x => x.Response).ToHashSet(); var types = metadata.Types.ToHashSet(); allTypes = new List <MetadataType>(); allTypes.AddRange(types); allTypes.AddRange(responseTypes); allTypes.AddRange(requestTypes); var orderedTypes = FilterTypes(allTypes); sb.AppendLine("namespace {0}".Fmt(globalNamespace.SafeToken())); sb.AppendLine(); foreach (var ns in namespaces.Where(x => !string.IsNullOrEmpty(x))) { sb.AppendLine("open " + ns); } if (Config.AddGeneratedCodeAttributes) { sb.AppendLine("open System.CodeDom.Compiler"); } var insertCode = InsertCodeFilter?.Invoke(allTypes, Config); if (insertCode != null) { sb.AppendLine(insertCode); } foreach (var type in orderedTypes) { var fullTypeName = type.GetFullName(); if (requestTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName)) { MetadataType response = null; MetadataOperationType operation; if (requestTypesMap.TryGetValue(type, out operation)) { response = operation.Response; } lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { ImplementsFn = () => { if (!Config.AddReturnMarker && !type.ReturnVoidMarker && type.ReturnMarkerTypeName == null) { return(null); } if (type.ReturnVoidMarker) { return("IReturnVoid"); } if (type.ReturnMarkerTypeName != null) { return(Type("IReturn`1", new[] { Type(type.ReturnMarkerTypeName) })); } return(response != null ? Type("IReturn`1", new[] { Type(response.Name, response.GenericArgs) }) : null); }, IsRequest = true, }); existingTypes.Add(fullTypeName); } } else if (responseTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName) && !Config.IgnoreTypesInNamespaces.Contains(type.Namespace)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsResponse = true, }); existingTypes.Add(fullTypeName); } } else if (types.Contains(type) && !existingTypes.Contains(fullTypeName)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsType = true }); existingTypes.Add(fullTypeName); } } var addCode = AddCodeFilter?.Invoke(allTypes, Config); if (addCode != null) { sb.AppendLine(addCode); } sb.AppendLine(); return(StringBuilderCache.ReturnAndFree(sbInner)); }
public static List<string> GetIncludeList(MetadataTypes metadata, MetadataTypesConfig config) { const string wildCard = ".*"; if (config.IncludeTypes == null) return null; var typesToExpand = config.IncludeTypes .Where(s => s.Length > 2 && s.EndsWith(wildCard)) .Map(s => s.Substring(0, s.Length - 2)); if (typesToExpand.Count == 0) return config.IncludeTypes; // From IncludeTypes get the corresponding MetadataTypes var includedMetadataTypes = metadata.Operations .Select(o => o.Request) .Where(t => typesToExpand.Contains(t.Name)) .ToList(); var includeSet = includedMetadataTypes .Where(x => x.ReturnMarkerTypeName != null) .Select(x => x.ReturnMarkerTypeName.Name) .ToHashSet(); var includedResponses = metadata.Operations .Where(t => typesToExpand.Contains(t.Request.Name) && t.Response != null) .Select(o => o.Response) .ToList(); includedResponses.ForEach(x => includeSet.Add(x.Name)); var returnTypesForInclude = metadata.Operations .Where(x => x.Response != null && includeSet.Contains(x.Response.Name)) .Map(x => x.Response); // GetReferencedTypes for both request + response objects var referenceTypes = includedMetadataTypes .Union(returnTypesForInclude) .Where(x => x != null) .SelectMany(x => x.GetReferencedTypeNames()); return referenceTypes .Union(config.IncludeTypes) .Union(typesToExpand) .Union(returnTypesForInclude.Select(x => x.Name)) .Distinct() .ToList(); }
public void ProcessRequest(IHttpRequest httpReq, IHttpResponse httpRes, string operationName) { var metadata = new MetadataTypes { Config = Config, }; var existingTypes = new HashSet<Type> { typeof(ResponseStatus), typeof(ErrorResponse), }; var meta = EndpointHost.Metadata; foreach (var operation in meta.Operations) { if (!meta.IsVisible(httpReq, operation)) continue; metadata.Operations.Add(new MetadataOperationType { Actions = operation.Actions, Request = operation.RequestType.ToType(), Response = operation.ResponseType.ToType(), }); existingTypes.Add(operation.RequestType); existingTypes.Add(operation.ResponseType); } foreach (var type in meta.GetAllTypes()) { if (existingTypes.Contains(type)) continue; metadata.Operations.Add(new MetadataOperationType { Request = type.ToType(), }); existingTypes.Add(type); } var considered = new HashSet<Type>(existingTypes); var queue = new Queue<Type>(existingTypes); while (queue.Count > 0) { var type = queue.Dequeue(); foreach (var pi in type.GetSerializableProperties()) { if (pi.PropertyType.IsUserType()) { if (considered.Contains(pi.PropertyType)) continue; considered.Add(pi.PropertyType); queue.Enqueue(pi.PropertyType); metadata.Types.Add(pi.PropertyType.ToType()); } } if (type.BaseType != null && type.BaseType.IsUserType() && !considered.Contains(type.BaseType)) { considered.Add(type.BaseType); queue.Enqueue(type.BaseType); metadata.Types.Add(type.BaseType.ToType()); } } httpRes.ContentType = "application/x-ssz-metatypes"; var json = metadata.ToJson(); var encJson = CryptUtils.Encrypt(EndpointHostConfig.PublicKey, json, RsaKeyLengths.Bit2048); httpRes.Write(encJson); }
private static void AddReferencedTypes(MetadataType metadataType, MetadataTypes metadataTypes, List<MetadataType> types) { if (metadataType.Inherits != null) { var type = FindMetadataType(metadataTypes, metadataType.Inherits.Name, metadataType.Inherits.Namespace); if (type != null && !types.Contains(type)) { types.Add(type); AddReferencedTypes(type, metadataTypes, types); } if (!metadataType.Inherits.GenericArgs.IsEmpty()) { foreach (var arg in metadataType.Inherits.GenericArgs) { type = FindMetadataType(metadataTypes, arg); if (type != null && !types.Contains(type)) { types.Add(type); AddReferencedTypes(type, metadataTypes, types); } } } } if (metadataType.Properties != null) { foreach (var p in metadataType.Properties) { var type = FindMetadataType(metadataTypes, p.Type, p.TypeNamespace); if (type != null && !types.Contains(type)) { types.Add(type); AddReferencedTypes(type, metadataTypes, types); } if (!p.GenericArgs.IsEmpty()) { foreach (var arg in p.GenericArgs) { type = FindMetadataType(metadataTypes, arg); if (type != null && !types.Contains(type)) { types.Add(type); AddReferencedTypes(type, metadataTypes, types); } } } else if (p.IsArray()) { var elType = p.Type.SplitOnFirst('[')[0]; type = FindMetadataType(metadataTypes, elType); if (type != null && !types.Contains(type)) { types.Add(type); AddReferencedTypes(type, metadataTypes, types); } } } } }
public SDMXObjectModel.Message.GenericMetadataHeaderType Get_Appropriate_Header(MetadataTypes metadataType) { SDMXObjectModel.Message.GenericMetadataHeaderType RetVal; SenderType Sender; PartyType Receiver; if (this._header == null) { Sender = new SenderType(Constants.Header.SenderId, Constants.Header.SenderName, Constants.DefaultLanguage, new SDMXObjectModel.Message.ContactType(Constants.Header.Sender, Constants.Header.SenderDepartment, Constants.Header.SenderRole, Constants.DefaultLanguage)); Sender.Contact[0].Items = new string[] { Constants.Header.SenderTelephone, Constants.Header.SenderEmail, Constants.Header.SenderFax }; Sender.Contact[0].ItemsElementName = new SDMXObjectModel.Message.ContactChoiceType[] { SDMXObjectModel.Message.ContactChoiceType.Telephone, SDMXObjectModel.Message.ContactChoiceType.Email, SDMXObjectModel.Message.ContactChoiceType.Fax }; Receiver = new PartyType(Constants.Header.ReceiverId, Constants.Header.ReceiverName, Constants.DefaultLanguage, new SDMXObjectModel.Message.ContactType(Constants.Header.Receiver, Constants.Header.ReceiverDepartment, Constants.Header.ReceiverRole, Constants.DefaultLanguage)); Receiver.Contact[0].Items = new string[] { Constants.Header.ReceiverTelephone, Constants.Header.ReceiverEmail, Constants.Header.ReceiverFax }; Receiver.Contact[0].ItemsElementName = new SDMXObjectModel.Message.ContactChoiceType[] { SDMXObjectModel.Message.ContactChoiceType.Telephone, SDMXObjectModel.Message.ContactChoiceType.Email, SDMXObjectModel.Message.ContactChoiceType.Fax }; RetVal = new GenericMetadataHeaderType(Constants.Header.Id, true, DateTime.Now, Sender, Receiver); } else { Sender = new SenderType(this._header.Sender.ID, this._header.Sender.Name, Constants.DefaultLanguage, new SDMXObjectModel.Message.ContactType(this._header.Sender.Contact.Name, this._header.Sender.Contact.Department, this._header.Sender.Contact.Role, Constants.DefaultLanguage)); Sender.Contact[0].Items = new string[] { this._header.Sender.Contact.Telephone, this._header.Sender.Contact.Email, this._header.Sender.Contact.Fax }; Sender.Contact[0].ItemsElementName = new SDMXObjectModel.Message.ContactChoiceType[] { SDMXObjectModel.Message.ContactChoiceType.Telephone, SDMXObjectModel.Message.ContactChoiceType.Email, SDMXObjectModel.Message.ContactChoiceType.Fax }; Receiver = new PartyType(this._header.Receiver.ID, this._header.Receiver.Name, Constants.DefaultLanguage, new SDMXObjectModel.Message.ContactType(this._header.Receiver.Contact.Name, this._header.Receiver.Contact.Department, this._header.Receiver.Contact.Role, Constants.DefaultLanguage)); Receiver.Contact[0].Items = new string[] { this._header.Receiver.Contact.Telephone, this._header.Receiver.Contact.Email, this._header.Receiver.Contact.Fax }; Receiver.Contact[0].ItemsElementName = new SDMXObjectModel.Message.ContactChoiceType[] { SDMXObjectModel.Message.ContactChoiceType.Telephone, SDMXObjectModel.Message.ContactChoiceType.Email, SDMXObjectModel.Message.ContactChoiceType.Fax }; RetVal = new GenericMetadataHeaderType(this._header.ID, true, DateTime.Now, Sender, Receiver); } RetVal.Structure = new List<GenericMetadataStructureType>(); RetVal.Structure.Add(new GenericMetadataStructureType()); switch (metadataType) { case MetadataTypes.Area: RetVal.Structure[0].structureID = Constants.MSD.Area.Id; RetVal.Structure[0].Item = new MetadataStructureReferenceType(); ((MetadataStructureReferenceType)RetVal.Structure[0].Item).Items = new List<object>(); ((MetadataStructureReferenceType)RetVal.Structure[0].Item).Items.Add(new MetadataStructureRefType(Constants.MSD.Area.Id, this._agencyId, Constants.MSD.Area.Version)); break; case MetadataTypes.Indicator: RetVal.Structure[0].structureID = Constants.MSD.Indicator.Id; RetVal.Structure[0].Item = new MetadataStructureReferenceType(); ((MetadataStructureReferenceType)RetVal.Structure[0].Item).Items = new List<object>(); ((MetadataStructureReferenceType)RetVal.Structure[0].Item).Items.Add(new MetadataStructureRefType(Constants.MSD.Indicator.Id, this._agencyId, Constants.MSD.Indicator.Version)); break; case MetadataTypes.Source: RetVal.Structure[0].structureID = Constants.MSD.Source.Id; RetVal.Structure[0].Item = new MetadataStructureReferenceType(); ((MetadataStructureReferenceType)RetVal.Structure[0].Item).Items = new List<object>(); ((MetadataStructureReferenceType)RetVal.Structure[0].Item).Items.Add(new MetadataStructureRefType(Constants.MSD.Source.Id, this._agencyId, Constants.MSD.Source.Version)); break; case MetadataTypes.Layer: RetVal.Structure[0].structureID = Constants.MSD.Area.Id; RetVal.Structure[0].Item = new MetadataStructureReferenceType(); ((MetadataStructureReferenceType)RetVal.Structure[0].Item).Items = new List<object>(); ((MetadataStructureReferenceType)RetVal.Structure[0].Item).Items.Add(new MetadataStructureRefType(Constants.MSD.Area.Id, this._agencyId, Constants.MSD.Area.Version)); break; default: break; } ((MetadataStructureRefType)((MetadataStructureReferenceType)RetVal.Structure[0].Item).Items[0]).local = false; ((MetadataStructureRefType)((MetadataStructureReferenceType)RetVal.Structure[0].Item).Items[0]).localSpecified = true; ((MetadataStructureRefType)((MetadataStructureReferenceType)RetVal.Structure[0].Item).Items[0]).@class = ObjectTypeCodelistType.MetadataStructure; ((MetadataStructureRefType)((MetadataStructureReferenceType)RetVal.Structure[0].Item).Items[0]).classSpecified = true; ((MetadataStructureRefType)((MetadataStructureReferenceType)RetVal.Structure[0].Item).Items[0]).package = PackageTypeCodelistType.metadatastructure; ((MetadataStructureRefType)((MetadataStructureReferenceType)RetVal.Structure[0].Item).Items[0]).packageSpecified = true; return RetVal; }
static MetadataType FindMetadataType(MetadataTypes metadataTypes, string name, string @namespace = null) { if (@namespace != null && @namespace.StartsWith("System")) return null; var reqType = metadataTypes.Operations.FirstOrDefault(x => x.Request.Name == name); if (reqType != null) return reqType.Request; var resType = metadataTypes.Operations .FirstOrDefault(x => x.Response != null && x.Response.Name == name); if (resType != null) return resType.Response; var type = metadataTypes.Types.FirstOrDefault(x => x.Name == name && (@namespace == null || x.Namespace == @namespace)); return type; }
public MetadataTypes GetMetadataTypes(IRequest req, Func <Operation, bool> predicate = null) { var metadata = new MetadataTypes { Config = config, }; var skipTypes = config.IgnoreTypes ?? new HashSet <Type>(); var opTypes = new HashSet <Type>(); var ignoreNamespaces = config.IgnoreTypesInNamespaces ?? new List <string>(); var exportTypes = config.ExportTypes ?? new HashSet <Type>(); foreach (var operation in meta.Operations) { if (predicate != null && !predicate(operation)) { continue; } if (!meta.IsVisible(req, operation)) { continue; } if (opTypes.Contains(operation.RequestType)) { continue; } if (skipTypes.Contains(operation.RequestType)) { continue; } if (ignoreNamespaces.Contains(operation.RequestType.Namespace)) { continue; } var opType = new MetadataOperationType { Actions = operation.Actions, Request = ToType(operation.RequestType), Response = ToType(operation.ResponseType), }; metadata.Operations.Add(opType); opTypes.Add(operation.RequestType); if (operation.ResponseType != null) { if (skipTypes.Contains(operation.ResponseType)) { //Config.IgnoreTypesInNamespaces in CSharpGenerator opType.Response = null; } else { opTypes.Add(operation.ResponseType); } } } var considered = new HashSet <Type>(opTypes); var queue = new Queue <Type>(opTypes); Func <Type, bool> ignoreTypeFn = t => t == null || t.IsGenericParameter || t == typeof(Enum) || considered.Contains(t) || skipTypes.Contains(t) || (ignoreNamespaces.Contains(t.Namespace) && !exportTypes.Contains(t)); Action <Type> registerTypeFn = null; registerTypeFn = t => { if (t.IsArray || t == typeof(Array)) { return; } considered.Add(t); queue.Enqueue(t); if ((!t.IsSystemType() && (t.IsClass || t.IsEnum || t.IsInterface) && !(t.IsGenericParameter)) || exportTypes.Contains(t)) { metadata.Types.Add(ToType(t)); foreach (var ns in GetNamespacesUsed(t)) { if (!metadata.Namespaces.Contains(ns)) { metadata.Namespaces.Add(ns); } } } }; while (queue.Count > 0) { var type = queue.Dequeue(); if (IsSystemCollection(type)) { type = type.GetCollectionType(); if (type != null && !ignoreTypeFn(type)) { registerTypeFn(type); } continue; } if (type.DeclaringType != null) { if (!ignoreTypeFn(type.DeclaringType)) { registerTypeFn(type.DeclaringType); } } if (type.HasInterface(typeof(IService)) && type.GetNestedTypes().IsEmpty()) { continue; } if (!type.IsUserType() && !type.IsInterface && !exportTypes.Contains(type)) { continue; } if (!type.HasInterface(typeof(IService))) { foreach (var pi in type.GetSerializableProperties() .Where(pi => !ignoreTypeFn(pi.PropertyType))) { registerTypeFn(pi.PropertyType); //Register Property Array Element Types if (pi.PropertyType.IsArray && !ignoreTypeFn(pi.PropertyType.GetElementType())) { registerTypeFn(pi.PropertyType.GetElementType()); } //Register Property Generic Arg Types if (!pi.PropertyType.IsGenericType()) { continue; } var propArgs = pi.PropertyType.GetGenericArguments(); foreach (var arg in propArgs.Where(arg => !ignoreTypeFn(arg))) { registerTypeFn(arg); } } } var genericBaseTypeDef = type.BaseType != null && type.BaseType.IsGenericType ? type.BaseType.GetGenericTypeDefinition() : null; if (!ignoreTypeFn(type.BaseType) || genericBaseTypeDef == typeof(QueryBase <,>)) { if (genericBaseTypeDef != null) { if (!ignoreTypeFn(genericBaseTypeDef)) { registerTypeFn(genericBaseTypeDef); } foreach (var arg in type.BaseType.GetGenericArguments() .Where(arg => !ignoreTypeFn(arg))) { registerTypeFn(arg); } } else { registerTypeFn(type.BaseType); } } if (!type.IsGenericType()) { continue; } //Register Generic Arg Types var args = type.GetGenericArguments(); foreach (var arg in args.Where(arg => !ignoreTypeFn(arg))) { registerTypeFn(arg); } } return(metadata); }
public string GetCode(MetadataTypes metadata, IRequest request) { var namespaces = Config.GetDefaultNamespaces(metadata); metadata.RemoveIgnoredTypesForNet(Config); if (Config.GlobalNamespace == null) { metadata.Types.Each(x => namespaces.Add(x.Namespace)); metadata.Operations.Each(x => namespaces.Add(x.Request.Namespace)); } else { namespaces.Add(Config.GlobalNamespace); } Func<string,string> defaultValue = k => request.QueryString[k].IsNullOrEmpty() ? "//" : ""; var sbInner = StringBuilderCache.Allocate(); var sb = new StringBuilderWrapper(sbInner); sb.AppendLine("/* Options:"); sb.AppendLine("Date: {0}".Fmt(DateTime.Now.ToString("s").Replace("T"," "))); sb.AppendLine("Version: {0}".Fmt(Env.ServiceStackVersion)); sb.AppendLine("Tip: {0}".Fmt(HelpMessages.NativeTypesDtoOptionsTip.Fmt("//"))); sb.AppendLine("BaseUrl: {0}".Fmt(Config.BaseUrl)); sb.AppendLine(); sb.AppendLine("{0}GlobalNamespace: {1}".Fmt(defaultValue("GlobalNamespace"), Config.GlobalNamespace)); sb.AppendLine("{0}MakePartial: {1}".Fmt(defaultValue("MakePartial"), Config.MakePartial)); sb.AppendLine("{0}MakeVirtual: {1}".Fmt(defaultValue("MakeVirtual"), Config.MakeVirtual)); sb.AppendLine("{0}MakeDataContractsExtensible: {1}".Fmt(defaultValue("MakeDataContractsExtensible"), Config.MakeDataContractsExtensible)); sb.AppendLine("{0}AddReturnMarker: {1}".Fmt(defaultValue("AddReturnMarker"), Config.AddReturnMarker)); sb.AppendLine("{0}AddDescriptionAsComments: {1}".Fmt(defaultValue("AddDescriptionAsComments"), Config.AddDescriptionAsComments)); sb.AppendLine("{0}AddDataContractAttributes: {1}".Fmt(defaultValue("AddDataContractAttributes"), Config.AddDataContractAttributes)); sb.AppendLine("{0}AddIndexesToDataMembers: {1}".Fmt(defaultValue("AddIndexesToDataMembers"), Config.AddIndexesToDataMembers)); sb.AppendLine("{0}AddGeneratedCodeAttributes: {1}".Fmt(defaultValue("AddGeneratedCodeAttributes"), Config.AddGeneratedCodeAttributes)); sb.AppendLine("{0}AddResponseStatus: {1}".Fmt(defaultValue("AddResponseStatus"), Config.AddResponseStatus)); sb.AppendLine("{0}AddImplicitVersion: {1}".Fmt(defaultValue("AddImplicitVersion"), Config.AddImplicitVersion)); sb.AppendLine("{0}InitializeCollections: {1}".Fmt(defaultValue("InitializeCollections"), Config.InitializeCollections)); sb.AppendLine("{0}IncludeTypes: {1}".Fmt(defaultValue("IncludeTypes"), Config.IncludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}ExcludeTypes: {1}".Fmt(defaultValue("ExcludeTypes"), Config.ExcludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}AddDefaultXmlNamespace: {1}".Fmt(defaultValue("AddDefaultXmlNamespace"), Config.AddDefaultXmlNamespace)); //[GeneratedCode] //sb.AppendLine("{0}DefaultNamespaces: {1}".Fmt(defaultValue("DefaultNamespaces"), Config.DefaultNamespaces.ToArray().Join(", "))); sb.AppendLine("*/"); sb.AppendLine(); namespaces.Where(x => !string.IsNullOrEmpty(x)) .Each(x => sb.AppendLine("using {0};".Fmt(x))); if (Config.AddGeneratedCodeAttributes) sb.AppendLine("using System.CodeDom.Compiler;"); if (Config.AddDataContractAttributes && Config.AddDefaultXmlNamespace != null) { sb.AppendLine(); namespaces.Where(x => !Config.DefaultNamespaces.Contains(x)).ToList() .ForEach(x => sb.AppendLine("[assembly: ContractNamespace(\"{0}\", ClrNamespace=\"{1}\")]" .Fmt(Config.AddDefaultXmlNamespace, x))); } sb.AppendLine(); string lastNS = null; var existingTypes = new HashSet<string>(); var requestTypes = metadata.Operations.Select(x => x.Request).ToHashSet(); var requestTypesMap = metadata.Operations.ToSafeDictionary(x => x.Request); var responseTypes = metadata.Operations .Where(x => x.Response != null) .Select(x => x.Response).ToHashSet(); var types = metadata.Types.ToHashSet(); var allTypes = new List<MetadataType>(); allTypes.AddRange(requestTypes); allTypes.AddRange(responseTypes); allTypes.AddRange(types); var orderedTypes = allTypes .OrderBy(x => x.Namespace) .ThenBy(x => x.Name); foreach (var type in orderedTypes) { var fullTypeName = type.GetFullName(); if (requestTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName)) { MetadataType response = null; MetadataOperationType operation; if (requestTypesMap.TryGetValue(type, out operation)) { response = operation.Response; } lastNS = AppendType(ref sb, type, lastNS, allTypes, new CreateTypeOptions { ImplementsFn = () => { if (!Config.AddReturnMarker && !type.ReturnVoidMarker && type.ReturnMarkerTypeName == null) return null; if (type.ReturnVoidMarker) return "IReturnVoid"; if (type.ReturnMarkerTypeName != null) return Type("IReturn`1", new[] { Type(type.ReturnMarkerTypeName) }); return response != null ? Type("IReturn`1", new[] { Type(response.Name, response.GenericArgs) }) : null; }, IsRequest = true, }); existingTypes.Add(fullTypeName); } } else if (responseTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName) && !Config.IgnoreTypesInNamespaces.Contains(type.Namespace)) { lastNS = AppendType(ref sb, type, lastNS, allTypes, new CreateTypeOptions { IsResponse = true, }); existingTypes.Add(fullTypeName); } } else if (types.Contains(type) && !existingTypes.Contains(fullTypeName)) { lastNS = AppendType(ref sb, type, lastNS, allTypes, new CreateTypeOptions { IsType = true }); existingTypes.Add(fullTypeName); } } if (lastNS != null) sb.AppendLine("}"); sb.AppendLine(); return StringBuilderCache.ReturnAndFree(sbInner); }
public string GetCode(MetadataTypes metadata, IRequest request, INativeTypesMetadata nativeTypes) { var typeNamespaces = new HashSet<string>(); RemoveIgnoredTypes(metadata); metadata.Types.Each(x => typeNamespaces.Add(x.Namespace)); metadata.Operations.Each(x => typeNamespaces.Add(x.Request.Namespace)); var defaultImports = new List<string>(DefaultImports); if (!Config.DefaultImports.IsEmpty()) { defaultImports = Config.DefaultImports; } else if (ReferencesGson(metadata)) { if (!defaultImports.Contains(GSonAnnotationsNamespace)) defaultImports.Add(GSonAnnotationsNamespace); if (!defaultImports.Contains(GSonReflectNamespace)) defaultImports.Add(GSonReflectNamespace); } var defaultNamespace = Config.GlobalNamespace ?? DefaultGlobalNamespace; Func<string, string> defaultValue = k => request.QueryString[k].IsNullOrEmpty() ? "//" : ""; var sbInner = StringBuilderCache.Allocate(); var sb = new StringBuilderWrapper(sbInner); sb.AppendLine("/* Options:"); sb.AppendLine("Date: {0}".Fmt(DateTime.Now.ToString("s").Replace("T", " "))); sb.AppendLine("Version: {0}".Fmt(Env.ServiceStackVersion)); sb.AppendLine("Tip: {0}".Fmt(HelpMessages.NativeTypesDtoOptionsTip.Fmt("//"))); sb.AppendLine("BaseUrl: {0}".Fmt(Config.BaseUrl)); sb.AppendLine(); sb.AppendLine("{0}Package: {1}".Fmt(defaultValue("Package"), Config.Package)); sb.AppendLine("{0}GlobalNamespace: {1}".Fmt(defaultValue("GlobalNamespace"), defaultNamespace)); sb.AppendLine("{0}AddPropertyAccessors: {1}".Fmt(defaultValue("AddPropertyAccessors"), Config.AddPropertyAccessors)); sb.AppendLine("{0}SettersReturnThis: {1}".Fmt(defaultValue("SettersReturnThis"), Config.SettersReturnThis)); sb.AppendLine("{0}AddServiceStackTypes: {1}".Fmt(defaultValue("AddServiceStackTypes"), Config.AddServiceStackTypes)); sb.AppendLine("{0}AddResponseStatus: {1}".Fmt(defaultValue("AddResponseStatus"), Config.AddResponseStatus)); sb.AppendLine("{0}AddDescriptionAsComments: {1}".Fmt(defaultValue("AddDescriptionAsComments"), Config.AddDescriptionAsComments)); sb.AppendLine("{0}AddImplicitVersion: {1}".Fmt(defaultValue("AddImplicitVersion"), Config.AddImplicitVersion)); sb.AppendLine("{0}IncludeTypes: {1}".Fmt(defaultValue("IncludeTypes"), Config.IncludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}ExcludeTypes: {1}".Fmt(defaultValue("ExcludeTypes"), Config.ExcludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}TreatTypesAsStrings: {1}".Fmt(defaultValue("TreatTypesAsStrings"), Config.TreatTypesAsStrings.Safe().ToArray().Join(","))); sb.AppendLine("{0}DefaultImports: {1}".Fmt(defaultValue("DefaultImports"), defaultImports.Join(","))); sb.AppendLine("*/"); sb.AppendLine(); foreach (var typeName in Config.TreatTypesAsStrings.Safe()) { TypeAliases[typeName] = "String"; } if (Config.Package != null) { sb.AppendLine("package {0};".Fmt(Config.Package)); sb.AppendLine(); } string lastNS = null; var existingTypes = new HashSet<string>(); var requestTypes = metadata.Operations.Select(x => x.Request).ToHashSet(); var requestTypesMap = metadata.Operations.ToSafeDictionary(x => x.Request); var responseTypes = metadata.Operations .Where(x => x.Response != null) .Select(x => x.Response).ToHashSet(); var types = metadata.Types.ToHashSet(); AllTypes.AddRange(requestTypes); AllTypes.AddRange(responseTypes); AllTypes.AddRange(types); //TypeScript doesn't support reusing same type name with different generic airity var conflictPartialNames = AllTypes.Map(x => x.Name).Distinct() .GroupBy(g => g.LeftPart('`')) .Where(g => g.Count() > 1) .Select(g => g.Key) .ToList(); this.conflictTypeNames = AllTypes .Where(x => conflictPartialNames.Any(name => x.Name.StartsWith(name))) .Map(x => x.Name); defaultImports.Each(x => sb.AppendLine("import {0};".Fmt(x))); sb.AppendLine(); sb.AppendLine("public class {0}".Fmt(defaultNamespace.SafeToken())); sb.AppendLine("{"); //ServiceStack core interfaces foreach (var type in AllTypes) { var fullTypeName = type.GetFullName(); if (requestTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName)) { MetadataType response = null; MetadataOperationType operation; if (requestTypesMap.TryGetValue(type, out operation)) { response = operation.Response; } lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { ImplementsFn = () => { if (!Config.AddReturnMarker && !type.ReturnVoidMarker && type.ReturnMarkerTypeName == null) return null; if (type.ReturnVoidMarker) return "IReturnVoid"; if (type.ReturnMarkerTypeName != null) return Type("IReturn`1", new[] { Type(type.ReturnMarkerTypeName) }); return response != null ? Type("IReturn`1", new[] { Type(response.Name, response.GenericArgs) }) : null; }, IsRequest = true, }); existingTypes.Add(fullTypeName); } } else if (responseTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName) && !Config.IgnoreTypesInNamespaces.Contains(type.Namespace)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsResponse = true, }); existingTypes.Add(fullTypeName); } } else if (types.Contains(type) && !existingTypes.Contains(fullTypeName)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsType = true }); existingTypes.Add(fullTypeName); } } sb.AppendLine(); sb.AppendLine("}"); return StringBuilderCache.ReturnAndFree(sbInner); }
public string GetCode(MetadataTypes metadata, IRequest request, INativeTypesMetadata nativeTypes) { var typeNamespaces = new HashSet <string>(); var includeList = RemoveIgnoredTypes(metadata); metadata.Types.Each(x => typeNamespaces.Add(x.Namespace)); metadata.Operations.Each(x => typeNamespaces.Add(x.Request.Namespace)); var defaultImports = new List <string>(DefaultImports); if (!Config.DefaultImports.IsEmpty()) { defaultImports = Config.DefaultImports; } else { if (ReferencesGson(metadata)) { defaultImports.AddIfNotExists(GSonAnnotationsNamespace); defaultImports.AddIfNotExists(GSonReflectNamespace); } if (ReferencesStream(metadata)) { defaultImports.AddIfNotExists(JavaIoNamespace); } } var defaultNamespace = Config.GlobalNamespace ?? DefaultGlobalNamespace; string DefaultValue(string k) => request.QueryString[k].IsNullOrEmpty() ? "//" : ""; var sbInner = StringBuilderCache.Allocate(); var sb = new StringBuilderWrapper(sbInner); sb.AppendLine("/* Options:"); sb.AppendLine("Date: {0}".Fmt(DateTime.Now.ToString("s").Replace("T", " "))); sb.AppendLine("Version: {0}".Fmt(Env.ServiceStackVersion)); sb.AppendLine("Tip: {0}".Fmt(HelpMessages.NativeTypesDtoOptionsTip.Fmt("//"))); sb.AppendLine("BaseUrl: {0}".Fmt(Config.BaseUrl)); sb.AppendLine(); sb.AppendLine("{0}Package: {1}".Fmt(DefaultValue("Package"), Config.Package)); sb.AppendLine("{0}GlobalNamespace: {1}".Fmt(DefaultValue("GlobalNamespace"), defaultNamespace)); sb.AppendLine("{0}AddPropertyAccessors: {1}".Fmt(DefaultValue("AddPropertyAccessors"), Config.AddPropertyAccessors)); sb.AppendLine("{0}SettersReturnThis: {1}".Fmt(DefaultValue("SettersReturnThis"), Config.SettersReturnThis)); sb.AppendLine("{0}AddServiceStackTypes: {1}".Fmt(DefaultValue("AddServiceStackTypes"), Config.AddServiceStackTypes)); sb.AppendLine("{0}AddResponseStatus: {1}".Fmt(DefaultValue("AddResponseStatus"), Config.AddResponseStatus)); sb.AppendLine("{0}AddDescriptionAsComments: {1}".Fmt(DefaultValue("AddDescriptionAsComments"), Config.AddDescriptionAsComments)); sb.AppendLine("{0}AddImplicitVersion: {1}".Fmt(DefaultValue("AddImplicitVersion"), Config.AddImplicitVersion)); sb.AppendLine("{0}IncludeTypes: {1}".Fmt(DefaultValue("IncludeTypes"), Config.IncludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}ExcludeTypes: {1}".Fmt(DefaultValue("ExcludeTypes"), Config.ExcludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}TreatTypesAsStrings: {1}".Fmt(DefaultValue("TreatTypesAsStrings"), Config.TreatTypesAsStrings.Safe().ToArray().Join(","))); sb.AppendLine("{0}DefaultImports: {1}".Fmt(DefaultValue("DefaultImports"), defaultImports.Join(","))); sb.AppendLine("*/"); sb.AppendLine(); foreach (var typeName in Config.TreatTypesAsStrings.Safe()) { TypeAliases[typeName] = "String"; } if (Config.Package != null) { sb.AppendLine("package {0};".Fmt(Config.Package)); sb.AppendLine(); } string lastNS = null; var existingTypes = new HashSet <string>(); var requestTypes = metadata.Operations.Select(x => x.Request).ToHashSet(); var requestTypesMap = metadata.Operations.ToSafeDictionary(x => x.Request); var responseTypes = metadata.Operations .Where(x => x.Response != null) .Select(x => x.Response).ToHashSet(); var types = metadata.Types.ToHashSet(); allTypes = new List <MetadataType>(); allTypes.AddRange(requestTypes); allTypes.AddRange(responseTypes); allTypes.AddRange(types); allTypes = FilterTypes(allTypes); //TypeScript doesn't support reusing same type name with different generic airity var conflictPartialNames = allTypes.Map(x => x.Name).Distinct() .GroupBy(g => g.LeftPart('`')) .Where(g => g.Count() > 1) .Select(g => g.Key) .ToList(); this.conflictTypeNames = allTypes .Where(x => conflictPartialNames.Any(name => x.Name.StartsWith(name))) .Map(x => x.Name); defaultImports.Each(x => sb.AppendLine("import {0};".Fmt(x))); sb.AppendLine(); var insertCode = InsertCodeFilter?.Invoke(allTypes, Config); if (insertCode != null) { sb.AppendLine(insertCode); } sb.AppendLine("public class {0}".Fmt(defaultNamespace.SafeToken())); sb.AppendLine("{"); //ServiceStack core interfaces foreach (var type in allTypes) { var fullTypeName = type.GetFullName(); if (requestTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName)) { MetadataType response = null; if (requestTypesMap.TryGetValue(type, out var operation)) { response = operation.Response; } lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { ImplementsFn = () => { if (!Config.AddReturnMarker && !type.ReturnVoidMarker && type.ReturnMarkerTypeName == null) { return(null); } if (type.ReturnVoidMarker) { return("IReturnVoid"); } if (type.ReturnMarkerTypeName != null) { return(Type("IReturn`1", new[] { Type(type.ReturnMarkerTypeName) })); } return(response != null ? Type("IReturn`1", new[] { Type(response.Name, response.GenericArgs) }) : null); }, IsRequest = true, }); existingTypes.Add(fullTypeName); } } else if (responseTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName) && !Config.IgnoreTypesInNamespaces.Contains(type.Namespace)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsResponse = true, }); existingTypes.Add(fullTypeName); } } else if (types.Contains(type) && !existingTypes.Contains(fullTypeName)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsType = true }); existingTypes.Add(fullTypeName); } } sb.AppendLine(); sb.AppendLine("}"); var addCode = AddCodeFilter?.Invoke(allTypes, Config); if (addCode != null) { sb.AppendLine(addCode); } return(StringBuilderCache.ReturnAndFree(sbInner)); }
private bool ReferencesGson(MetadataTypes metadata) { var allTypes = GetAllMetadataTypes(metadata); return allTypes.Any(x => JavaGeneratorExtensions.JavaKeyWords.Contains(x.Name) || x.Properties.Safe().Any(p => p.DataMember != null && p.DataMember.Name != null) || (x.ReturnMarkerTypeName != null && x.ReturnMarkerTypeName.Name.IndexOf('`') >= 0)); //uses TypeToken<T> }
public string GetCode(MetadataTypes metadata, IRequest request) { var typeNamespaces = new HashSet<string>(); RemoveIgnoredTypes(metadata); metadata.Types.Each(x => typeNamespaces.Add(x.Namespace)); metadata.Operations.Each(x => typeNamespaces.Add(x.Request.Namespace)); var defaultImports = !Config.DefaultImports.IsEmpty() ? Config.DefaultImports : DefaultImports; Func<string, string> defaultValue = k => request.QueryString[k].IsNullOrEmpty() ? "//" : ""; var sb = new StringBuilderWrapper(new StringBuilder()); var sbExt = new StringBuilderWrapper(new StringBuilder()); sb.AppendLine("/* Options:"); sb.AppendLine("Date: {0}".Fmt(DateTime.Now.ToString("s").Replace("T", " "))); sb.AppendLine("SwiftVersion: 2.0"); sb.AppendLine("Version: {0}".Fmt(Env.ServiceStackVersion)); sb.AppendLine("Tip: {0}".Fmt(HelpMessages.NativeTypesDtoOptionsTip.Fmt("//"))); sb.AppendLine("BaseUrl: {0}".Fmt(Config.BaseUrl)); sb.AppendLine(); sb.AppendLine("{0}BaseClass: {1}".Fmt(defaultValue("BaseClass"), Config.BaseClass)); sb.AppendLine("{0}AddModelExtensions: {1}".Fmt(defaultValue("AddModelExtensions"), Config.AddModelExtensions)); sb.AppendLine("{0}AddServiceStackTypes: {1}".Fmt(defaultValue("AddServiceStackTypes"), Config.AddServiceStackTypes)); sb.AppendLine("{0}IncludeTypes: {1}".Fmt(defaultValue("IncludeTypes"), Config.IncludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}ExcludeTypes: {1}".Fmt(defaultValue("ExcludeTypes"), Config.ExcludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}ExcludeGenericBaseTypes: {1}".Fmt(defaultValue("ExcludeGenericBaseTypes"), Config.ExcludeGenericBaseTypes)); sb.AppendLine("{0}AddResponseStatus: {1}".Fmt(defaultValue("AddResponseStatus"), Config.AddResponseStatus)); sb.AppendLine("{0}AddImplicitVersion: {1}".Fmt(defaultValue("AddImplicitVersion"), Config.AddImplicitVersion)); sb.AppendLine("{0}InitializeCollections: {1}".Fmt(defaultValue("InitializeCollections"), Config.InitializeCollections)); sb.AppendLine("{0}TreatTypesAsStrings: {1}".Fmt(defaultValue("TreatTypesAsStrings"), Config.TreatTypesAsStrings.Safe().ToArray().Join(","))); sb.AppendLine("{0}DefaultImports: {1}".Fmt(defaultValue("DefaultImports"), defaultImports.Join(","))); sb.AppendLine("*/"); sb.AppendLine(); foreach (var typeName in Config.TreatTypesAsStrings.Safe()) { TypeAliases[typeName] = "String"; } string lastNS = null; var existingTypes = new HashSet<string>(); var requestTypes = metadata.Operations.Select(x => x.Request).ToHashSet(); var requestTypesMap = metadata.Operations.ToSafeDictionary(x => x.Request); var responseTypes = metadata.Operations .Where(x => x.Response != null) .Select(x => x.Response).ToHashSet(); var types = metadata.Types.ToHashSet(); AllTypes.AddRange(requestTypes); AllTypes.AddRange(responseTypes); AllTypes.AddRange(types); //Swift doesn't support reusing same type name with different generic airity var conflictPartialNames = AllTypes.Map(x => x.Name).Distinct() .GroupBy(g => g.SplitOnFirst('`')[0]) .Where(g => g.Count() > 1) .Select(g => g.Key) .ToList(); this.conflictTypeNames = AllTypes .Where(x => conflictPartialNames.Any(name => x.Name.StartsWith(name))) .Map(x => x.Name); defaultImports.Each(x => sb.AppendLine("import {0};".Fmt(x))); //ServiceStack core interfaces foreach (var type in AllTypes) { var fullTypeName = type.GetFullName(); if (requestTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName)) { MetadataType response = null; MetadataOperationType operation; if (requestTypesMap.TryGetValue(type, out operation)) { response = operation.Response; } lastNS = AppendType(ref sb, ref sbExt, type, lastNS, new CreateTypeOptions { ImplementsFn = () => { if (!Config.AddReturnMarker && !type.ReturnVoidMarker && type.ReturnMarkerTypeName == null) return null; if (type.ReturnVoidMarker) return "IReturnVoid"; if (type.ReturnMarkerTypeName != null) return ReturnType("IReturn`1", new[] { Type(type.ReturnMarkerTypeName) }); return response != null ? ReturnType("IReturn`1", new[] { Type(response.Name, response.GenericArgs) }) : null; }, IsRequest = true, }); existingTypes.Add(fullTypeName); } } else if (responseTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName) && !Config.IgnoreTypesInNamespaces.Contains(type.Namespace)) { lastNS = AppendType(ref sb, ref sbExt, type, lastNS, new CreateTypeOptions { IsResponse = true, }); existingTypes.Add(fullTypeName); } } else if (types.Contains(type) && !existingTypes.Contains(fullTypeName)) { lastNS = AppendType(ref sb, ref sbExt, type, lastNS, new CreateTypeOptions { IsType = true }); existingTypes.Add(fullTypeName); } } if (Config.AddModelExtensions) { sb.AppendLine(); sb.AppendLine(sbExt.ToString()); } return sb.ToString(); }
private void RemoveIgnoredTypes(MetadataTypes metadata) { metadata.RemoveIgnoredTypes(Config); metadata.Types.RemoveAll(x => IgnoreTypeNames.Contains(x.Name)); }
public string GetCode(MetadataTypes metadata, IRequest request) { var namespaces = Config.GetDefaultNamespaces(metadata); metadata.RemoveIgnoredTypes(Config); if (Config.GlobalNamespace == null) { metadata.Types.Each(x => namespaces.Add(x.Namespace)); metadata.Operations.Each(x => namespaces.Add(x.Request.Namespace)); } else { namespaces.Add(Config.GlobalNamespace); } Func <string, string> defaultValue = k => request.QueryString[k].IsNullOrEmpty() ? "//" : ""; var sb = new StringBuilderWrapper(new StringBuilder()); sb.AppendLine("/* Options:"); sb.AppendLine("Date: {0}".Fmt(DateTime.Now.ToString("s").Replace("T", " "))); sb.AppendLine("Version: {0}".Fmt(metadata.Version)); sb.AppendLine("BaseUrl: {0}".Fmt(Config.BaseUrl)); sb.AppendLine(); sb.AppendLine("{0}GlobalNamespace: {1}".Fmt(defaultValue("GlobalNamespace"), Config.GlobalNamespace)); sb.AppendLine("{0}MakePartial: {1}".Fmt(defaultValue("MakePartial"), Config.MakePartial)); sb.AppendLine("{0}MakeVirtual: {1}".Fmt(defaultValue("MakeVirtual"), Config.MakeVirtual)); sb.AppendLine("{0}MakeDataContractsExtensible: {1}".Fmt(defaultValue("MakeDataContractsExtensible"), Config.MakeDataContractsExtensible)); sb.AppendLine("{0}AddReturnMarker: {1}".Fmt(defaultValue("AddReturnMarker"), Config.AddReturnMarker)); sb.AppendLine("{0}AddDescriptionAsComments: {1}".Fmt(defaultValue("AddDescriptionAsComments"), Config.AddDescriptionAsComments)); sb.AppendLine("{0}AddDataContractAttributes: {1}".Fmt(defaultValue("AddDataContractAttributes"), Config.AddDataContractAttributes)); sb.AppendLine("{0}AddIndexesToDataMembers: {1}".Fmt(defaultValue("AddIndexesToDataMembers"), Config.AddIndexesToDataMembers)); sb.AppendLine("{0}AddResponseStatus: {1}".Fmt(defaultValue("AddResponseStatus"), Config.AddResponseStatus)); sb.AppendLine("{0}AddImplicitVersion: {1}".Fmt(defaultValue("AddImplicitVersion"), Config.AddImplicitVersion)); sb.AppendLine("{0}InitializeCollections: {1}".Fmt(defaultValue("InitializeCollections"), Config.InitializeCollections)); sb.AppendLine("{0}IncludeTypes: {1}".Fmt(defaultValue("IncludeTypes"), Config.IncludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}ExcludeTypes: {1}".Fmt(defaultValue("ExcludeTypes"), Config.ExcludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}AddDefaultXmlNamespace: {1}".Fmt(defaultValue("AddDefaultXmlNamespace"), Config.AddDefaultXmlNamespace)); //sb.AppendLine("{0}DefaultNamespaces: {1}".Fmt(defaultValue("DefaultNamespaces"), Config.DefaultNamespaces.ToArray().Join(", "))); sb.AppendLine("*/"); sb.AppendLine(); namespaces.Each(x => sb.AppendLine("using {0};".Fmt(x))); if (Config.AddDataContractAttributes && Config.AddDefaultXmlNamespace != null) { sb.AppendLine(); namespaces.Where(x => !Config.DefaultNamespaces.Contains(x)).ToList() .ForEach(x => sb.AppendLine("[assembly: ContractNamespace(\"{0}\", ClrNamespace=\"{1}\")]" .Fmt(Config.AddDefaultXmlNamespace, x))); } sb.AppendLine(); string lastNS = null; var existingTypes = new HashSet <string>(); var requestTypes = metadata.Operations.Select(x => x.Request).ToHashSet(); var requestTypesMap = metadata.Operations.ToSafeDictionary(x => x.Request); var responseTypes = metadata.Operations .Where(x => x.Response != null) .Select(x => x.Response).ToHashSet(); var types = metadata.Types.ToHashSet(); var allTypes = new List <MetadataType>(); allTypes.AddRange(requestTypes); allTypes.AddRange(responseTypes); allTypes.AddRange(types); var orderedTypes = allTypes .OrderBy(x => x.Namespace) .ThenBy(x => x.Name); foreach (var type in orderedTypes) { var fullTypeName = type.GetFullName(); if (requestTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName)) { MetadataType response = null; MetadataOperationType operation; if (requestTypesMap.TryGetValue(type, out operation)) { response = operation.Response; } lastNS = AppendType(ref sb, type, lastNS, allTypes, new CreateTypeOptions { ImplementsFn = () => { if (!Config.AddReturnMarker && !type.ReturnVoidMarker && type.ReturnMarkerTypeName == null) { return(null); } if (type.ReturnVoidMarker) { return("IReturnVoid"); } if (type.ReturnMarkerTypeName != null) { return(Type("IReturn`1", new[] { Type(type.ReturnMarkerTypeName) })); } return(response != null ? Type("IReturn`1", new[] { Type(response.Name, response.GenericArgs) }) : null); }, IsRequest = true, }); existingTypes.Add(fullTypeName); } } else if (responseTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName) && !Config.IgnoreTypesInNamespaces.Contains(type.Namespace)) { lastNS = AppendType(ref sb, type, lastNS, allTypes, new CreateTypeOptions { IsResponse = true, }); existingTypes.Add(fullTypeName); } } else if (types.Contains(type) && !existingTypes.Contains(fullTypeName)) { lastNS = AppendType(ref sb, type, lastNS, allTypes, new CreateTypeOptions { IsType = true }); existingTypes.Add(fullTypeName); } } if (lastNS != null) { sb.AppendLine("}"); } sb.AppendLine(); return(sb.ToString()); }
public string GetCode(MetadataTypes metadata, IRequest request, INativeTypesMetadata nativeTypes) { var typeNamespaces = new HashSet<string>(); metadata.RemoveIgnoredTypes(Config); metadata.Types.Each(x => typeNamespaces.Add(x.Namespace)); metadata.Operations.Each(x => typeNamespaces.Add(x.Request.Namespace)); var defaultImports = !Config.DefaultImports.IsEmpty() ? Config.DefaultImports : DefaultImports; // Look first for shortest Namespace ending with `ServiceModel` convention, else shortest ns var globalNamespace = Config.GlobalNamespace ?? typeNamespaces.Where(x => x.EndsWith("ServiceModel")) .OrderBy(x => x).FirstOrDefault() ?? typeNamespaces.OrderBy(x => x).First(); Func<string, string> defaultValue = k => request.QueryString[k].IsNullOrEmpty() ? "//" : ""; var sb = new StringBuilderWrapper(new StringBuilder()); sb.AppendLine("/* Options:"); sb.AppendLine("Date: {0}".Fmt(DateTime.Now.ToString("s").Replace("T", " "))); sb.AppendLine("Version: {0}".Fmt(Env.ServiceStackVersion)); sb.AppendLine("BaseUrl: {0}".Fmt(Config.BaseUrl)); sb.AppendLine(); sb.AppendLine("{0}GlobalNamespace: {1}".Fmt(defaultValue("GlobalNamespace"), Config.GlobalNamespace)); sb.AppendLine("{0}MakePropertiesOptional: {1}".Fmt(defaultValue("MakePropertiesOptional"), Config.MakePropertiesOptional)); sb.AppendLine("{0}AddServiceStackTypes: {1}".Fmt(defaultValue("AddServiceStackTypes"), Config.AddServiceStackTypes)); sb.AppendLine("{0}AddResponseStatus: {1}".Fmt(defaultValue("AddResponseStatus"), Config.AddResponseStatus)); sb.AppendLine("{0}AddImplicitVersion: {1}".Fmt(defaultValue("AddImplicitVersion"), Config.AddImplicitVersion)); sb.AppendLine("{0}IncludeTypes: {1}".Fmt(defaultValue("IncludeTypes"), Config.IncludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}ExcludeTypes: {1}".Fmt(defaultValue("ExcludeTypes"), Config.ExcludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}DefaultImports: {1}".Fmt(defaultValue("DefaultImports"), defaultImports.Join(","))); sb.AppendLine("*/"); sb.AppendLine(); string lastNS = null; var existingTypes = new HashSet<string>(); var requestTypes = metadata.Operations.Select(x => x.Request).ToHashSet(); var requestTypesMap = metadata.Operations.ToSafeDictionary(x => x.Request); var responseTypes = metadata.Operations .Where(x => x.Response != null) .Select(x => x.Response).ToHashSet(); var types = metadata.Types.ToHashSet(); var allTypes = new List<MetadataType>(); allTypes.AddRange(types); allTypes.AddRange(responseTypes); allTypes.AddRange(requestTypes); allTypes.RemoveAll(x => x.IgnoreType(Config)); //TypeScript doesn't support reusing same type name with different generic airity var conflictPartialNames = allTypes.Map(x => x.Name).Distinct() .GroupBy(g => g.SplitOnFirst('`')[0]) .Where(g => g.Count() > 1) .Select(g => g.Key) .ToList(); this.conflictTypeNames = allTypes .Where(x => conflictPartialNames.Any(name => x.Name.StartsWith(name))) .Map(x => x.Name); defaultImports.Each(x => sb.AppendLine("import {0};".Fmt(x))); sb.AppendLine(); sb.AppendLine("declare module {0}".Fmt(globalNamespace.SafeToken())); sb.AppendLine("{"); //ServiceStack core interfaces foreach (var type in allTypes) { var fullTypeName = type.GetFullName(); if (requestTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName)) { MetadataType response = null; MetadataOperationType operation; if (requestTypesMap.TryGetValue(type, out operation)) { response = operation.Response; } lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { ImplementsFn = () => { if (!Config.AddReturnMarker && !type.ReturnVoidMarker && type.ReturnMarkerTypeName == null) return null; if (type.ReturnVoidMarker) return "IReturnVoid"; if (type.ReturnMarkerTypeName != null) return Type("IReturn`1", new[] { Type(type.ReturnMarkerTypeName) }); return response != null ? Type("IReturn`1", new[] { Type(response.Name, response.GenericArgs) }) : null; }, IsRequest = true, }); existingTypes.Add(fullTypeName); } } else if (responseTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName) && !Config.IgnoreTypesInNamespaces.Contains(type.Namespace)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsResponse = true, }); existingTypes.Add(fullTypeName); } } else if (types.Contains(type) && !existingTypes.Contains(fullTypeName)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsType = true }); existingTypes.Add(fullTypeName); } } sb.AppendLine(); sb.AppendLine("}"); return sb.ToString(); }
public static HashSet <string> GetDefaultNamespaces(this MetadataTypesConfig config, MetadataTypes metadata) { var namespaces = config.DefaultNamespaces.ToHashSet(); //Add any ignored namespaces used foreach (var ns in metadata.Namespaces) { //Ignored by IsUserType() if (!ns.StartsWith("System") && !config.IgnoreTypesInNamespaces.Contains(ns)) { continue; } if (!namespaces.Contains(ns)) { namespaces.Add(ns); } } return(namespaces); }
public MetadataTypes GetMetadataTypes(IRequest req) { var metadata = new MetadataTypes { Config = config, }; var skipTypes = new HashSet<Type>(config.SkipExistingTypes); config.IgnoreTypes.Each(x => skipTypes.Add(x)); foreach (var operation in meta.Operations) { if (!meta.IsVisible(req, operation)) continue; metadata.Operations.Add(new MetadataOperationType { Actions = operation.Actions, Request = ToType(operation.RequestType), Response = ToType(operation.ResponseType), }); skipTypes.Add(operation.RequestType); if (operation.ResponseType != null) { skipTypes.Add(operation.ResponseType); } } foreach (var type in meta.GetAllTypes()) { if (skipTypes.Contains(type)) continue; metadata.Operations.Add(new MetadataOperationType { Request = ToType(type), }); skipTypes.Add(type); } var considered = new HashSet<Type>(skipTypes); var queue = new Queue<Type>(skipTypes); while (queue.Count > 0) { var type = queue.Dequeue(); foreach (var pi in type.GetSerializableProperties()) { if (pi.PropertyType.IsUserType()) { if (considered.Contains(pi.PropertyType)) continue; considered.Add(pi.PropertyType); queue.Enqueue(pi.PropertyType); metadata.Types.Add(ToType(pi.PropertyType)); } } if (type.BaseType != null && type.BaseType.IsUserType() && !considered.Contains(type.BaseType)) { considered.Add(type.BaseType); queue.Enqueue(type.BaseType); metadata.Types.Add(ToType(type.BaseType)); } } return metadata; }
public string GetCode(MetadataTypes metadata, IRequest request) { var namespaces = new HashSet<string>(); Config.DefaultNamespaces.Each(x => namespaces.Add(x)); var typeNamespaces = new HashSet<string>(); metadata.Types.Each(x => typeNamespaces.Add(x.Namespace)); metadata.Operations.Each(x => typeNamespaces.Add(x.Request.Namespace)); // Look first for shortest Namespace ending with `ServiceModel` convention, else shortest ns var globalNamespace = Config.GlobalNamespace ?? typeNamespaces.Where(x => x.EndsWith("ServiceModel")) .OrderBy(x => x).FirstOrDefault() ?? typeNamespaces.OrderBy(x => x).First(); Func<string, string> defaultValue = k => request.QueryString[k].IsNullOrEmpty() ? "//" : ""; var sb = new StringBuilderWrapper(new StringBuilder()); sb.AppendLine("(* Options:"); sb.AppendLine("Date: {0}".Fmt(DateTime.Now.ToString("s").Replace("T", " "))); sb.AppendLine("Version: {0}".Fmt(metadata.Version)); sb.AppendLine("BaseUrl: {0}".Fmt(Config.BaseUrl)); sb.AppendLine(); sb.AppendLine("{0}MakeDataContractsExtensible: {1}".Fmt(defaultValue("MakeDataContractsExtensible"), Config.MakeDataContractsExtensible)); sb.AppendLine("{0}AddReturnMarker: {1}".Fmt(defaultValue("AddReturnMarker"), Config.AddReturnMarker)); sb.AppendLine("{0}AddDescriptionAsComments: {1}".Fmt(defaultValue("AddDescriptionAsComments"), Config.AddDescriptionAsComments)); sb.AppendLine("{0}AddDataContractAttributes: {1}".Fmt(defaultValue("AddDataContractAttributes"), Config.AddDataContractAttributes)); sb.AppendLine("{0}AddIndexesToDataMembers: {1}".Fmt(defaultValue("AddIndexesToDataMembers"), Config.AddIndexesToDataMembers)); sb.AppendLine("{0}AddResponseStatus: {1}".Fmt(defaultValue("AddResponseStatus"), Config.AddResponseStatus)); sb.AppendLine("{0}AddImplicitVersion: {1}".Fmt(defaultValue("AddImplicitVersion"), Config.AddImplicitVersion)); sb.AppendLine("{0}InitializeCollections: {1}".Fmt(defaultValue("InitializeCollections"), Config.InitializeCollections)); //sb.AppendLine("{0}AddDefaultXmlNamespace: {1}".Fmt(defaultValue("AddDefaultXmlNamespace"), Config.AddDefaultXmlNamespace)); //sb.AppendLine("{0}DefaultNamespaces: {1}".Fmt(defaultValue("DefaultNamespaces"), Config.DefaultNamespaces.ToArray().Join(", "))); sb.AppendLine("*)"); sb.AppendLine(); //if (Config.AddDataContractAttributes // && Config.AddDefaultXmlNamespace != null) //{ // sb.AppendLine(); // var list = namespaces.Where(x => !Config.DefaultNamespaces.Contains(x)).ToList(); // list.ForEach(x => // sb.AppendLine("[<assembly: ContractNamespace(\"{0}\", ClrNamespace=\"{1}\")>]" // .Fmt(Config.AddDefaultXmlNamespace, x))); // if (list.Count > 0) // { // sb.AppendLine("do()"); //http://scottseely.com/2009/01/23/f-assembly-level-attributes-assemblyinfo-fs-and-do/ // } //} //sb.AppendLine(); string lastNS = null; var existingOps = new HashSet<string>(); var requestTypes = metadata.Operations.Select(x => x.Request).ToHashSet(); var requestTypesMap = metadata.Operations.ToSafeDictionary(x => x.Request); var responseTypes = metadata.Operations .Where(x => x.Response != null) .Select(x => x.Response).ToHashSet(); var types = metadata.Types.ToHashSet(); var allTypes = new List<MetadataType>(); allTypes.AddRange(types); allTypes.AddRange(responseTypes); allTypes.AddRange(requestTypes); var orderedTypes = allTypes.OrderTypesByDeps(); sb.AppendLine("namespace {0}".Fmt(globalNamespace.SafeToken())); sb.AppendLine(); foreach (var ns in namespaces) { sb.AppendLine("open " + ns); } foreach (var type in orderedTypes) { var fullTypeName = type.GetFullName(); if (requestTypes.Contains(type)) { if (!existingOps.Contains(fullTypeName)) { MetadataType response = null; MetadataOperationType operation; if (requestTypesMap.TryGetValue(type, out operation)) { response = operation.Response; } lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { ImplementsFn = () => { if (!Config.AddReturnMarker && !type.ReturnVoidMarker && type.ReturnMarkerTypeName == null) return null; if (type.ReturnVoidMarker) return "IReturnVoid"; if (type.ReturnMarkerTypeName != null) return Type("IReturn`1", new[] { Type(type.ReturnMarkerTypeName) }); return response != null ? Type("IReturn`1", new[] { Type(type.Name, type.GenericArgs) }) : null; }, IsRequest = true, }); existingOps.Add(fullTypeName); } } else if (responseTypes.Contains(type)) { if (!existingOps.Contains(fullTypeName) && !Config.IgnoreTypesInNamespaces.Contains(type.Namespace)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsResponse = true, }); existingOps.Add(fullTypeName); } } else if (types.Contains(type) && !existingOps.Contains(fullTypeName)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsType = true }); } } sb.AppendLine(); return sb.ToString(); }
public string GetCode(MetadataTypes metadata) { var namespaces = new HashSet<string>(); Config.DefaultNamespaces.Each(x => namespaces.Add(x)); metadata.Types.Each(x => namespaces.Add(x.Namespace)); metadata.Operations.Each(x => namespaces.Add(x.Request.Namespace)); var sb = new StringBuilderWrapper(new StringBuilder()); sb.AppendLine("/* Options:"); sb.AppendLine("Version: {0}".Fmt(Version)); sb.AppendLine("BaseUrl: {0}".Fmt(Config.BaseUrl)); sb.AppendLine(); sb.AppendLine("ServerVersion: {0}".Fmt(metadata.Version)); sb.AppendLine("MakePartial: {0}".Fmt(Config.MakePartial)); sb.AppendLine("MakeVirtual: {0}".Fmt(Config.MakeVirtual)); sb.AppendLine("MakeDataContractsExtensible: {0}".Fmt(Config.MakeDataContractsExtensible)); sb.AppendLine("AddReturnMarker: {0}".Fmt(Config.AddReturnMarker)); sb.AppendLine("AddDescriptionAsComments: {0}".Fmt(Config.AddDescriptionAsComments)); sb.AppendLine("AddDataContractAttributes: {0}".Fmt(Config.AddDataContractAttributes)); sb.AppendLine("AddDataAnnotationAttributes: {0}".Fmt(Config.AddDataAnnotationAttributes)); sb.AppendLine("AddIndexesToDataMembers: {0}".Fmt(Config.AddIndexesToDataMembers)); sb.AppendLine("AddResponseStatus: {0}".Fmt(Config.AddResponseStatus)); sb.AppendLine("AddImplicitVersion: {0}".Fmt(Config.AddImplicitVersion)); sb.AppendLine("InitializeCollections: {0}".Fmt(Config.InitializeCollections)); sb.AppendLine("AddDefaultXmlNamespace: {0}".Fmt(Config.AddDefaultXmlNamespace)); //sb.AppendLine("DefaultNamespaces: {0}".Fmt(Config.DefaultNamespaces.ToArray().Join(", "))); sb.AppendLine("*/"); sb.AppendLine(); namespaces.Each(x => sb.AppendLine("using {0};".Fmt(x))); if (Config.AddDataContractAttributes && Config.AddDefaultXmlNamespace != null) { sb.AppendLine(); namespaces.Where(x => !Config.DefaultNamespaces.Contains(x)).ToList() .ForEach(x => sb.AppendLine("[assembly: ContractNamespace(\"{0}\", ClrNamespace=\"{1}\")]" .Fmt(Config.AddDefaultXmlNamespace, x))); } sb.AppendLine(); string lastNS = null; var existingOps = new HashSet<string>(); var requestTypes = metadata.Operations.Select(x => x.Request).ToHashSet(); var requestTypesMap = metadata.Operations.ToSafeDictionary(x => x.Request); var responseTypes = metadata.Operations .Where(x => x.Response != null) .Select(x => x.Response).ToHashSet(); var types = metadata.Types.ToHashSet(); var allTypes = new List<MetadataType>(); allTypes.AddRange(requestTypes); allTypes.AddRange(responseTypes); allTypes.AddRange(types); var orderedTypes = allTypes .OrderBy(x => x.Namespace) .ThenBy(x => x.Name); foreach (var type in orderedTypes) { var fullTypeName = type.GetFullName(); if (requestTypes.Contains(type)) { if (!existingOps.Contains(fullTypeName)) { MetadataType response = null; MetadataOperationType operation; if (requestTypesMap.TryGetValue(type, out operation)) { response = operation.Response; } lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { ImplementsFn = () => { if (!Config.AddReturnMarker && !type.ReturnVoidMarker && type.ReturnMarkerTypeName == null) return null; if (type.ReturnVoidMarker) return "IReturnVoid"; if (type.ReturnMarkerTypeName != null) return Type("IReturn`1", new[] { Type(type.ReturnMarkerTypeName) }); return response != null ? Type("IReturn`1", new[] { Type(type.Name, type.GenericArgs) }) : null; }, IsRequest = true, }); existingOps.Add(fullTypeName); } } else if (responseTypes.Contains(type)) { if (!existingOps.Contains(fullTypeName) && !Config.IgnoreTypesInNamespaces.Contains(type.Namespace)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsResponse = true, }); existingOps.Add(fullTypeName); } } else if (types.Contains(type) && !existingOps.Contains(fullTypeName)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsType = true }); } } if (lastNS != null) sb.AppendLine("}"); sb.AppendLine(); return sb.ToString(); }
public string GetCode(MetadataTypes metadata, IRequest request, INativeTypesMetadata nativeTypes) { var typeNamespaces = new HashSet <string>(); var includeList = metadata.RemoveIgnoredTypes(Config); metadata.Types.Each(x => typeNamespaces.Add(x.Namespace)); metadata.Operations.Each(x => typeNamespaces.Add(x.Request.Namespace)); var defaultImports = !Config.DefaultImports.IsEmpty() ? Config.DefaultImports : DefaultImports; var globalNamespace = Config.GlobalNamespace; string defaultValue(string k) => request.QueryString[k].IsNullOrEmpty() ? "//" : ""; var sbInner = StringBuilderCache.Allocate(); var sb = new StringBuilderWrapper(sbInner); sb.AppendLine("/* Options:"); sb.AppendLine("Date: {0}".Fmt(DateTime.Now.ToString("s").Replace("T", " "))); sb.AppendLine("Version: {0}".Fmt(Env.ServiceStackVersion)); sb.AppendLine("Tip: {0}".Fmt(HelpMessages.NativeTypesDtoOptionsTip.Fmt("//"))); sb.AppendLine("BaseUrl: {0}".Fmt(Config.BaseUrl)); sb.AppendLine(); sb.AppendLine("{0}GlobalNamespace: {1}".Fmt(defaultValue("GlobalNamespace"), Config.GlobalNamespace)); //sb.AppendLine("{0}ExportAsTypes: {1}".Fmt(defaultValue("ExportAsTypes"), Config.ExportAsTypes)); sb.AppendLine("{0}MakePropertiesOptional: {1}".Fmt(defaultValue("MakePropertiesOptional"), Config.MakePropertiesOptional)); sb.AppendLine("{0}AddServiceStackTypes: {1}".Fmt(defaultValue("AddServiceStackTypes"), Config.AddServiceStackTypes)); sb.AppendLine("{0}AddResponseStatus: {1}".Fmt(defaultValue("AddResponseStatus"), Config.AddResponseStatus)); sb.AppendLine("{0}AddImplicitVersion: {1}".Fmt(defaultValue("AddImplicitVersion"), Config.AddImplicitVersion)); sb.AppendLine("{0}AddDescriptionAsComments: {1}".Fmt(defaultValue("AddDescriptionAsComments"), Config.AddDescriptionAsComments)); sb.AppendLine("{0}IncludeTypes: {1}".Fmt(defaultValue("IncludeTypes"), Config.IncludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}ExcludeTypes: {1}".Fmt(defaultValue("ExcludeTypes"), Config.ExcludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}DefaultImports: {1}".Fmt(defaultValue("DefaultImports"), defaultImports.Join(","))); sb.AppendLine("*/"); sb.AppendLine(); string lastNS = null; var existingTypes = new HashSet <string>(); var requestTypes = metadata.Operations.Select(x => x.Request).ToHashSet(); var requestTypesMap = metadata.Operations.ToSafeDictionary(x => x.Request); var responseTypes = metadata.Operations .Where(x => x.Response != null) .Select(x => x.Response).ToHashSet(); var types = metadata.Types.CreateSortedTypeList(); allTypes = metadata.GetAllTypesOrdered(); allTypes.RemoveAll(x => x.IgnoreType(Config, includeList)); allTypes = FilterTypes(allTypes); //TypeScript doesn't support reusing same type name with different generic airity var conflictPartialNames = allTypes.Map(x => x.Name).Distinct() .GroupBy(g => g.LeftPart('`')) .Where(g => g.Count() > 1) .Select(g => g.Key) .ToList(); this.conflictTypeNames = allTypes .Where(x => conflictPartialNames.Any(name => x.Name.StartsWith(name))) .Map(x => x.Name); defaultImports.Each(x => sb.AppendLine("import {0};".Fmt(x))); if (!string.IsNullOrEmpty(globalNamespace)) { var moduleDef = Config.ExportAsTypes ? "export " : "declare "; sb.AppendLine(); sb.AppendLine("{0}module {1}".Fmt(moduleDef, globalNamespace.SafeToken())); sb.AppendLine("{"); sb = sb.Indent(); } //ServiceStack core interfaces foreach (var type in allTypes) { var fullTypeName = type.GetFullName(); if (requestTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName)) { MetadataType response = null; if (requestTypesMap.TryGetValue(type, out var operation)) { response = operation.Response; } lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { ImplementsFn = () => { if (!Config.AddReturnMarker && !type.ReturnVoidMarker && type.ReturnMarkerTypeName == null) { return(null); } if (type.ReturnVoidMarker) { return("IReturnVoid"); } if (type.ReturnMarkerTypeName != null) { return(Type("IReturn`1", new[] { Type(type.ReturnMarkerTypeName).InDeclarationType() })); } return(response != null ? Type("IReturn`1", new[] { Type(response.Name, response.GenericArgs).InDeclarationType() }) : null); }, IsRequest = true, }); existingTypes.Add(fullTypeName); } } else if (responseTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName) && !Config.IgnoreTypesInNamespaces.Contains(type.Namespace)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsResponse = true, }); existingTypes.Add(fullTypeName); } } else if (types.Contains(type) && !existingTypes.Contains(fullTypeName)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsType = true }); existingTypes.Add(fullTypeName); } } if (!string.IsNullOrEmpty(globalNamespace)) { sb = sb.UnIndent(); sb.AppendLine(); sb.AppendLine("}"); } return(StringBuilderCache.ReturnAndFree(sbInner)); }
public string GetCode(MetadataTypes metadata, IRequest request, INativeTypesMetadata nativeTypes) { var typeNamespaces = new HashSet<string>(); metadata.RemoveIgnoredTypes(Config); metadata.Types.Each(x => typeNamespaces.Add(x.Namespace)); metadata.Operations.Each(x => typeNamespaces.Add(x.Request.Namespace)); var defaultImports = !Config.DefaultImports.IsEmpty() ? Config.DefaultImports : DefaultImports; var globalNamespace = Config.GlobalNamespace; Func<string, string> defaultValue = k => request.QueryString[k].IsNullOrEmpty() ? "//" : ""; var sbInner = StringBuilderCache.Allocate(); var sb = new StringBuilderWrapper(sbInner); sb.AppendLine("/* Options:"); sb.AppendLine("Date: {0}".Fmt(DateTime.Now.ToString("s").Replace("T", " "))); sb.AppendLine("Version: {0}".Fmt(Env.ServiceStackVersion)); sb.AppendLine("Tip: {0}".Fmt(HelpMessages.NativeTypesDtoOptionsTip.Fmt("//"))); sb.AppendLine("BaseUrl: {0}".Fmt(Config.BaseUrl)); sb.AppendLine(); sb.AppendLine("{0}GlobalNamespace: {1}".Fmt(defaultValue("GlobalNamespace"), Config.GlobalNamespace)); //sb.AppendLine("{0}ExportAsTypes: {1}".Fmt(defaultValue("ExportAsTypes"), Config.ExportAsTypes)); sb.AppendLine("{0}MakePropertiesOptional: {1}".Fmt(defaultValue("MakePropertiesOptional"), Config.MakePropertiesOptional)); sb.AppendLine("{0}AddServiceStackTypes: {1}".Fmt(defaultValue("AddServiceStackTypes"), Config.AddServiceStackTypes)); sb.AppendLine("{0}AddResponseStatus: {1}".Fmt(defaultValue("AddResponseStatus"), Config.AddResponseStatus)); sb.AppendLine("{0}AddImplicitVersion: {1}".Fmt(defaultValue("AddImplicitVersion"), Config.AddImplicitVersion)); sb.AppendLine("{0}AddDescriptionAsComments: {1}".Fmt(defaultValue("AddDescriptionAsComments"), Config.AddDescriptionAsComments)); sb.AppendLine("{0}IncludeTypes: {1}".Fmt(defaultValue("IncludeTypes"), Config.IncludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}ExcludeTypes: {1}".Fmt(defaultValue("ExcludeTypes"), Config.ExcludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}DefaultImports: {1}".Fmt(defaultValue("DefaultImports"), defaultImports.Join(","))); sb.AppendLine("*/"); sb.AppendLine(); string lastNS = null; var existingTypes = new HashSet<string>(); var requestTypes = metadata.Operations.Select(x => x.Request).ToHashSet(); var requestTypesMap = metadata.Operations.ToSafeDictionary(x => x.Request); var responseTypes = metadata.Operations .Where(x => x.Response != null) .Select(x => x.Response).ToHashSet(); // Base Types need to be written first var types = CreateSortedTypeList(metadata.Types); allTypes = new List<MetadataType>(); allTypes.AddRange(types); allTypes.AddRange(responseTypes); allTypes.AddRange(requestTypes); allTypes.RemoveAll(x => x.IgnoreType(Config)); allTypes = FilterTypes(allTypes); //TypeScript doesn't support reusing same type name with different generic airity var conflictPartialNames = allTypes.Map(x => x.Name).Distinct() .GroupBy(g => g.LeftPart('`')) .Where(g => g.Count() > 1) .Select(g => g.Key) .ToList(); this.conflictTypeNames = allTypes .Where(x => conflictPartialNames.Any(name => x.Name.StartsWith(name))) .Map(x => x.Name); defaultImports.Each(x => sb.AppendLine("import {0};".Fmt(x))); if (!string.IsNullOrEmpty(globalNamespace)) { var moduleDef = Config.ExportAsTypes ? "" : "declare "; sb.AppendLine(); sb.AppendLine("{0}module {1}".Fmt(moduleDef, globalNamespace.SafeToken())); sb.AppendLine("{"); sb = sb.Indent(); } //ServiceStack core interfaces foreach (var type in allTypes) { var fullTypeName = type.GetFullName(); if (requestTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName)) { MetadataType response = null; MetadataOperationType operation; if (requestTypesMap.TryGetValue(type, out operation)) { response = operation.Response; } lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { ImplementsFn = () => { if (!Config.AddReturnMarker && !type.ReturnVoidMarker && type.ReturnMarkerTypeName == null) return null; if (type.ReturnVoidMarker) return "IReturnVoid"; if (type.ReturnMarkerTypeName != null) return Type("IReturn`1", new[] { Type(type.ReturnMarkerTypeName).InDeclarationType() }); return response != null ? Type("IReturn`1", new[] { Type(response.Name, response.GenericArgs).InDeclarationType() }) : null; }, IsRequest = true, }); existingTypes.Add(fullTypeName); } } else if (responseTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName) && !Config.IgnoreTypesInNamespaces.Contains(type.Namespace)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsResponse = true, }); existingTypes.Add(fullTypeName); } } else if (types.Contains(type) && !existingTypes.Contains(fullTypeName)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsType = true }); existingTypes.Add(fullTypeName); } } if (!string.IsNullOrEmpty(globalNamespace)) { sb = sb.UnIndent(); sb.AppendLine(); sb.AppendLine("}"); } return StringBuilderCache.ReturnAndFree(sbInner); }
private static List<MetadataType> GetAllMetadataTypes(MetadataTypes metadata) { var allTypes = new List<MetadataType>(); allTypes.AddRange(metadata.Types); allTypes.AddRange(metadata.Operations.Where(x => x.Request != null).Select(x => x.Request)); allTypes.AddRange(metadata.Operations.Where(x => x.Response != null).Select(x => x.Request)); return allTypes; }
private bool ReferencesGson(MetadataTypes metadata) { return(metadata.GetAllMetadataTypes().Any(x => KotlinGeneratorExtensions.KotlinKeyWords.Contains(x.Name) || x.Properties.Safe().Any(p => p.DataMember != null && p.DataMember.Name != null) || (x.RequestType?.ReturnType != null && x.RequestType?.ReturnType.Name.IndexOf('`') >= 0))); //uses TypeToken<T> }
static MetadataType FindMetadataType(MetadataTypes metadataTypes, Type type) { return(type == null ? null : FindMetadataType(metadataTypes, type.Name, type.Namespace)); }
public string GetCode(MetadataTypes metadata, IRequest request) { var typeNamespaces = new HashSet <string>(); RemoveIgnoredTypes(metadata); metadata.Types.Each(x => typeNamespaces.Add(x.Namespace)); metadata.Operations.Each(x => typeNamespaces.Add(x.Request.Namespace)); var defaultImports = !Config.DefaultImports.IsEmpty() ? Config.DefaultImports : DefaultImports; Func <string, string> defaultValue = k => request.QueryString[k].IsNullOrEmpty() ? "//" : ""; var sb = new StringBuilderWrapper(new StringBuilder()); var sbExt = new StringBuilderWrapper(new StringBuilder()); sb.AppendLine("/* Options:"); sb.AppendLine("Date: {0}".Fmt(DateTime.Now.ToString("s").Replace("T", " "))); sb.AppendLine("SwiftVersion: 2.0"); sb.AppendLine("Version: {0}".Fmt(Env.ServiceStackVersion)); sb.AppendLine("BaseUrl: {0}".Fmt(Config.BaseUrl)); sb.AppendLine(); sb.AppendLine("{0}BaseClass: {1}".Fmt(defaultValue("BaseClass"), Config.BaseClass)); sb.AppendLine("{0}AddModelExtensions: {1}".Fmt(defaultValue("AddModelExtensions"), Config.AddModelExtensions)); sb.AppendLine("{0}AddServiceStackTypes: {1}".Fmt(defaultValue("AddServiceStackTypes"), Config.AddServiceStackTypes)); sb.AppendLine("{0}IncludeTypes: {1}".Fmt(defaultValue("IncludeTypes"), Config.IncludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}ExcludeTypes: {1}".Fmt(defaultValue("ExcludeTypes"), Config.ExcludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}ExcludeGenericBaseTypes: {1}".Fmt(defaultValue("ExcludeGenericBaseTypes"), Config.ExcludeGenericBaseTypes)); sb.AppendLine("{0}AddResponseStatus: {1}".Fmt(defaultValue("AddResponseStatus"), Config.AddResponseStatus)); sb.AppendLine("{0}AddImplicitVersion: {1}".Fmt(defaultValue("AddImplicitVersion"), Config.AddImplicitVersion)); sb.AppendLine("{0}InitializeCollections: {1}".Fmt(defaultValue("InitializeCollections"), Config.InitializeCollections)); sb.AppendLine("{0}DefaultImports: {1}".Fmt(defaultValue("DefaultImports"), defaultImports.Join(","))); sb.AppendLine("*/"); sb.AppendLine(); string lastNS = null; var existingTypes = new HashSet <string>(); var requestTypes = metadata.Operations.Select(x => x.Request).ToHashSet(); var requestTypesMap = metadata.Operations.ToSafeDictionary(x => x.Request); var responseTypes = metadata.Operations .Where(x => x.Response != null) .Select(x => x.Response).ToHashSet(); var types = metadata.Types.ToHashSet(); AllTypes.AddRange(requestTypes); AllTypes.AddRange(responseTypes); AllTypes.AddRange(types); //Swift doesn't support reusing same type name with different generic airity var conflictPartialNames = AllTypes.Map(x => x.Name).Distinct() .GroupBy(g => g.SplitOnFirst('`')[0]) .Where(g => g.Count() > 1) .Select(g => g.Key) .ToList(); this.conflictTypeNames = AllTypes .Where(x => conflictPartialNames.Any(name => x.Name.StartsWith(name))) .Map(x => x.Name); defaultImports.Each(x => sb.AppendLine("import {0};".Fmt(x))); //ServiceStack core interfaces foreach (var type in AllTypes) { var fullTypeName = type.GetFullName(); if (requestTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName)) { MetadataType response = null; MetadataOperationType operation; if (requestTypesMap.TryGetValue(type, out operation)) { response = operation.Response; } lastNS = AppendType(ref sb, ref sbExt, type, lastNS, new CreateTypeOptions { ImplementsFn = () => { if (!Config.AddReturnMarker && !type.ReturnVoidMarker && type.ReturnMarkerTypeName == null) { return(null); } if (type.ReturnVoidMarker) { return("IReturnVoid"); } if (type.ReturnMarkerTypeName != null) { return(ReturnType("IReturn`1", new[] { Type(type.ReturnMarkerTypeName) })); } return(response != null ? ReturnType("IReturn`1", new[] { Type(response.Name, response.GenericArgs) }) : null); }, IsRequest = true, }); existingTypes.Add(fullTypeName); } } else if (responseTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName) && !Config.IgnoreTypesInNamespaces.Contains(type.Namespace)) { lastNS = AppendType(ref sb, ref sbExt, type, lastNS, new CreateTypeOptions { IsResponse = true, }); existingTypes.Add(fullTypeName); } } else if (types.Contains(type) && !existingTypes.Contains(fullTypeName)) { lastNS = AppendType(ref sb, ref sbExt, type, lastNS, new CreateTypeOptions { IsType = true }); existingTypes.Add(fullTypeName); } } if (Config.AddModelExtensions) { sb.AppendLine(); sb.AppendLine(sbExt.ToString()); } return(sb.ToString()); }
public string GetCode(MetadataTypes metadata, IRequest request) { var namespaces = Config.GetDefaultNamespaces(metadata); metadata.RemoveIgnoredTypesForNet(Config); if (!Config.ExcludeNamespace) { if (Config.GlobalNamespace == null) { metadata.Types.Each(x => namespaces.Add(x.Namespace)); metadata.Operations.Each(x => { namespaces.Add(x.Request.Namespace); if (x.Response != null) { namespaces.Add(x.Response.Namespace); } }); } else { namespaces.Add(Config.GlobalNamespace); } } string defaultValue(string k) => request.QueryString[k].IsNullOrEmpty() ? "//" : ""; var sbInner = StringBuilderCache.Allocate(); var sb = new StringBuilderWrapper(sbInner); sb.AppendLine("/* Options:"); sb.AppendLine("Date: {0}".Fmt(DateTime.Now.ToString("s").Replace("T", " "))); sb.AppendLine("Version: {0}".Fmt(Env.VersionString)); sb.AppendLine("Tip: {0}".Fmt(HelpMessages.NativeTypesDtoOptionsTip.Fmt("//"))); sb.AppendLine("BaseUrl: {0}".Fmt(Config.BaseUrl)); if (Config.UsePath != null) { sb.AppendLine("UsePath: {0}".Fmt(Config.UsePath)); } sb.AppendLine(); sb.AppendLine("{0}GlobalNamespace: {1}".Fmt(defaultValue("GlobalNamespace"), Config.GlobalNamespace)); sb.AppendLine("{0}MakePartial: {1}".Fmt(defaultValue("MakePartial"), Config.MakePartial)); sb.AppendLine("{0}MakeVirtual: {1}".Fmt(defaultValue("MakeVirtual"), Config.MakeVirtual)); sb.AppendLine("{0}MakeInternal: {1}".Fmt(defaultValue("MakeInternal"), Config.MakeInternal)); sb.AppendLine("{0}MakeDataContractsExtensible: {1}".Fmt(defaultValue("MakeDataContractsExtensible"), Config.MakeDataContractsExtensible)); sb.AppendLine("{0}AddReturnMarker: {1}".Fmt(defaultValue("AddReturnMarker"), Config.AddReturnMarker)); sb.AppendLine("{0}AddDescriptionAsComments: {1}".Fmt(defaultValue("AddDescriptionAsComments"), Config.AddDescriptionAsComments)); sb.AppendLine("{0}AddDataContractAttributes: {1}".Fmt(defaultValue("AddDataContractAttributes"), Config.AddDataContractAttributes)); sb.AppendLine("{0}AddIndexesToDataMembers: {1}".Fmt(defaultValue("AddIndexesToDataMembers"), Config.AddIndexesToDataMembers)); sb.AppendLine("{0}AddGeneratedCodeAttributes: {1}".Fmt(defaultValue("AddGeneratedCodeAttributes"), Config.AddGeneratedCodeAttributes)); sb.AppendLine("{0}AddResponseStatus: {1}".Fmt(defaultValue("AddResponseStatus"), Config.AddResponseStatus)); sb.AppendLine("{0}AddImplicitVersion: {1}".Fmt(defaultValue("AddImplicitVersion"), Config.AddImplicitVersion)); sb.AppendLine("{0}InitializeCollections: {1}".Fmt(defaultValue("InitializeCollections"), Config.InitializeCollections)); sb.AppendLine("{0}ExportValueTypes: {1}".Fmt(defaultValue("ExportValueTypes"), Config.ExportValueTypes)); sb.AppendLine("{0}IncludeTypes: {1}".Fmt(defaultValue("IncludeTypes"), Config.IncludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}ExcludeTypes: {1}".Fmt(defaultValue("ExcludeTypes"), Config.ExcludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}AddNamespaces: {1}".Fmt(defaultValue("AddNamespaces"), Config.AddNamespaces.Safe().ToArray().Join(","))); sb.AppendLine("{0}AddDefaultXmlNamespace: {1}".Fmt(defaultValue("AddDefaultXmlNamespace"), Config.AddDefaultXmlNamespace)); sb.AppendLine("*/"); sb.AppendLine(); namespaces.Where(x => !string.IsNullOrEmpty(x)) .Each(x => sb.AppendLine($"using {x};")); if (Config.AddGeneratedCodeAttributes) { sb.AppendLine("using System.CodeDom.Compiler;"); } if (Config.AddDataContractAttributes && Config.AddDefaultXmlNamespace != null) { sb.AppendLine(); namespaces.Where(x => !Config.DefaultNamespaces.Contains(x)).ToList() .ForEach(x => sb.AppendLine( $"[assembly: ContractNamespace(\"{Config.AddDefaultXmlNamespace}\", ClrNamespace=\"{x}\")]")); } sb.AppendLine(); string lastNS = null; var existingTypes = new HashSet <string>(); var requestTypes = metadata.Operations.Select(x => x.Request).ToSet(); var requestTypesMap = metadata.Operations.ToSafeDictionary(x => x.Request); var responseTypes = metadata.Operations .Where(x => x.Response != null) .Select(x => x.Response).ToSet(); var types = metadata.Types.ToSet(); allTypes = new List <MetadataType>(); allTypes.AddRange(requestTypes); allTypes.AddRange(responseTypes); allTypes.AddRange(types); allTypes = FilterTypes(allTypes); var orderedTypes = allTypes .OrderBy(x => x.Namespace) .ThenBy(x => x.Name) .ToList(); var insertCode = InsertCodeFilter?.Invoke(orderedTypes, Config); if (insertCode != null) { sb.AppendLine(insertCode); } foreach (var type in orderedTypes) { var fullTypeName = type.GetFullName(); if (requestTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName)) { MetadataType response = null; if (requestTypesMap.TryGetValue(type, out var operation)) { response = operation.Response; } lastNS = AppendType(ref sb, type, lastNS, allTypes, new CreateTypeOptions { Routes = metadata.Operations.GetRoutes(type), ImplementsFn = () => { if (!Config.AddReturnMarker && operation?.ReturnsVoid != true && operation?.ReturnType == null) { return(null); } if (operation?.ReturnsVoid == true) { return(nameof(IReturnVoid)); } if (operation?.ReturnType != null) { return(Type("IReturn`1", new[] { Type(operation.ReturnType) })); } return(response != null ? Type("IReturn`1", new[] { Type(response.Name, response.GenericArgs) }) : null); }, IsRequest = true, }); existingTypes.Add(fullTypeName); } } else if (responseTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName) && !Config.IgnoreTypesInNamespaces.Contains(type.Namespace)) { lastNS = AppendType(ref sb, type, lastNS, allTypes, new CreateTypeOptions { IsResponse = true, }); existingTypes.Add(fullTypeName); } } else if (types.Contains(type) && !existingTypes.Contains(fullTypeName)) { lastNS = AppendType(ref sb, type, lastNS, allTypes, new CreateTypeOptions { IsType = true }); existingTypes.Add(fullTypeName); } } var addCode = AddCodeFilter?.Invoke(orderedTypes, Config); if (addCode != null) { sb.AppendLine(addCode); } if (lastNS != null) { sb.AppendLine("}"); } sb.AppendLine(); return(StringBuilderCache.ReturnAndFree(sbInner)); }