public static string GetModelName(GenerationItemModel model, ObjectDefinitionBase objectDefinition, bool isInterface)
{
objectDefinition = GetDefinition(objectDefinition, model);
if (objectDefinition is EnumDefinition)
{
isInterface = false;
}
var translator = model.GetTranslator(objectDefinition);
if (translator == null)
{
if (objectDefinition.IsArray && objectDefinition.InnerObject != null)
{
return(string.Format("List<{0}>", GetModelName(model, objectDefinition.InnerObject, isInterface: isInterface)));
}
if (objectDefinition.IsInterface)
{
return(objectDefinition.Name.Substring(1, objectDefinition.Name.Length - 1).Replace("View", ""));
}
if (objectDefinition is EnumDefinition)
{
return(objectDefinition.FullName);
}
return(string.Format("{0}{1}", isInterface && !objectDefinition.IsInterface ? "I" : "", objectDefinition.Name.Replace("View", "")));
}
return(translator.Translation);
}
public override ObjectDefinitionBase Process(ObjectDefinitionBase output, ObjectBase input, IInputService service)
{
var methodProvider = this.Resolve <IMethodProvider>();
var propertyProvider = this.Resolve <IPropertyProvider>();
var structOutput = output as StructDefinition;
var structInput = input as Struct;
if (structOutput == null || structInput == null)
{
return(output);
}
if (structInput.Methods != null)
{
structOutput.Methods = structInput.Methods.Select(x => methodProvider.Process(methodProvider.Create(x), x, service)).ToList();
}
if (structInput.Properties != null)
{
structOutput.Properties = structInput.Properties.Select(x => propertyProvider.Process(propertyProvider.Create(x), x, service)).ToList();
}
if (structInput.GenericArguments != null)
{
structOutput.GenericArguments = structInput.GenericArguments.Select(x => service.GetObjectDefinitions().FirstOrDefault(o => o.FullName == x.FullName)).ToList();
}
return(base.Process(output, input, service));
}
protected override bool IsMatch(TypeMatcherConfiguration configuration, ObjectDefinitionBase objectDefinition)
{
if (configuration.Parameters.Length == 0)
throw new Exception("NameIn type expect an array of names.");
return configuration.Parameters.Contains(objectDefinition.Name);
}
public static string GetFileName(GenerationItemModel model, ObjectDefinitionBase objectDefinition, bool isInterface)
{
var namingRule = new SeparateWordsNamingRule();
var name = GetModelName(model, objectDefinition, isInterface: false);
if (objectDefinition.IsInterface)
{
name = name.Substring(1, name.Length - 1);
}
var newName = namingRule.Execute(name, new NamingRuleConfiguration()
{
Parameters = new[] { "-" }
}).ToLowerInvariant();
if (isInterface && objectDefinition is StructDefinition)
{
return(newName + ".interface");
}
if (isInterface && objectDefinition is EnumDefinition)
{
return(newName + ".enum");
}
return(newName);
}
public static string GetIsEqualCondition(ObjectDefinitionBase definition, string source, string destination)
{
var structDefinition = definition as StructDefinition;
if (structDefinition == null)
{
return(string.Empty);
}
var primaryKeys = GetPrimaryKeys(structDefinition);
if (!primaryKeys.Any())
{
return("true");
}
var builder = new System.Text.StringBuilder();
foreach (var property in primaryKeys)
{
builder.AppendFormat("{0}.{1} == {2}.{1} && ", source, property.Name, destination);
}
return(builder.Remove(builder.Length - 4, 4).ToString());
}
public GenerationItemModel(OutputFileConfiguration configuration, ObjectDefinitionBase definition, IEnumerable <ObjectDefinitionBase> definitions, INativeTypeTranslators typeTranslators)
{
this.Configuration = configuration;
this.Definition = definition;
this.Definitions = definitions;
this.TypeTranslators = typeTranslators;
}
public static string GetIsNewCondition(ObjectDefinitionBase definition)
{
var structDefinition = definition as StructDefinition;
if (structDefinition == null)
{
return(string.Empty);
}
var primaryKeys = GetPrimaryKeys(structDefinition);
if (!primaryKeys.Any())
{
return("true");
}
var builder = new System.Text.StringBuilder();
foreach (var property in primaryKeys)
{
builder.AppendFormat("this.{0} == default({1}) || ", property.Name, property.Type.Name);
}
return(builder.Remove(builder.Length - 4, 4).ToString());
}
public void Add(Type key, ObjectDefinitionBase definition)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
this.Definitions.Add(definition.FullName, definition);
}
public bool Match(TypeMatcherConfiguration configuration, ObjectDefinitionBase objectDefinition)
{
if (configuration.Negate)
{
return(!this.IsMatch(configuration, objectDefinition));
}
return(this.IsMatch(configuration, objectDefinition));
}
protected override bool IsMatch(TypeMatcherConfiguration configuration, ObjectDefinitionBase objectDefinition)
{
if (configuration.Parameters.Length != 1)
{
throw new Exception("Contains attribute type matcher has only 1 argument, the string to be found.");
}
return(objectDefinition.Attributes.Any(x => x.Name == configuration.Parameters[0]));
}
protected override bool IsMatch(TypeMatcherConfiguration configuration, ObjectDefinitionBase objectDefinition)
{
if (configuration.Parameters.Length != 0)
{
throw new Exception("Is Struct type matcher hasn't any arguments.");
}
return(objectDefinition.GetType() == typeof(StructDefinition));
}
protected override bool IsMatch(TypeMatcherConfiguration configuration, ObjectDefinitionBase objectDefinition)
{
if (configuration.Parameters.Length != 1)
{
throw new Exception("FullNameEquals type matcher has only 1 argument, the string to be found.");
}
return(objectDefinition.FullName.Equals(configuration.Parameters[0]));
}
protected override bool IsMatch(TypeMatcherConfiguration configuration, ObjectDefinitionBase objectDefinition)
{
if (configuration.Parameters.Length < 1)
{
throw new Exception("NameEndsWith type matcher needs at least 1 parameter.");
}
return(configuration.Parameters.Aggregate(false, (current, parameter) => current || objectDefinition.Name.EndsWith(parameter)));
}
public static ObjectDefinitionBase GetDefinition(ObjectDefinitionBase objectDefinition, GenerationItemModel model)
{
if (objectDefinition.FullName.StartsWith("System.Threading.Tasks.Task"))
{
var structDefinition = objectDefinition as StructDefinition;
return(structDefinition.GenericArguments.FirstOrDefault() ?? model.Definitions.FirstOrDefault(x => x.FullName == "System.Void"));
}
return(objectDefinition);
}
public static bool RequiresQuotationMarks(ObjectDefinitionBase objectDefinition)
{
var name = IsNullable(objectDefinition) && objectDefinition.InnerObject != null ? objectDefinition.InnerObject.Name : objectDefinition.Name;
return(name == "String" ||
name == "Char" ||
name == "DateTime" ||
name == "TimeSpan" ||
name == "Object");
}
public static bool InheritsFrom(this ObjectDefinitionBase definition, string name)
{
if (definition == null)
{
throw new ArgumentNullException(nameof(definition));
}
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
return(definition.FindInHierarchy(name) != null);
}
public static string GetModelName(GenerationItemModel model, ObjectDefinitionBase objectDefinition, bool isInterface = false)
{
if (objectDefinition is EnumDefinition)
{
isInterface = false;
}
var translator = model.GetTranslator(objectDefinition);
if (translator == null)
{
return(objectDefinition.IsArray && objectDefinition.InnerObject != null
? $"{(isInterface ? "IReadOnlyCollection" : "List")}<{GetModelName(model, objectDefinition.InnerObject, isInterface: isInterface)}>"
: $"{(isInterface ? "I" : "")}{(isInterface ? objectDefinition.Name.Replace("View", string.Empty) : objectDefinition.Name)}");
}
return(translator.Translation);
}
public override ObjectDefinitionBase Process(ObjectDefinitionBase output, ObjectBase input, IInputService service)
{
var enumValueProvider = this.Resolve <IEnumValueProvider>();
var enumOutput = output as EnumDefinition;
var enumInput = input as Enum;
if (enumOutput == null || enumInput == null)
{
return(output);
}
if (enumInput.Values != null)
{
enumOutput.Values = enumInput.Values.Select(x => enumValueProvider.Process(enumValueProvider.Create(x), x, service)).ToList();
}
return(base.Process(output, input, service));
}
private static ObjectDefinitionBase FindInHierarchy(this ObjectDefinitionBase definition, string name, bool includeItself = false)
{
if (definition == null)
{
throw new ArgumentNullException(nameof(definition));
}
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if ((definition.FullName == name || definition.Name == name) && includeItself)
{
return(definition);
}
// search first in the base class hierarchy.
if (definition.BaseType != null)
{
var result = FindInHierarchy(definition.BaseType, name, true);
if (result != null)
{
return(result);
}
}
// then search in each implemented interface hierarchy.
if (definition.ImplementedInterfaces != null && definition.ImplementedInterfaces.Any())
{
foreach (var implemented in definition.ImplementedInterfaces)
{
var result = FindInHierarchy(implemented, name, true);
if (result != null)
{
return(result);
}
}
}
return(null);
}
public static string GetMapMethod(ObjectDefinitionBase objectDefinition)
{
var type = IsNullable(objectDefinition) && objectDefinition.InnerObject != null ? objectDefinition.InnerObject : objectDefinition;
if (type.Name == typeof(Byte[]).Name || type.Name == typeof(SByte[]).Name)
{
return("GetBytes");
}
if (type.Name == typeof(float).Name || type.Name == typeof(System.Single).Name)
{
return("GetFloat");
}
if (type.Name == typeof(DateTimeOffset).Name)
{
return("GetDateTime");
}
return($"Get{type.Name}");
}
public override ObjectDefinitionBase Process(ObjectDefinitionBase definition, IObjectDefinitions <Type> objectDefinitions, Type parameter)
{
base.Process(definition, objectDefinitions, parameter);
var attributeProvider = this.Resolve <IAttributeDefinitionProvider <Attribute, Type> >();
var propertyProvider = this.Resolve <IPropertyDefinitionProvider <PropertyInfo, Type> >();
var methodProvider = this.Resolve <IMethodDefinitionProvider <MethodInfo, Type> >();
var typeInfo = parameter.GetTypeInfo();
var structDefinition = definition as StructDefinition;
if (structDefinition == null)
{
return(definition);
}
typeInfo.GetCustomAttributes()
.Select(x => attributeProvider.Process(attributeProvider.GetFromSource(x), objectDefinitions, x))
.ToList()
.ForEach(x => structDefinition.AddAttribute(x));
typeInfo.DeclaredProperties
.Where(x => (x.GetMethod?.IsPublic ?? false) || (x.SetMethod?.IsPublic ?? false))
.Select(x => propertyProvider.Process(propertyProvider.GetFromSource(x), objectDefinitions, x))
.ToList()
.ForEach(x => structDefinition.AddProperty(x));
typeInfo.DeclaredMethods
.Where(x => !x.IsSpecialName && x.IsPublic)
.Select(x => methodProvider.Process(methodProvider.GetFromSource(x), objectDefinitions, x))
.ToList()
.ForEach(x => structDefinition.AddMethod(x));
typeInfo.GenericTypeArguments
.Select(objectDefinitions.Get)
.ToList()
.ForEach(x => structDefinition.AddGenericArgument(x));
return(structDefinition);
}
public static bool IsGenericNullable(ObjectDefinitionBase objectDefinition)
{
return(objectDefinition.Name.StartsWith("Nullable<"));
}
public static string GetServiceName(ObjectDefinitionBase objectDefinition, bool isInterface)
{
return(string.Format("{0}{1}", isInterface ? "I" : "", objectDefinition.Name.Replace("Controller", "Service")));
}
protected abstract bool IsMatch(TypeMatcherConfiguration configuration, ObjectDefinitionBase objectDefinition);
public NativeTypeTranslator GetTranslator(ObjectDefinitionBase definition)
{
return(this.TypeTranslators.Find(x => x.Name == definition.FullName || x.Name == definition.Name).FirstOrDefault());
}
public static bool IsNullable(ObjectDefinitionBase objectDefinition)
{
return(objectDefinition.Name.StartsWith("Nullable<") || objectDefinition.Name == "String" || objectDefinition.IsArray);
}
public static IEnumerable <ObjectDefinitionBase> GetModelRelatedContracts(GenerationItemModel model, ObjectDefinitionBase definition, List <PropertyDefinition> properties)
{
var contracts = new Dictionary <string, ObjectDefinitionBase>();
foreach (var property in properties)
{
var objectDefinition = GetDefinition(property.Type, model);
if (objectDefinition.IsArray)
{
objectDefinition = objectDefinition.InnerObject;
}
var translator = model.GetTranslator(objectDefinition);
if (objectDefinition.Name != definition.Name &&
!contracts.ContainsKey(objectDefinition.Name) &&
translator == null)
{
contracts.Add(objectDefinition.Name, objectDefinition);
}
}
return(contracts.Values.ToList());
}
public static IEnumerable <ObjectDefinitionBase> GetServiceRelatedContracts(GenerationItemModel model, ObjectDefinitionBase definition)
{
var contracts = new Dictionary <string, ObjectDefinitionBase>();
var classDefinition = definition as StructDefinition;
if (classDefinition == null)
{
return(contracts.Values);
}
foreach (var method in classDefinition.Methods)
{
var objectDefinition = GetDefinition(method.ReturnType, model);
if (objectDefinition.IsArray)
{
objectDefinition = objectDefinition.InnerObject;
}
var translator = model.GetTranslator(objectDefinition);
if (!contracts.ContainsKey(objectDefinition.Name) &&
translator == null)
{
contracts.Add(objectDefinition.Name, objectDefinition);
}
foreach (var parameter in method.Parameters)
{
objectDefinition = GetDefinition(parameter.Type, model);
if (objectDefinition.IsArray)
{
objectDefinition = objectDefinition.InnerObject;
}
translator = model.GetTranslator(objectDefinition);
if (!contracts.ContainsKey(objectDefinition.Name) &&
translator == null)
{
contracts.Add(objectDefinition.Name, objectDefinition);
}
}
}
return(contracts.Values.ToList());
}
private static bool IsMatch(ObjectDefinitionBase objectDefinition, OutputFileConfiguration outputConfiguration)
{
return(outputConfiguration.TypeMatchers.Any() &&
outputConfiguration.TypeMatchers.Aggregate(true, (current, typeMatcherConfiguration) => current & TypeMatcherFactory.Create(typeMatcherConfiguration.Name).Match(typeMatcherConfiguration, objectDefinition)));
}
public static List <PropertyDefinition> GetProperties(ObjectDefinitionBase definition)
{
return((definition as StructDefinition).Properties.Where(x => x.Attributes.Any(a => a.Name == "DataMemberAttribute")).ToList());
}
