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>
}
private void RemoveIgnoredTypes(MetadataTypes metadata)
{
metadata.RemoveIgnoredTypes(Config);
metadata.Types.RemoveAll(x => IgnoreTypeNames.Contains(x.Name));
}
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));
}
