/// <summary>
/// To specify that this (primtive) property is a reference to another model found from another API or service
/// </summary>
/// <typeparam name="TS"></typeparam>
/// <param name="serviceName"></param>
/// <param name="node"></param>
/// <returns></returns>
public AnalyticalChild <TParent, T> GetFromService <TS>(string serviceName, AnalyticalObject <TS> node) where TS : class
{
PopulateServiceMaps(serviceName, parentName + "_" + Name, node.Name);
foreach (var entry in node.TypeMap)
{
this.TypeMap.Add(entry);
}
return(this);
}
/// <summary>
/// Pass in a property by LINQ expression so that it can be defined by modifying the resulting AnalyticalChild
/// The AnalyticalChild constructor will try to guess the type.
/// </summary>
/// <typeparam name="TProperty">Type of property to be defined</typeparam>
/// <param name="propertyExpression"></param>
/// <param name="directParent">Direct parent, this should not be set by the user</param>
/// <returns></returns>
public AnalyticalChild <T, TProperty> Property <TProperty>(Expression <Func <T, TProperty> > propertyExpression,
AnalyticalObject <T> directParent = null)
{
var expression = (MemberExpression)propertyExpression.Body;
string name = expression.Member.Name;
Type childType = propertyExpression.ReturnType;
var child = new AnalyticalChild <T, TProperty>(directParent ?? this, name, childType, this.TypeMap);
return(child);
}
/// <summary>
/// Defines an AnalyticalChild and tries to guess the type if it's a primtive type or string. It adds its parents and grandparents to keep track of them.
/// </summary>
/// <param name="analyticalObject"></param>
/// <param name="childName"></param>
/// <param name="childType"></param>
/// <param name="typeMapsReference"></param>
/// <param name="grandParentName"></param>
public AnalyticalChild(AnalyticalObject <TParent> analyticalObject, string childName, Type childType, TypeMap typeMapsReference = null, string grandParentName = null) : base(analyticalObject.TypeMap)
{
this.DirectParent = analyticalObject;
this.Name = childName;
this.childType = childType;
this.parentName = grandParentName == null? analyticalObject.Name : grandParentName + "_" + analyticalObject.Name;
this.TypeMap = typeMapsReference ?? base.TypeMap;
if (TypeUtils.TryGuessInternalType(childType, out this.sqlType))
{
PopulateTypeMaps(sqlType, childName);
}
}
/// <summary>
/// Override default behavior to modify parent passing
/// </summary>
/// <typeparam name="TProperty"></typeparam>
/// <param name="propertyExpression"></param>
/// <param name="directParent"></param>
/// <returns></returns>
public new AnalyticalChild <T, TProperty> Property <TProperty>(Expression <Func <T, TProperty> > propertyExpression,
AnalyticalObject <T> directParent = null)
{
var expression = (MemberExpression)propertyExpression.Body;
string name = expression.Member.Name;
Type childType = propertyExpression.ReturnType;
AnalyticalChild <T, TProperty> child;
// Passing the type maps down to the child, so that all children/grandchildren share the same type dictionary
child = new AnalyticalChild <T, TProperty>(this, name, childType, this.TypeMap, this.parentName);
return(child);
}
/// <summary>
/// To specify that this (primtive) property is a reference to another model found from another API or service
/// </summary>
/// <typeparam name="TS"></typeparam>
/// <param name="serviceName"></param>
/// <param name="node"></param>
/// <returns></returns>
public AnalyticalChild <TParent, T> GetFromService <TS>(string serviceName, AnalyticalObject <TS> node)
where TS : class
{
PopulateTypeMaps(new NodeProperties()
{
ServiceName = serviceName,
NodeName = node.Name,
}, parentName, Name, true);
foreach (var entry in node.TypeMap)
{
string key = Namer.EnsureMinimumUniqueKey(Name.ToLower() + "_" + entry.Key, TypeMap, true);
TypeMap[key] = entry.Value;
}
return(this);
}
/// <summary>
/// Defines an AnalyticalChild and tries to guess the type if it's a primtive type or string. It adds its parents and grandparents to keep track of them.
/// </summary>
/// <param name="analyticalObject"></param>
/// <param name="childName"></param>
/// <param name="childType"></param>
/// <param name="typeMapsReference"></param>
/// <param name="grandParentName"></param>
public AnalyticalChild(AnalyticalObject <TParent> analyticalObject, string childName, Type childType,
TypeMap typeMapsReference = null, string grandParentName = null)
: base(analyticalObject.TypeMap, analyticalObject.minimumKeyToHierarchy)
{
this.DirectParent = analyticalObject;
this.Name = childName;
this.childType = childType;
this.parentName = grandParentName == null
? analyticalObject.Name
: grandParentName + "_" + analyticalObject.Name;
this.TypeMap = typeMapsReference ?? base.TypeMap;
if (TypeUtils.TryGuessInternalType(childType, out this.sqlType))
{
base.PopulateTypeMaps(
new NodeProperties()
{
InternalType = sqlType
},
parentName, childName, true);
}
}
public AnalyticalChild <T, TProperty> Property <TProperty>(string propertyName, AnalyticalObject <TProperty> type)
{
var child = new AnalyticalChild <T, TProperty>(this, propertyName, type.AnalyzedType, this.TypeMap);
PopulateTypeMaps(new NodeProperties()
{
InternalType = InternalType.NEVER
}, Name, propertyName);
foreach (var kv in type.TypeMap)
{
PopulateTypeMaps(kv.Value, $"{propertyName}_{kv.Key}", true);
}
return(child);
}