private OdcmType ResolveType(string name, string @namespace, TypeKind kind)
{
OdcmType type;
if (!_odcmModel.TryResolveType(name, @namespace, out type))
{
switch (kind)
{
case TypeKind.Complex:
type = new OdcmClass(name, @namespace, OdcmClassKind.Complex);
break;
case TypeKind.Entity:
type = new OdcmClass(name, @namespace, OdcmClassKind.Entity);
break;
case TypeKind.Enum:
type = new OdcmEnum(name, @namespace);
break;
case TypeKind.Primitive:
type = new OdcmPrimitiveType(name, @namespace);
break;
}
_odcmModel.AddType(type);
}
return(type);
}
public static OdcmEnum AsOdcmEnum(this OdcmObject odcmObject)
{
OdcmEnum foo = odcmObject as OdcmEnum;
var bar = foo.Members.LastOrDefault();
return(odcmObject as OdcmEnum);
}
public void Write(OdcmEnum odcmEnum)
{
// if no Underlying type is specified then default to 'int'.
_("public enum {0} : {1}", odcmEnum.Name,
odcmEnum.UnderlyingType == null ? "int" : NamesService.GetPrimitiveTypeKeyword(odcmEnum.UnderlyingType));
using (_builder.IndentBraced)
{
Write(odcmEnum.Members);
}
}
public Enum(OdcmEnum odcmEnum)
{
Name = odcmEnum.Name;
Description = odcmEnum.Description;
// if no Underlying type is specified then default to 'int'.
UnderlyingType =
odcmEnum.UnderlyingType == null
? "int"
: NamesService.GetPrimitiveTypeKeyword(odcmEnum.UnderlyingType);
Members = odcmEnum.Members.Select(m => new EnumMember(m));
}
public void ProcessEnum(OdcmEnum odcmEnum)
{
PushIndent(" ");
#line default
#line hidden
#line 110 "E:\gittf\Roxel\O365\Public\src\EdmDecomposition\EdmDecomposition\ODataWriter.tt"
this.Write("\r\npublic enum ");
#line default
#line hidden
#line 112 "E:\gittf\Roxel\O365\Public\src\EdmDecomposition\EdmDecomposition\ODataWriter.tt"
this.Write(this.ToStringHelper.ToStringWithCulture(odcmEnum.Name));
#line default
#line hidden
#line 112 "E:\gittf\Roxel\O365\Public\src\EdmDecomposition\EdmDecomposition\ODataWriter.tt"
this.Write("\r\n{\r\n");
#line default
#line hidden
#line 114 "E:\gittf\Roxel\O365\Public\src\EdmDecomposition\EdmDecomposition\ODataWriter.tt"
foreach (OdcmEnumMember odcmEnumMember in odcmEnum.Members)
{
ProcessEnumMember(odcmEnumMember);
}
PopLastNonCRLFFromOutput(1);
#line default
#line hidden
#line 120 "E:\gittf\Roxel\O365\Public\src\EdmDecomposition\EdmDecomposition\ODataWriter.tt"
this.Write("}\r\n");
#line default
#line hidden
#line 122 "E:\gittf\Roxel\O365\Public\src\EdmDecomposition\EdmDecomposition\ODataWriter.tt"
PopIndent();
}
public static IEnumerable <Feature> ForOdcmEnum(OdcmEnum odcmEnum)
{
return(new[]
{
new Feature
{
Enums = new[]
{
new Enum(odcmEnum)
}
}
});
}
public static OdcmEnum OdcmEnum(Action <OdcmEnum> config = null)
{
var retVal = new OdcmEnum(Any.CSharpIdentifier(), Any.CSharpIdentifier());
retVal.UnderlyingType = Any.EnumUnderlyingType();
if (config != null)
{
config(retVal);
}
return(retVal);
}
public static string ToEdmx(this OdcmEnum odcmEnum)
{
var sb = new StringBuilder();
sb.AppendFormat("<EnumType Name=\"{0}\">", odcmEnum.Name);
if (odcmEnum.Members.Any())
{
sb.Append(odcmEnum.Members.Select(ToEdmx).Aggregate((c, n) => c + "\n" + n));
}
sb.AppendFormat("</EnumType>");
return(sb.ToString());
}
/// <summary>
/// Appends either:
/// export type EnumType = EnumValue1 | EnumValue2 | EnumValue3;
/// or:
/// export type EnumType =
/// | EnumValue1
/// | EnumValue2
/// | EnumValue3;
/// </summary>
/// <param name="enumType">enum</param>
private void AddEnum(OdcmEnum enumType)
{
var export = IsMainNamespace ? "export " : string.Empty;
var enumTypeName = enumType.Name.UpperCaseFirstChar();
var enumValues = enumType.GetEnumValues();
var exportTypeLength = (export + "type").Length + enumTypeName.Length + enumValues.Length + 3;
if (exportTypeLength < MaxLineLength)
{
sb.AppendLine($"{NamespaceIndent}{export}type {enumTypeName} = {enumValues};");
}
else
{
sb.AppendLine($"{NamespaceIndent}{export}type {enumTypeName} =");
var enums = enumValues.Split('|');
sb.Append($"{NamespaceIndent}{TabSpace}| ");
sb.Append(string.Join(Environment.NewLine + NamespaceIndent + TabSpace + "| ", enums.Select(@enum => @enum.Trim())));
sb.AppendLine(";");
}
}
private void WriteNamespace(IEdmModel edmModel, string @namespace)
{
var namespaceElements = from se in edmModel.SchemaElements
where string.Equals(se.Namespace, @namespace)
select se;
var types = from se in namespaceElements
where se.SchemaElementKind == EdmSchemaElementKind.TypeDefinition
select se as IEdmType;
var complexTypes = from se in types
where se.TypeKind == EdmTypeKind.Complex
select se as IEdmComplexType;
var entityTypes = from se in types
where se.TypeKind == EdmTypeKind.Entity
select se as IEdmEntityType;
var enumTypes = from se in types
where se.TypeKind == EdmTypeKind.Enum
select se as IEdmEnumType;
var entityContainers = from se in namespaceElements
where se.SchemaElementKind == EdmSchemaElementKind.EntityContainer
select se as IEdmEntityContainer;
var boundFunctions = from se in
(from ec in entityContainers
select ec.Elements).SelectMany(v => v)
where
se.ContainerElementKind == EdmContainerElementKind.FunctionImport &&
((IEdmFunctionImport)se).IsBindable
select se as IEdmFunctionImport;
Console.WriteLine(@namespace);
foreach (var enumType in enumTypes)
{
OdcmEnum odcmEnum;
if (!_odcmModel.TryResolveType(enumType.Name, enumType.Namespace, out odcmEnum))
{
odcmEnum = new OdcmEnum(enumType.Name, enumType.Namespace);
_odcmModel.AddType(odcmEnum);
}
odcmEnum.UnderlyingType =
(OdcmPrimitiveType)
ResolveType(enumType.UnderlyingType.Name, enumType.UnderlyingType.Namespace,
TypeKind.Primitive);
odcmEnum.IsFlags = enumType.IsFlags;
foreach (var enumMember in enumType.Members)
{
odcmEnum.Members.Add(new OdcmEnumMember(enumMember.Name)
{
Value = ((EdmIntegerConstant)enumMember.Value).Value
});
}
}
foreach (var complexType in complexTypes)
{
OdcmClass odcmClass;
if (!_odcmModel.TryResolveType(complexType.Name, complexType.Namespace, out odcmClass))
{
odcmClass = new OdcmClass(complexType.Name, complexType.Namespace, OdcmClassKind.Complex);
_odcmModel.AddType(odcmClass);
}
odcmClass.IsAbstract = complexType.IsAbstract;
odcmClass.IsOpen = complexType.IsOpen;
if (complexType.BaseType != null)
{
OdcmClass baseClass;
if (!_odcmModel.TryResolveType(
((IEdmSchemaElement)complexType.BaseType).Name,
((IEdmSchemaElement)complexType.BaseType).Namespace,
out baseClass))
{
baseClass = new OdcmClass(
((IEdmSchemaElement)complexType.BaseType).Name,
((IEdmSchemaElement)complexType.BaseType).Namespace,
OdcmClassKind.Complex);
_odcmModel.AddType(baseClass);
}
odcmClass.Base = baseClass;
if (!baseClass.Derived.Contains(odcmClass))
{
baseClass.Derived.Add(odcmClass);
}
}
foreach (var property in complexType.DeclaredProperties)
{
WriteProperty(odcmClass, property);
}
}
foreach (var entityType in entityTypes)
{
OdcmClass odcmClass;
if (!_odcmModel.TryResolveType(entityType.Name, entityType.Namespace, out odcmClass))
{
odcmClass = new OdcmClass(entityType.Name, entityType.Namespace, OdcmClassKind.Entity);
_odcmModel.AddType(odcmClass);
}
odcmClass.IsAbstract = entityType.IsAbstract;
odcmClass.IsOpen = entityType.IsOpen;
if (entityType.BaseType != null)
{
OdcmClass baseClass;
if (!_odcmModel.TryResolveType(
((IEdmSchemaElement)entityType.BaseType).Name,
((IEdmSchemaElement)entityType.BaseType).Namespace,
out baseClass))
{
baseClass = new OdcmClass(
((IEdmSchemaElement)entityType.BaseType).Name,
((IEdmSchemaElement)entityType.BaseType).Namespace,
OdcmClassKind.Entity);
_odcmModel.AddType(baseClass);
}
odcmClass.Base = baseClass;
if (!baseClass.Derived.Contains(odcmClass))
{
baseClass.Derived.Add(odcmClass);
}
}
foreach (var property in entityType.DeclaredProperties)
{
WriteProperty(odcmClass, property);
}
foreach (IEdmStructuralProperty keyProperty in entityType.Key())
{
var property = FindProperty(odcmClass, keyProperty);
if (property != null)
{
// The properties that compose the key MUST be non-nullable.
property.IsNullable = false;
}
odcmClass.Key.Add(property);
}
var entityTypeFunctions = from se in boundFunctions
where IsFunctionBound(se, entityType)
select se;
foreach (var function in entityTypeFunctions)
{
WriteMethod(odcmClass, function);
}
}
foreach (var entityContainer in entityContainers)
{
OdcmClass odcmClass;
if (!_odcmModel.TryResolveType(entityContainer.Name, entityContainer.Namespace, out odcmClass))
{
odcmClass = new OdcmClass(entityContainer.Name, entityContainer.Namespace, OdcmClassKind.Service);
_odcmModel.AddType(odcmClass);
}
var entitySets = from se in entityContainer.Elements
where se.ContainerElementKind == EdmContainerElementKind.EntitySet
select se as IEdmEntitySet;
foreach (var entitySet in entitySets)
{
WriteProperty(odcmClass, entitySet);
}
var functionImports = from se in entityContainer.Elements
where
se.ContainerElementKind == EdmContainerElementKind.FunctionImport &&
!((IEdmFunctionImport)se).IsBindable
select se as IEdmFunctionImport;
foreach (var functionImport in functionImports)
{
WriteMethod(odcmClass, functionImport);
}
}
}
// enum value string, ex: "low" | "normal" | "high"
public static String GetEnumValues(this OdcmEnum _enum)
{
return(_enum.Members.Select(m => "\"" + m.Name + "\"").Aggregate((cur, next) => cur + " | " + next));
}
private void WriteNamespace(IEdmModel edmModel, string @namespace)
{
var namespaceElements = from elements in edmModel.SchemaElements
where string.Equals(elements.Namespace, @namespace)
select elements;
var types = from element in namespaceElements
where element.SchemaElementKind == EdmSchemaElementKind.TypeDefinition
select element as IEdmType;
var complexTypes = from element in types
where element.TypeKind == EdmTypeKind.Complex
select element as IEdmComplexType;
var entityTypes = from element in types
where element.TypeKind == EdmTypeKind.Entity
select element as IEdmEntityType;
var enumTypes = from elements in types
where elements.TypeKind == EdmTypeKind.Enum
select elements as IEdmEnumType;
var entityContainers = from element in namespaceElements
where element.SchemaElementKind == EdmSchemaElementKind.EntityContainer
select element as IEdmEntityContainer;
var actions = from element in namespaceElements
where element.SchemaElementKind == EdmSchemaElementKind.Action && ((IEdmAction)element).IsBound
select element as IEdmAction;
var functions = from element in namespaceElements
where element.SchemaElementKind == EdmSchemaElementKind.Function && ((IEdmFunction)element).IsBound
select element as IEdmFunction;
foreach (var enumType in enumTypes)
{
OdcmEnum odcmEnum;
if (!OdcmModel.TryResolveType(enumType.Name, enumType.Namespace, out odcmEnum))
{
odcmEnum = new OdcmEnum(enumType.Name, enumType.Namespace);
odcmEnum.UnderlyingType = (OdcmPrimitiveType)ResolveType(enumType.UnderlyingType.Name, enumType.UnderlyingType.Namespace, TypeKind.Primitive);
OdcmModel.AddType(odcmEnum);
}
foreach (var enumMember in enumType.Members)
{
odcmEnum.Members.Add(new OdcmEnumMember(enumMember.Name)
{
Value = ((EdmIntegerConstant)enumMember.Value).Value
});
}
}
foreach (var complexType in complexTypes)
{
OdcmClass odcmClass;
if (!OdcmModel.TryResolveType(complexType.Name, complexType.Namespace, out odcmClass))
{
odcmClass = new OdcmClass(complexType.Name, complexType.Namespace, OdcmClassKind.Complex);
OdcmModel.AddType(odcmClass);
}
odcmClass.IsAbstract = complexType.IsAbstract;
if (complexType.BaseType != null)
{
OdcmClass baseClass;
if (!OdcmModel.TryResolveType(((IEdmSchemaElement)complexType.BaseType).Name, ((IEdmSchemaElement)complexType.BaseType).Namespace, out baseClass))
{
baseClass = new OdcmClass(((IEdmSchemaElement)complexType.BaseType).Name, ((IEdmSchemaElement)complexType.BaseType).Namespace, OdcmClassKind.Complex);
OdcmModel.AddType(baseClass);
}
odcmClass.Base = baseClass;
if (!baseClass.Derived.Contains(odcmClass))
{
baseClass.Derived.Add(odcmClass);
}
}
var structuralProperties = from element in complexType.Properties()
where element.PropertyKind == EdmPropertyKind.Structural &&
element.DeclaringType == (IEdmStructuredType)complexType
select element as IEdmStructuralProperty;
foreach (var structuralProperty in structuralProperties)
{
OdcmField odcmField = WriteStructuralField(odcmClass, structuralProperty);
WriteStructuralProperty(odcmClass, odcmField, structuralProperty);
}
}
foreach (var entityType in entityTypes)
{
OdcmClass odcmClass;
if (!OdcmModel.TryResolveType(entityType.Name, entityType.Namespace, out odcmClass))
{
odcmClass = new OdcmClass(entityType.Name, entityType.Namespace, OdcmClassKind.Entity);
OdcmModel.AddType(odcmClass);
}
odcmClass.IsAbstract = entityType.IsAbstract;
if (entityType.BaseType != null)
{
OdcmClass baseClass;
if (!OdcmModel.TryResolveType(((IEdmSchemaElement)entityType.BaseType).Name, ((IEdmSchemaElement)entityType.BaseType).Namespace, out baseClass))
{
baseClass = new OdcmClass(((IEdmSchemaElement)entityType.BaseType).Name, ((IEdmSchemaElement)entityType.BaseType).Namespace, OdcmClassKind.Entity);
OdcmModel.AddType(baseClass);
}
odcmClass.Base = baseClass;
if (!baseClass.Derived.Contains(odcmClass))
{
baseClass.Derived.Add(odcmClass);
}
}
var structuralProperties = from element in entityType.DeclaredProperties
where element.PropertyKind == EdmPropertyKind.Structural
select element as IEdmStructuralProperty;
foreach (var structuralProperty in structuralProperties)
{
OdcmField odcmField = WriteStructuralField(odcmClass, structuralProperty);
WriteStructuralProperty(odcmClass, odcmField, structuralProperty);
}
foreach (IEdmStructuralProperty keyProperty in entityType.Key())
{
var property = FindProperty(odcmClass, keyProperty);
if (property != null)
{
// The properties that compose the key MUST be non-nullable.
property.IsNullable = false;
}
odcmClass.Key.Add(FindField(odcmClass, keyProperty));
}
var navigationProperties = from element in entityType.DeclaredProperties
where element.PropertyKind == EdmPropertyKind.Navigation
select element as IEdmNavigationProperty;
foreach (var navigationProperty in navigationProperties)
{
OdcmField odcmField = WriteNavigationField(odcmClass, navigationProperty);
WriteNavigationProperty(odcmClass, odcmField, navigationProperty);
}
var entityTypeActions = from element in actions
where IsOperationBound(element, entityType)
select element;
foreach (var action in entityTypeActions)
{
WriteMethod(odcmClass, action);
}
var entityTypeFunctions = from element in functions
where IsOperationBound(element, entityType)
select element;
foreach (var function in entityTypeFunctions)
{
WriteMethod(odcmClass, function);
}
}
foreach (var entityContainer in entityContainers)
{
OdcmClass odcmClass;
if (!OdcmModel.TryResolveType(entityContainer.Name, entityContainer.Namespace, out odcmClass))
{
odcmClass = new OdcmClass(entityContainer.Name, entityContainer.Namespace, OdcmClassKind.Service);
OdcmModel.AddType(odcmClass);
}
var entitySets = from element in entityContainer.Elements
where element.ContainerElementKind == EdmContainerElementKind.EntitySet
select element as IEdmEntitySet;
foreach (var entitySet in entitySets)
{
OdcmField odcmField = WriteField(odcmClass, entitySet);
WriteProperty(odcmClass, odcmField, entitySet);
}
var singletons = from element in entityContainer.Elements
where element.ContainerElementKind == EdmContainerElementKind.Singleton
select element as IEdmSingleton;
foreach (var singleton in singletons)
{
OdcmField odcmField = WriteField(odcmClass, singleton);
WriteProperty(odcmClass, odcmField, singleton);
}
var actionImports = from element in entityContainer.Elements
where element.ContainerElementKind == EdmContainerElementKind.ActionImport
select element as IEdmActionImport;
foreach (var actionImport in actionImports)
{
WriteMethod(odcmClass, actionImport.Action);
}
var functionImports = from element in entityContainer.Elements
where element.ContainerElementKind == EdmContainerElementKind.FunctionImport
select element as IEdmFunctionImport;
foreach (var functionImport in functionImports)
{
WriteMethod(odcmClass, functionImport.Function);
}
}
}
public static Enum Map(OdcmEnum odcmEnum)
{
return(new Enum
{
});
}
