private static string createDbSetMethods(DbSetInfo dbSetInfo, string tableName)
{
var sb = new StringBuilder(512);
sb.AppendLine(string.Format("#region {0}", dbSetInfo.dbSetName));
sb.AppendLine("[Query]");
sb.AppendFormat("public QueryResult<{0}> Read{1}()", dbSetInfo.EntityType.Name, dbSetInfo.dbSetName);
sb.AppendLine("");
sb.AppendLine("{");
sb.AppendLine("\tint? totalCount = null;");
sb.AppendLine(string.Format("\tvar res = this.QueryHelper.PerformQuery(this.DB.{0}, this.CurrentQueryInfo, ref totalCount).AsEnumerable();", tableName));
sb.AppendLine(string.Format("\treturn new QueryResult<{0}>(res, totalCount);",dbSetInfo.EntityType.Name));
sb.AppendLine("}");
sb.AppendLine("");
sb.AppendLine("[Insert]");
sb.AppendFormat("public void Insert{1}({0} {2})", dbSetInfo.EntityType.Name, dbSetInfo.dbSetName, dbSetInfo.dbSetName.ToLower());
sb.AppendLine("");
sb.AppendLine("{");
sb.AppendLine(string.Format("\tif (({0}.EntityState != EntityState.Detached))", dbSetInfo.dbSetName.ToLower()));
sb.AppendLine("\t{");
sb.AppendLine(string.Format("\t\tthis.DB.ObjectStateManager.ChangeObjectState({0}, EntityState.Added);",dbSetInfo.dbSetName.ToLower()));
sb.AppendLine("\t}");
sb.AppendLine("\telse");
sb.AppendLine("\t{");
sb.AppendLine(string.Format("\t\tthis.DB.{0}.AddObject({1});", tableName, dbSetInfo.dbSetName.ToLower()));
sb.AppendLine("\t}");
sb.AppendLine("}");
sb.AppendLine("");
sb.AppendLine("[Update]");
sb.AppendFormat("public void Update{1}({0} {2})", dbSetInfo.EntityType.Name, dbSetInfo.dbSetName, dbSetInfo.dbSetName.ToLower());
sb.AppendLine("");
sb.AppendLine("{");
sb.AppendLine(string.Format("\t{0} orig = this.GetOriginal<{0}>();", dbSetInfo.EntityType.Name));
sb.AppendLine(string.Format("\tthis.DB.{0}.Attach({1});", tableName, dbSetInfo.dbSetName.ToLower()));
sb.AppendLine(string.Format("\tthis.DB.{0}.ApplyOriginalValues(orig);", tableName));
sb.AppendLine("}");
sb.AppendLine("");
sb.AppendLine("[Delete]");
sb.AppendFormat("public void Delete{1}({0} {2})", dbSetInfo.EntityType.Name, dbSetInfo.dbSetName, dbSetInfo.dbSetName.ToLower());
sb.AppendLine("");
sb.AppendLine("{");
sb.AppendLine(string.Format("\tif (({0}.EntityState != EntityState.Detached))", dbSetInfo.dbSetName.ToLower()));
sb.AppendLine("\t{");
sb.AppendLine(string.Format("\t\tthis.DB.ObjectStateManager.ChangeObjectState({0}, EntityState.Deleted);", dbSetInfo.dbSetName.ToLower()));
sb.AppendLine("\t}");
sb.AppendLine("\telse");
sb.AppendLine("\t{");
sb.AppendLine(string.Format("\t\tthis.DB.{0}.Attach({1});", tableName, dbSetInfo.dbSetName.ToLower()));
sb.AppendLine(string.Format("\t\tthis.DB.{0}.DeleteObject({1});", tableName, dbSetInfo.dbSetName.ToLower()));
sb.AppendLine("\t}");
sb.AppendLine("}");
sb.AppendLine("");
sb.AppendLine("#endregion");
return sb.ToString();
}
public RowGenerator(DbSetInfo dbSetInfo, IEnumerable<object> dataSource, IDataHelper dataHelper)
{
this._dbSetInfo = dbSetInfo;
this._dataSource = dataSource;
this._dataHelper = dataHelper;
this.fieldInfos = this._dbSetInfo.GetInResultFields();
this.fieldCnt = this.fieldInfos.Length;
this.pkInfos = this._dbSetInfo.GetPKFields();
}
private void CreateIncludedResult(DbSetInfo dbSetInfo, IEnumerable<object> inputEntities, string propertyName, string[] nextParts, Dictionary<string, IncludedResult> visited)
{
var metadata = MetadataHelper.EnsureMetadataInitialized(this._domainService);
bool isChildProperty = false;
DbSetInfo nextDbSetInfo = null;
var assoc = metadata.associations.Values.Where(a => a.parentDbSetName == dbSetInfo.dbSetName && a.parentToChildrenName == propertyName).FirstOrDefault();
if (assoc != null)
{
isChildProperty = true;
nextDbSetInfo = metadata.dbSets[assoc.childDbSetName];
}
else
{
assoc = metadata.associations.Values.Where(a => a.childDbSetName == dbSetInfo.dbSetName && a.childToParentName == propertyName).FirstOrDefault();
if (assoc == null)
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_INCL_NAVIG_INVALID, propertyName + (nextParts.Length > 0 ? ("." + string.Join(".", nextParts)) : "")));
}
nextDbSetInfo = metadata.dbSets[assoc.parentDbSetName];
}
if (visited.ContainsKey(nextDbSetInfo.dbSetName + "." + propertyName))
return;
int rowCount = 0;
object propValue;
LinkedList<object> resultEntities = new LinkedList<object>();
foreach (object entity in inputEntities)
{
propValue = this._dataHelper.GetValue(entity, propertyName, true);
if (isChildProperty && propValue is IEnumerable)
{
foreach (object childEntity in (IEnumerable)propValue)
{
resultEntities.AddLast(childEntity);
++rowCount;
}
}
else if (!isChildProperty && propValue != null)
{
resultEntities.AddLast(propValue);
++rowCount;
}
}
//create temporary result without rows
//fills rows at the end of the method
IncludedResult current = new IncludedResult { dbSetName = nextDbSetInfo.dbSetName, rows = new Row[0], names = nextDbSetInfo.GetNames() };
visited.Add(nextDbSetInfo.dbSetName + "." + propertyName, current);
if (nextParts.Length > 0)
this.CreateIncludedResult(nextDbSetInfo, resultEntities, nextParts[0], nextParts.Skip(1).ToArray(), visited);
RowGenerator rowGenerator = new RowGenerator(nextDbSetInfo, resultEntities, this._dataHelper);
current.rows = rowGenerator.CreateDistinctRows(ref rowCount);
current.rowCount = rowCount;
}
public IEnumerable<IncludedResult> CreateIncludedResults(DbSetInfo dbSetInfo, IEnumerable<object> entities, string[] includePaths)
{
if (includePaths.Length == 0)
return Enumerable.Empty<IncludedResult>();
Dictionary<string, IncludedResult> visited = new Dictionary<string, IncludedResult>();
var metadata = MetadataHelper.EnsureMetadataInitialized(this._domainService);
foreach (string includePath in includePaths)
{
string[] pathParts = includePath.Split('.');
string[] nextParts = pathParts.Skip(1).ToArray();
this.CreateIncludedResult(dbSetInfo, entities, pathParts[0], nextParts, visited);
}
return visited.Values;
}
public static Metadata FromXML(string xml)
{
Metadata metadata = new Metadata();
XDocument xdoc = XDocument.Parse(xml);
XElement xmetadata = xdoc.Element(NS_DATA + "Metadata");
XElement xdbSets = xmetadata.Element(NS_DATA + "Metadata.DbSets");
if (xdbSets != null)
{
foreach (var xdbSet in xdbSets.Elements(NS_DATA + "DbSetInfo"))
{
string xType = (string)xdbSet.Attribute("EntityType").Value;
Type _entityType = _GetTypeFromXType(xType, xdoc);
DbSetInfo dbSetInfo = new DbSetInfo()
{
dbSetName = (string)xdbSet.Attribute("dbSetName"),
EntityType = _entityType,
insertDataMethod = (string)xdbSet.Attribute("insertDataMethod"),
updateDataMethod = (string)xdbSet.Attribute("updateDataMethod"),
deleteDataMethod = (string)xdbSet.Attribute("deleteDataMethod"),
refreshDataMethod = (string)xdbSet.Attribute("refreshDataMethod"),
validateDataMethod = (string)xdbSet.Attribute("validateDataMethod")
};
if (xdbSet.Attributes("enablePaging").Any())
dbSetInfo.enablePaging = (bool)xdbSet.Attribute("enablePaging");
if (xdbSet.Attributes("pageSize").Any())
dbSetInfo.pageSize = (int)xdbSet.Attribute("pageSize");
if (xdbSet.Attributes("isTrackChanges").Any())
dbSetInfo.isTrackChanges = (bool)xdbSet.Attribute("isTrackChanges");
if (xdbSet.Attributes("FetchSize").Any())
dbSetInfo.FetchSize = (int)xdbSet.Attribute("FetchSize");
metadata.DbSets.Add(dbSetInfo);
XElement xFields = xdbSet.Element(NS_DATA + "DbSetInfo.fieldInfos");
IEnumerable<XElement> fields = xFields.Elements(NS_DATA + "Field");
dbSetInfo.fieldInfos.AddRange(_XElementsToFieldList(fields));
}
}
XElement xAssocs = xmetadata.Element(NS_DATA + "Metadata.Associations");
if (xAssocs != null)
{
foreach (var xAssoc in xAssocs.Elements(NS_DATA + "Association"))
{
Association assoc = new Association() {
name=(string)xAssoc.Attribute("name")
};
if (xAssoc.Attributes("parentDbSetName").Any())
assoc.parentDbSetName = (string)xAssoc.Attribute("parentDbSetName");
if (xAssoc.Attributes("childDbSetName").Any())
assoc.childDbSetName = (string)xAssoc.Attribute("childDbSetName");
if (xAssoc.Attributes("childToParentName").Any())
assoc.childToParentName = (string)xAssoc.Attribute("childToParentName");
if (xAssoc.Attributes("parentToChildrenName").Any())
assoc.parentToChildrenName = (string)xAssoc.Attribute("parentToChildrenName");
if (xAssoc.Attributes("onDeleteAction").Any())
assoc.onDeleteAction = (DeleteAction)Enum.Parse(typeof(DeleteAction), xAssoc.Attribute("onDeleteAction").Value);
XElement xFieldRels = xAssoc.Element(NS_DATA + "Association.fieldRels");
if (xFieldRels != null)
{
foreach (var xFieldRel in xFieldRels.Elements(NS_DATA + "FieldRel"))
{
FieldRel fldRel = new FieldRel()
{
parentField = (string)xFieldRel.Attribute("parentField"),
childField = (string)xFieldRel.Attribute("childField")
};
assoc.fieldRels.Add(fldRel);
}
}
metadata.Associations.Add(assoc);
}
}
return metadata;
}
private string createEntityType(DbSetInfo dbSetInfo)
{
var sb = new StringBuilder(512);
var dbSetType = GetDbSetTypeName(dbSetInfo.dbSetName);
var entityName = GetEntityName(dbSetInfo.dbSetName);
var entityInterfaceName = GetEntityInterfaceName(dbSetInfo.dbSetName);
var entityType = GetEntityTypeName(dbSetInfo.dbSetName);
var fieldInfos = dbSetInfo.fieldInfos;
var sbFields = new StringBuilder(512);
var sbFields2 = new StringBuilder(512);
var sbFieldsDef = new StringBuilder();
var sbFieldsInit = new StringBuilder();
if (this._dotNet2TS.IsTypeNameRegistered(entityType))
throw new ApplicationException(string.Format("Names collision. Name '{0}' can not be used for an entity type's name because this name is used for a client's type.", entityInterfaceName));
Action<Field> AddCalculatedField = (Field f) =>
{
string dataType = this.GetFieldDataType(f);
sbFields.AppendFormat("\tget {0}(): {1} {{ return this._aspect._getCalcFieldVal('{0}'); }}", f.fieldName, dataType);
sbFields.AppendLine();
sbFields2.AppendFormat("\t{0}: {1};", f.fieldName, dataType);
sbFields2.AppendLine();
};
Action<Field> AddNavigationField = (Field f) =>
{
string dataType = this.GetFieldDataType(f);
sbFields.AppendFormat("\tget {0}(): {1} {{ return this._aspect._getNavFieldVal('{0}'); }}", f.fieldName, dataType);
sbFields.AppendLine();
//no writable properties to ParentToChildren navigation fields
if (!dataType.EndsWith("[]"))
{
sbFields.AppendFormat("\tset {0}(v: {1}) {{ this._aspect._setNavFieldVal('{0}',v); }}", f.fieldName, dataType);
sbFields.AppendLine();
}
sbFields2.AppendFormat("\t{0}: {1};", f.fieldName, dataType);
sbFields2.AppendLine();
};
Action<Field> AddComplexTypeField = (Field f) =>
{
string dataType = this.GetFieldDataType(f);
sbFields.AppendFormat("\tget {0}(): {1} {{ if (!this._{0}) {{this._{0} = new {1}('{0}', this._aspect);}} return this._{0}; }}", f.fieldName, dataType);
sbFields.AppendLine();
sbFieldsDef.AppendFormat("\tprivate _{0}: {1};", f.fieldName, dataType);
sbFieldsDef.AppendLine();
sbFieldsInit.AppendFormat("\t\tthis._{0} = null;", f.fieldName);
sbFieldsInit.AppendLine();
sbFields2.AppendFormat("\t{0}: {1};", f.fieldName, dataType);
sbFields2.AppendLine();
};
Action<Field> AddSimpleField = (Field f) =>
{
string dataType = this.GetFieldDataType(f);
sbFields.AppendFormat("\tget {0}(): {1} {{ return this._aspect._getFieldVal('{0}'); }}", f.fieldName, dataType);
sbFields.AppendLine();
if (!f.isReadOnly)
{
sbFields.AppendFormat("\tset {0}(v: {1}) {{ this._aspect._setFieldVal('{0}',v); }}", f.fieldName, dataType);
sbFields.AppendLine();
}
sbFields2.AppendFormat("\t{0}: {1};", f.fieldName, dataType);
sbFields2.AppendLine();
};
fieldInfos.ForEach((fieldInfo) =>
{
if (fieldInfo.fieldType == FieldType.Calculated)
{
AddCalculatedField(fieldInfo);
}
else if (fieldInfo.fieldType == FieldType.Navigation)
{
AddNavigationField(fieldInfo);
}
else if (fieldInfo.fieldType == FieldType.Object)
{
AddComplexTypeField(fieldInfo);
}
else
{
AddSimpleField(fieldInfo);
}
});
(new TemplateParser("Entity.txt")).ProcessParts((part) =>
{
if (!part.isPlaceHolder)
{
sb.Append(part.value);
}
else
{
switch (part.value)
{
case "DBSET_NAME":
sb.Append(dbSetInfo.dbSetName);
break;
case "DBSET_TYPE":
sb.Append(dbSetType);
break;
case "ENTITY_NAME":
sb.Append(entityName);
break;
case "ENTITY_TYPE":
sb.Append(entityType);
break;
case "ENTITY_INTERFACE":
sb.Append(entityInterfaceName);
break;
case "ENTITY_FIELDS":
sb.Append(sbFields.ToString());
break;
case "INTERFACE_FIELDS":
sb.Append(sbFields2.ToString());
break;
case "FIELDS_DEF":
sb.Append(sbFieldsDef.ToString());
break;
case "FIELDS_INIT":
sb.Append(sbFieldsInit.ToString());
break;
}
}
});
return sb.ToString();
}
private string createDbSetType(DbSetInfo dbSetInfo)
{
var sb = new StringBuilder(512);
var dbSetType = GetDbSetTypeName(dbSetInfo.dbSetName);
var entityName = GetEntityName(dbSetInfo.dbSetName);
var entityType = GetEntityTypeName(dbSetInfo.dbSetName);
var entityInterfaceName = GetEntityInterfaceName(dbSetInfo.dbSetName);
var childAssoc = this._metadata.associations.Where(assoc => assoc.childDbSetName == dbSetInfo.dbSetName).ToList();
var parentAssoc = this._metadata.associations.Where(assoc => assoc.parentDbSetName == dbSetInfo.dbSetName).ToList();
var fieldInfos = dbSetInfo.fieldInfos;
var pkFields = dbSetInfo.GetPKFields();
string pkVals = "";
foreach (var pkField in pkFields)
{
if (!string.IsNullOrEmpty(pkVals))
pkVals += ", ";
pkVals += toCamelCase(pkField.fieldName) + ": " + this.GetFieldDataType(pkField);
}
(new TemplateParser("DbSet.txt")).ProcessParts((part) =>
{
if (!part.isPlaceHolder)
{
sb.Append(part.value);
}
else
{
switch (part.value)
{
case "DBSET_NAME":
sb.Append(dbSetInfo.dbSetName);
break;
case "DBSET_TYPE":
sb.Append(dbSetType);
break;
case "ENTITY_NAME":
sb.Append(entityName);
break;
case "ENTITY_TYPE":
sb.Append(entityType);
break;
case "ENTITY_INTERFACE":
{
sb.Append(entityInterfaceName);
}
break;
case "DBSET_INFO":
{
dbSetInfo._fieldInfos = null;
sb.Append(this._serviceContainer.Serializer.Serialize(dbSetInfo));
dbSetInfo._fieldInfos = fieldInfos;
}
break;
case "FIELD_INFOS":
{
sb.Append(this._serviceContainer.Serializer.Serialize(dbSetInfo.fieldInfos));
}
break;
case "CHILD_ASSOC":
sb.Append(this._serviceContainer.Serializer.Serialize(childAssoc));
break;
case "PARENT_ASSOC":
sb.Append(this._serviceContainer.Serializer.Serialize(parentAssoc));
break;
case "QUERIES":
sb.Append(this.createDbSetQueries(dbSetInfo));
break;
case "CALC_FIELDS":
sb.Append(this.createCalcFields(dbSetInfo));
break;
case "PK_VALS":
sb.Append(pkVals);
break;
}
}
});
return sb.ToString();
}
private string createCalcFields(DbSetInfo dbSetInfo)
{
var entityType = GetEntityTypeName(dbSetInfo.dbSetName);
var sb = new StringBuilder(256);
dbSetInfo.fieldInfos.ForEach((fieldInfo) =>
{
this._serviceContainer.DataHelper.ForEachFieldInfo("", fieldInfo, (fullName, f) =>
{
if (f.fieldType == FieldType.Calculated)
{
sb.AppendFormat("\tdefine{0}Field(getFunc: (item: {1}) => {2})", fullName.Replace('.', '_'), entityType, this.GetFieldDataType(f));
sb.Append(" { ");
sb.AppendFormat("this._defineCalculatedField('{0}', getFunc);", fullName);
sb.Append(" }");
sb.AppendLine();
}
});
});
return sb.ToString();
}
/*
private string createQueryNames()
{
var sb = new StringBuilder(256);
sb.AppendLine("export var QUERY_NAME =");
sb.Append("{");
bool isFirst = true;
this._metadata.methods.ForEach((methodInfo) =>
{
if (methodInfo.isQuery)
{
if (!isFirst)
{
sb.Append(",");
sb.AppendLine();
}
sb.AppendFormat("\t{0}: '{0}'", methodInfo.methodName);
isFirst = false;
}
});
sb.AppendLine();
sb.AppendLine("};");
return sb.ToString();
}
*/
private string createDbSetQueries(DbSetInfo dbSetInfo)
{
var sb = new StringBuilder(256);
var sbArgs = new StringBuilder(256);
var selected = this._metadata.methods.Where((m) => m.isQuery && MetadataHelper.RemoveTaskFromType(m.methodInfo.ReturnType).GetGenericArguments().First() == dbSetInfo.EntityType).ToList();
selected.ForEach((methodInfo) =>
{
sbArgs.Length = 0;
sbArgs.AppendLine("args?: {");
int cnt = 0;
methodInfo.parameters.ForEach((paramInfo) =>
{
sbArgs.Append("\t\t");
sbArgs.AppendFormat(this._CreateParamSignature(paramInfo));
sbArgs.AppendLine();
++cnt;
});
sbArgs.Append("\t}");
if (cnt == 0)
{
sbArgs.Length = 0;
}
sb.AppendFormat("\tcreate{0}Query({1})", methodInfo.methodName, sbArgs.ToString());
sb.AppendLine();
sb.Append("\t{");
sb.AppendLine();
if (sbArgs.Length > 0)
{
sb.AppendFormat("\t\tvar query = this.createQuery('{0}');", methodInfo.methodName);
sb.AppendLine();
sb.AppendLine("\t\tquery.params = args;");
sb.AppendLine("\t\treturn query;");
}
else
{
sb.AppendFormat("\t\treturn this.createQuery('{0}');", methodInfo.methodName);
sb.AppendLine();
}
sb.AppendLine("\t}");
});
return sb.ToString();
}
public static MethodInfo GetCRUDMethodInfo(DbSetInfo dbInfo, RowInfo rowInfo)
{
MethodInfo methInfo = null;
switch (rowInfo.changeType)
{
case ChangeType.Added:
methInfo = dbInfo.getOperationMethodInfo(MethodType.Insert);
break;
case ChangeType.Deleted:
methInfo = dbInfo.getOperationMethodInfo(MethodType.Delete);
break;
case ChangeType.Updated:
methInfo = dbInfo.getOperationMethodInfo(MethodType.Update);
break;
default:
throw new DomainServiceException(string.Format(ErrorStrings.ERR_REC_CHANGETYPE_INVALID, dbInfo.EntityType.Name, rowInfo.changeType));
}
return methInfo;
}
public static DbSetPermit GetDbSetPermissions(DbSetInfo dbInfo, IAuthorizer authorizer)
{
MethodInfo methInfo = null;
DbSetPermit permit = new DbSetPermit();
permit.dbSetName = dbInfo.dbSetName;
methInfo = dbInfo.getOperationMethodInfo(MethodType.Insert);
permit.canAddRow = methInfo != null && CanAccessMethod(methInfo,authorizer);
methInfo = dbInfo.getOperationMethodInfo(MethodType.Update);
permit.canEditRow = methInfo != null && CanAccessMethod(methInfo, authorizer);
methInfo = dbInfo.getOperationMethodInfo(MethodType.Delete);
permit.canDeleteRow = methInfo != null && CanAccessMethod(methInfo, authorizer);
methInfo = dbInfo.getOperationMethodInfo(MethodType.Refresh);
permit.canRefreshRow = methInfo != null && CanAccessMethod(methInfo, authorizer);
return permit;
}
public static void CheckMethod(BaseDomainService domainService, DbSetInfo dbSetInfo, MethodType methodType)
{
Type thisType = domainService.GetType();
string methodName = dbSetInfo.getOperationMethodName(methodType);
if (string.IsNullOrWhiteSpace(methodName))
return;
MethodInfo minfo = DataHelper.GetMethodInfo(thisType, methodName);
if (minfo != null)
{
switch (methodType)
{
case MethodType.Refresh:
dbSetInfo._refreshDataMethod = minfo;
break;
case MethodType.Insert:
dbSetInfo._insertDataMethod = minfo;
break;
case MethodType.Update:
dbSetInfo._updateDataMethod = minfo;
break;
case MethodType.Delete:
dbSetInfo._deleteDataMethod = minfo;
break;
case MethodType.Validate:
dbSetInfo._validateDataMethod = minfo;
break;
default:
throw new DomainServiceException(string.Format("Invalid Method Type {0}", methodType));
}
}
else
{
throw new DomainServiceException(string.Format("The DataService: {0} has no method: {2} specified for DbSet: {1} and operation: {3}", thisType.Name, dbSetInfo.dbSetName, methodName, Enum.GetName(typeof(MethodType), methodType)));
}
}
public string CreateComplexType(DbSetInfo dbSetInfo, Field fieldInfo, int level)
{
string typeName;
if (level == 0)
{
typeName = string.Format("{0}_{1}", dbSetInfo.dbSetName, fieldInfo.fieldName);
}
else
{
//to prevent names collision the type name is a three part name
typeName = string.Format("{0}_{1}{2}", dbSetInfo.dbSetName, fieldInfo.fieldName, level);
}
fieldInfo._TypeScriptDataType = typeName;
var sb = new StringBuilder(512);
var sbProperties = new StringBuilder();
var sbFieldsDef = new StringBuilder();
var sbFieldsInit = new StringBuilder();
Action<Field> AddProperty = (Field f) =>
{
string dataType = this.GetFieldDataType(f);
sbProperties.AppendFormat("\tget {0}(): {2} {{ return this.getValue('{1}'); }}", f.fieldName, f._FullName, dataType);
sbProperties.AppendLine();
if (!f.isReadOnly)
{
sbProperties.AppendFormat("\tset {0}(v: {2}) {{ this.setValue('{1}', v); }}", f.fieldName, f._FullName, dataType);
sbProperties.AppendLine();
}
};
Action<Field> AddCalculatedProperty = (Field f) =>
{
string dataType = this.GetFieldDataType(f);
sbProperties.AppendFormat("\tget {0}(): {2} {{ return this.getEntity()._getCalcFieldVal('{1}'); }}", f.fieldName, f._FullName, dataType);
sbProperties.AppendLine();
};
Action<Field, string> AddComplexProperty = (Field f, string dataType) =>
{
sbProperties.AppendFormat("\tget {0}(): {1} {{ if (!this._{0}) {{this._{0} = new {1}('{0}', this);}} return this._{0}; }}", f.fieldName, dataType);
sbProperties.AppendLine();
sbFieldsDef.AppendFormat("\tprivate _{0}: {1};", f.fieldName, dataType);
sbFieldsDef.AppendLine();
sbFieldsInit.AppendFormat("\t\tthis._{0} = null;", f.fieldName);
sbFieldsInit.AppendLine();
};
fieldInfo.nested.ForEach((f) =>
{
if (f.fieldType == FieldType.Calculated)
{
AddCalculatedProperty(f);
}
else if (f.fieldType == FieldType.Navigation)
{
throw new InvalidOperationException("Navigation fields are not allowed on complex type properties");
}
else if (f.fieldType == FieldType.Object)
{
string dataType = this.CreateComplexType(dbSetInfo, f, level + 1);
AddComplexProperty(f, dataType);
}
else
{
AddProperty(f);
}
});
string templateName = "RootComplexProperty.txt";
if (level > 0)
templateName = "ChildComplexProperty.txt";
(new TemplateParser(templateName)).ProcessParts((part) =>
{
if (!part.isPlaceHolder)
{
sb.Append(part.value);
}
else
{
switch (part.value)
{
case "PROPERTIES":
sb.Append(sbProperties.ToString());
break;
case "TYPE_NAME":
sb.Append(typeName);
break;
case "FIELDS_DEF":
sb.Append(sbFieldsDef.ToString());
break;
case "FIELDS_INIT":
sb.Append(sbFieldsInit.ToString());
break;
}
}
});
this._complexTypes.Add(typeName, sb.ToString());
return typeName;
}
