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; }