public bool IsUsedAsParameterInAnyMethod(IEnumerable <Core.WebApiGenerator.ControllerObject> controllers, ApiObject requestObj)
{
return(controllers.Any(c => c.Methods
.Any(m => m.Parameter != null &&
(m.Parameter.Type == requestObj.Type || m.Parameter.Type == CollectionTypeHelper.GetCollectionType(requestObj.Type) ||
CollectionTypeHelper.GetCollectionType(m.Parameter.Type) == requestObj.Type))));
}
public static string GetTypeFromApiObject(ApiObject apiObject)
{
if (apiObject.IsArray)
{
if (string.IsNullOrWhiteSpace(apiObject.Type))
{
return(CollectionTypeHelper.GetCollectionType(apiObject.Name));
}
if (CollectionTypeHelper.IsCollection(apiObject.Type))
{
return(apiObject.Type);
}
return(CollectionTypeHelper.GetCollectionType(apiObject.Type));
}
if (apiObject.IsMap)
{
return(apiObject.Type);
}
if (apiObject.IsScalar)
{
return(apiObject.Properties.First().Type);
}
if (!string.IsNullOrWhiteSpace(apiObject.Type) && apiObject.Type != apiObject.Name)
{
return(apiObject.Type);
}
return(apiObject.Name);
}
protected void CleanProperties(IDictionary <string, ApiObject> apiObjects)
{
var keys = apiObjects.Keys.ToList();
var apiObjectsCount = keys.Count - 1;
for (var i = apiObjectsCount; i >= 0; i--)
{
var apiObject = apiObjects[keys[i]];
var count = apiObject.Properties.Count;
for (var index = count - 1; index >= 0; index--)
{
var prop = apiObject.Properties[index];
var type = prop.Type;
if (!string.IsNullOrWhiteSpace(type) && IsCollectionType(type))
{
type = CollectionTypeHelper.GetBaseType(type);
}
if (prop.IsAdditionalProperties)
{
continue;
}
if (!NewNetTypeMapper.IsPrimitiveType(type) && schemaResponseObjects.All(o => o.Value.Name != type) &&
schemaRequestObjects.All(o => o.Value.Name != type) &&
enums.All(e => e.Value.Name != type) &&
schemaObjects.All(o => o.Value.Name != type))
{
apiObject.Properties.Remove(prop);
}
}
}
}
private void UpdateObjects(ApiObject obj, ICollection <ApiObject> values)
{
foreach (var type in values)
{
foreach (var prop in type.Properties.Where(p => p.TypeId != null))
{
if (NeedsFixing(obj, prop))
{
if (CollectionTypeHelper.IsCollection(prop.Type))
{
prop.Type = CollectionTypeHelper.GetCollectionType(obj.Name);
}
else
{
prop.Type = obj.Name;
}
}
else if (linkIdsWithTypes.ContainsKey(prop.TypeId))
{
if (CollectionTypeHelper.IsCollection(prop.Type))
{
prop.Type = CollectionTypeHelper.GetCollectionType(linkIdsWithTypes[prop.TypeId]);
}
else
{
prop.Type = linkIdsWithTypes[prop.TypeId];
}
}
}
}
}
private bool IsUsedAsReferenceInAnyObject(ApiObject obj)
{
return(schemaObjects.SelectMany(o => o.Value.Properties).Any(x => x.Type == obj.Type ||
x.Type == CollectionTypeHelper.GetCollectionType(obj.Type) ||
x.Type == obj.BaseClass ||
CollectionTypeHelper.GetCollectionType(x.Type) == obj.Type ||
x.Type == CollectionTypeHelper.GetCollectionType(obj.BaseClass) ||
CollectionTypeHelper.GetCollectionType(x.Type) == obj.BaseClass
)
|| schemaObjects.Values.Any(o => o.BaseClass == obj.Type)
|| schemaRequestObjects.SelectMany(o => o.Value.Properties).Any(x => x.Type == obj.Type ||
x.Type == CollectionTypeHelper.GetCollectionType(obj.Type) ||
x.Type == obj.BaseClass ||
CollectionTypeHelper.GetCollectionType(x.Type) == obj.Type ||
x.Type == CollectionTypeHelper.GetCollectionType(obj.BaseClass) ||
CollectionTypeHelper.GetCollectionType(x.Type) == obj.BaseClass)
|| schemaResponseObjects.SelectMany(o => o.Value.Properties).Any(x => x.Type == obj.Type ||
x.Type == CollectionTypeHelper.GetCollectionType(obj.Type) ||
x.Type == obj.BaseClass ||
CollectionTypeHelper.GetCollectionType(x.Type) == obj.Type ||
x.Type == CollectionTypeHelper.GetCollectionType(obj.BaseClass) ||
CollectionTypeHelper.GetCollectionType(x.Type) == obj.BaseClass));
}
public bool IsUsedAsParameterInAnyMethod(IEnumerable <ClassObject> classes, ApiObject requestObj)
{
return(classes.Any(c => c.Methods
.Any(m => m.Parameter != null &&
(m.Parameter.Type == requestObj.Type || m.Parameter.Type == CollectionTypeHelper.GetCollectionType(requestObj.Type) ||
CollectionTypeHelper.GetCollectionType(m.Parameter.Type) == requestObj.Type))));
}
private void AddProperty(RAML.Parser.Model.EndPoint resource, Operation method, string key, Response response, ICollection <Property> properties, string fullUrl)
{
var mimeType = GeneratorServiceHelper.GetMimeType(response);
if (mimeType == null)
{
return;
}
var type = responseTypesService.GetResponseType(method, resource, mimeType, key, response.StatusCode, fullUrl);
if (string.IsNullOrWhiteSpace(type))
{
return;
}
var name = NetNamingMapper.GetPropertyName(CollectionTypeHelper.GetBaseType(type));
if (properties.Any(p => p.Name == name))
{
name = name + response.StatusCode;
}
var property = new Property
{
Name = name,
Description = response.Description + " " + mimeType.Schema.Description,
Example = ObjectParser.MapExample(mimeType.Schema),
Type = type,
StatusCode = GetStatusCode(response),
JSONSchema = mimeType.Schema as SchemaShape == null ? null : ((SchemaShape)mimeType.Schema).Raw.Replace(Environment.NewLine, "").Replace("\r\n", "").Replace("\n", "").Replace("\"", "\\\"")
};
properties.Add(property);
}
public bool IsUsedAsResponseInAnyMethod(IEnumerable <ClassObject> classes, ApiObject apiObj)
{
return(classes.Any(c => c.Methods.Any(m => m.ReturnType == apiObj.Type ||
m.ReturnType == CollectionTypeHelper.GetCollectionType(apiObj.Type) ||
CollectionTypeHelper.GetCollectionType(m.ReturnType) == apiObj.Type ||
m.ReturnType == apiObj.Name ||
(m.ReturnTypeObject != null && m.ReturnTypeObject.Properties != null &&
m.ReturnTypeObject.Properties.Any(x => x.Type == apiObj.Type || x.Type == CollectionTypeHelper.GetCollectionType(apiObj.Type) ||
CollectionTypeHelper.GetCollectionType(x.Type) == apiObj.Type)))));
}
public static string DecodeRaml1Type(string type)
{
// TODO: can I handle this better ?
if (type.Contains("(") || type.Contains("|"))
{
return("object");
}
if (type.EndsWith("[][]")) // array of arrays
{
var strippedType = type.Substring(0, type.Length - 4);
if (NewNetTypeMapper.Map(strippedType) == null)
{
strippedType = NetNamingMapper.GetObjectName(strippedType);
}
var decodeRaml1Type = CollectionTypeHelper.GetCollectionType(CollectionTypeHelper.GetCollectionType(strippedType));
return(decodeRaml1Type);
}
if (type.EndsWith("[]")) // array
{
var strippedType = type.Substring(0, type.Length - 2);
if (NewNetTypeMapper.Map(strippedType) == null)
{
strippedType = NetNamingMapper.GetObjectName(strippedType);
}
var decodeRaml1Type = CollectionTypeHelper.GetCollectionType(strippedType);
return(decodeRaml1Type);
}
if (type.EndsWith("{}")) // Map
{
var subtype = type.Substring(0, type.Length - 2);
var netType = NewNetTypeMapper.Map(subtype);
if (netType != null)
{
return("IDictionary<string, " + netType + ">");
}
return("IDictionary<string, " + NetNamingMapper.GetObjectName(subtype) + ">");
}
if (CollectionTypeHelper.IsCollection(type))
{
return(type);
}
return(NetNamingMapper.GetObjectName(type));
}
private static string GetCollectionType(Property prop, string itemType)
{
if (NewNetTypeMapper.IsPrimitiveType(itemType))
{
return(CollectionTypeHelper.GetCollectionType(itemType));
}
if (CollectionTypeHelper.IsCollection(itemType))
{
return(CollectionTypeHelper.GetCollectionType(itemType));
}
return(CollectionTypeHelper.GetCollectionType(NetNamingMapper.GetObjectName(itemType)));
}
protected void HandleScalarTypes()
{
foreach (var obj in schemaObjects)
{
foreach (var prop in obj.Value.Properties)
{
var baseType = prop.Type;
if (CollectionTypeHelper.IsCollection(prop.Type))
{
baseType = CollectionTypeHelper.GetBaseType(prop.Type);
}
if (!prop.IsEnum && !NewNetTypeMapper.IsPrimitiveType(baseType))
{
var apiObj = FindObject(baseType, schemaObjects);
if (apiObj != null && apiObj.IsScalar)
{
prop.Type = apiObj.Type;
}
}
}
}
}
private Property MapProperty(PropertyShape p, string parentClassName)
{
var prop = new Property(parentClassName)
{
Name = NetNamingMapper.GetObjectName(GetNameFromPath(p.Path)),
Required = p.Required,
Type = NetNamingMapper.GetObjectName(GetNameFromPath(p.Path)) //TODO: check
};
if (p.Range == null)
{
return(prop);
}
prop.Name = NetNamingMapper.GetObjectName(string.IsNullOrWhiteSpace(p.Path) ? p.Range.Name : GetNameFromPath(p.Path));
prop.Description = p.Range.Description;
prop.Example = MapExample(p.Range);
prop.Type = NewNetTypeMapper.GetNetType(p.Range, existingObjects, newObjects, existingEnums, newEnums);
if (p.Range is ScalarShape scalar)
{
prop.Pattern = scalar.Pattern;
prop.MaxLength = scalar.MaxLength;
prop.MinLength = scalar.MinLength;
prop.Maximum = string.IsNullOrWhiteSpace(scalar.Maximum) ? (double?)null : Convert.ToDouble(scalar.Maximum);
prop.Minimum = string.IsNullOrWhiteSpace(scalar.Minimum) ? (double?)null : Convert.ToDouble(scalar.Minimum);
if (scalar.Values != null && scalar.Values.Any())
{
// enum ??
prop.IsEnum = true;
var apiEnum = ParseEnum(scalar, existingEnums, warnings, newEnums);
if (!newEnums.ContainsKey(apiEnum.Name))
{
newEnums.Add(apiEnum.Name, apiEnum);
}
prop.Type = apiEnum.Name;
}
return(prop);
}
if (existingObjects.ContainsKey(prop.Type) || newObjects.ContainsKey(prop.Type))
{
return(prop);
}
if (p.Range is NodeShape)
{
var tuple = ParseObject(prop.Name, p.Range, existingObjects, warnings, existingEnums);
prop.Type = NetNamingMapper.GetObjectName(prop.Name);
}
if (p.Range is ArrayShape array)
{
if (array.Items is ScalarShape)
{
return(prop);
}
var itemType = NewNetTypeMapper.GetNetType(array.Items, existingObjects, newObjects, existingEnums, newEnums);
prop.Type = CollectionTypeHelper.GetCollectionType(NetNamingMapper.GetObjectName(itemType));
if (array.Items is NodeShape && itemType == "Items")
{
itemType = NetNamingMapper.GetObjectName(array.Name);
prop.Type = CollectionTypeHelper.GetCollectionType(NetNamingMapper.GetObjectName(array.Name));
}
if (existingObjects.ContainsKey(itemType) || newObjects.ContainsKey(itemType))
{
return(prop);
}
ParseObject(array.Name, array.Items, existingObjects, warnings, existingEnums);
}
foreach (var parent in p.Range.Inherits)
{
if (!(parent is ScalarShape) && !NewNetTypeMapper.IsPrimitiveType(prop.Type) &&
!(CollectionTypeHelper.IsCollection(prop.Type) && NewNetTypeMapper.IsPrimitiveType(CollectionTypeHelper.GetBaseType(prop.Type))) &&
string.IsNullOrWhiteSpace(parent.LinkTargetName))
{
ParseObject(prop.Name, parent, existingObjects, warnings, existingEnums);
}
}
return(prop);
}
public static string GetNetType(Shape shape, IDictionary <string, ApiObject> existingObjects = null,
IDictionary <string, ApiObject> newObjects = null, IDictionary <string, ApiEnum> existingEnums = null, IDictionary <string, ApiEnum> newEnums = null)
{
if (!string.IsNullOrWhiteSpace(shape.LinkTargetName))
{
return(NetNamingMapper.GetObjectName(GetTypeFromLinkOrId(shape.LinkTargetName)));
}
if (shape is ScalarShape scalar)
{
if (shape.Values != null && shape.Values.Any())
{
var key = GetTypeFromLinkOrId(shape.Id);
if (existingEnums != null && existingEnums.ContainsKey(key))
{
return(existingEnums[key].Name);
}
if (newEnums != null && newEnums.ContainsKey(key))
{
return(newEnums[key].Name);
}
}
return(GetNetType(scalar.DataType.Substring(scalar.DataType.LastIndexOf('#') + 1), scalar.Format));
}
if (shape is ArrayShape array)
{
return(CollectionTypeHelper.GetCollectionType(GetNetType(array.Items, existingObjects, newObjects, existingEnums, newEnums)));
}
if (shape is FileShape file)
{
return(TypeStringConversion["file"]);
}
if (shape.Id.Contains("#/declarations"))
{
var key = GetTypeFromLinkOrId(shape.Id);
if (existingObjects != null && (existingObjects.ContainsKey(key) ||
existingObjects.Keys.Any(k => k.ToLowerInvariant() == key.ToLowerInvariant())))
{
if (existingObjects.ContainsKey(key))
{
return(existingObjects[key].Type);
}
return(existingObjects.First(kv => kv.Key.ToLowerInvariant() == key.ToLowerInvariant()).Value.Type);
}
if (newObjects != null && newObjects.ContainsKey(key))
{
return(newObjects[key].Type);
}
}
if (shape.Inherits.Count() == 1)
{
if (shape is NodeShape nodeShape)
{
if (nodeShape.Properties.Count() == 0)
{
return(GetNetType(nodeShape.Inherits.First(), existingObjects, newObjects, existingEnums, newEnums));
}
}
if (shape.Inherits.First() is ArrayShape arrayShape)
{
return(CollectionTypeHelper.GetCollectionType(GetNetType(arrayShape.Items, existingObjects, newObjects, existingEnums, newEnums)));
}
if (shape is AnyShape any)
{
var key = NetNamingMapper.GetObjectName(any.Inherits.First().Name);
if (existingObjects != null && existingObjects.ContainsKey(key))
{
return(key);
}
if (newObjects != null && newObjects.ContainsKey(key))
{
return(key);
}
}
}
if (shape.Inherits.Count() > 0)
{
//TODO: check
}
if (shape.GetType() == typeof(AnyShape))
{
return(GetNetType("any", null));
}
if (shape is UnionShape)
{
return("object");
}
return(NetNamingMapper.GetObjectName(shape.Name));
}
private bool NeedsFixing(ApiObject obj, Property prop)
{
return(prop.TypeId == obj.Id && ((!CollectionTypeHelper.IsCollection(prop.Type) && prop.Type != obj.Name) ||
(CollectionTypeHelper.IsCollection(prop.Type) && CollectionTypeHelper.GetCollectionType(obj.Type) != prop.Type)));
}
internal static bool IsPrimitiveOrSchemaObject(string type, IDictionary <string, ApiObject> schemaObjects)
{
return(NewNetTypeMapper.IsPrimitiveType(type) || NewNetTypeMapper.IsPrimitiveType(CollectionTypeHelper.GetBaseType(type)) ||
schemaObjects.ContainsKey(type) || schemaObjects.Any(o => o.Value.Type == type || o.Value.Type == CollectionTypeHelper.GetBaseType(type)));
}
private Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum>, IDictionary <Guid, string> > ParseObject(Guid id, string key, Shape shape,
IDictionary <string, ApiObject> existingObjects, bool isRootType)
{
if (AlreadyExists(existingObjects, existingEnums, shape.Id))
{
return(new Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum>, IDictionary <Guid, string> >
(newObjects, newEnums, new Dictionary <Guid, string>()));
}
// if is array of scalar or array of object there's no new object, except when is a root type
if (!isRootType && shape is ArrayShape array && (array.Items is ScalarShape || array.Items is AnyShape))
{
return(new Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum>, IDictionary <Guid, string> >
(newObjects, newEnums, new Dictionary <Guid, string>()));
}
var linkedType = new Dictionary <Guid, string>();
var apiObj = new ApiObject
{
Id = id,
AmfId = shape.Id,
BaseClass = GetBaseClass(shape),
IsArray = shape is ArrayShape,
IsScalar = shape is ScalarShape,
IsUnionType = shape is UnionShape,
Name = NetNamingMapper.GetObjectName(key),
Type = NetNamingMapper.GetObjectName(key),
Description = shape.Description,
Example = MapExample(shape)
};
if (isRootType && apiObj.IsScalar)
{
apiObj.Type = NewNetTypeMapper.GetNetType(shape, existingObjects);
}
if (isRootType && apiObj.IsArray && shape is ArrayShape arrShape)
{
var itemShape = arrShape.Items;
if (itemShape is NodeShape)
{
var itemId = Guid.NewGuid();
ParseObject(itemId, itemShape.Name, itemShape, existingObjects, false);
apiObj.Type = NewNetTypeMapper.GetNetType(shape, existingObjects);
}
else
{
//if (newObjects.ContainsKey(itemShape.Id))
// apiObj.Type = CollectionTypeHelper.GetCollectionType(newObjects[itemShape.Id].Type);
//else if(existingObjects.ContainsKey(itemShape.Id))
// apiObj.Type = CollectionTypeHelper.GetCollectionType(existingObjects[itemShape.Id].Type);
//else
apiObj.Type = NewNetTypeMapper.GetNetType(shape, existingObjects);
}
}
if (shape is NodeShape node && node.Properties.Count() == 1 && node.Properties.First().Path != null && node.Properties.First().Path.StartsWith("/") &&
node.Properties.First().Path.EndsWith("/"))
{
apiObj.IsMap = true;
var valueType = "object";
if (node.Properties.First().Range != null)
{
valueType = NewNetTypeMapper.GetNetType(node.Properties.First().Range, existingObjects);
}
apiObj.Type = $"Dictionary<string, {valueType}>";
AddNewObject(shape, apiObj);
return(new Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum>, IDictionary <Guid, string> >(newObjects, newEnums, linkedType));
}
apiObj.Properties = MapProperties(shape, apiObj.Name).ToList();
ApiObject match = null;
if (existingObjects.Values.Any(o => o.Name == apiObj.Name) || newObjects.Values.Any(o => o.Name == apiObj.Name))
{
if (UniquenessHelper.HasSameProperties(apiObj, existingObjects, key, newObjects, emptyDic))
{
return(new Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum>, IDictionary <Guid, string> >(newObjects, newEnums, linkedType));
}
match = HandleNameDuplication(id, apiObj, key, linkedType);
}
if (existingObjects.Values.Any(o => o.Type == apiObj.Type) || newObjects.Values.Any(o => o.Type == apiObj.Type))
{
if (UniquenessHelper.HasSameProperties(apiObj, existingObjects, key, newObjects, emptyDic))
{
return(new Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum>, IDictionary <Guid, string> >(newObjects, newEnums, linkedType));
}
match = HandleTypeDuplication(id, apiObj, key, linkedType);
}
if (match != null)
{
return(new Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum>, IDictionary <Guid, string> >(newObjects, newEnums, linkedType));
}
//if (match == null)
//{
// match = UniquenessHelper.FirstOrDefaultWithSameProperties(apiObj, existingObjects, key, newObjects, emptyDic);
// if (match != null)
// {
// if (!linkedType.ContainsKey(id))
// linkedType.Add(id, match.Type);
// }
//}
if (shape.Inherits != null && shape.Inherits.Count() == 1)
{
var baseClass = NewNetTypeMapper.GetNetType(shape.Inherits.First(), existingObjects, newObjects, existingEnums, newEnums);
if (!string.IsNullOrWhiteSpace(baseClass))
{
apiObj.BaseClass = CollectionTypeHelper.GetConcreteType(baseClass);
}
}
AddNewObject(shape, apiObj);
return(new Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum>, IDictionary <Guid, string> >(newObjects, newEnums, linkedType));
}
private string DecodeResponseRaml1Type(string type)
{
// TODO: can I handle this better ?
if (type.Contains("(") || type.Contains("|"))
{
return("string");
}
if (type.EndsWith("[][]")) // array of arrays
{
var subtype = type.Substring(0, type.Length - 4);
if (NewNetTypeMapper.IsPrimitiveType(subtype))
{
subtype = NewNetTypeMapper.Map(subtype);
}
else
{
subtype = NetNamingMapper.GetObjectName(subtype);
}
return(CollectionTypeHelper.GetCollectionType(CollectionTypeHelper.GetCollectionType(subtype)));
}
if (type.EndsWith("[]")) // array
{
var subtype = type.Substring(0, type.Length - 2);
if (NewNetTypeMapper.IsPrimitiveType(subtype))
{
subtype = NewNetTypeMapper.Map(subtype);
}
else
{
subtype = NetNamingMapper.GetObjectName(subtype);
}
return(CollectionTypeHelper.GetCollectionType(subtype));
}
if (type.EndsWith("{}")) // Map
{
var subtype = type.Substring(0, type.Length - 2);
var netType = NewNetTypeMapper.Map(subtype);
if (!string.IsNullOrWhiteSpace(netType))
{
return("IDictionary<string, " + netType + ">");
}
var objectType = GetReturnTypeFromName(subtype);
if (!string.IsNullOrWhiteSpace(objectType))
{
return("IDictionary<string, " + objectType + ">");
}
return("IDictionary<string, object>");
}
if (NewNetTypeMapper.IsPrimitiveType(type))
{
return(NewNetTypeMapper.Map(type));
}
return(type);
}
private Property MapProperty(PropertyShape p, string parentClassName)
{
var name = GetPropertyName(p);
var prop = new Property(parentClassName)
{
Name = NetNamingMapper.GetPropertyName(name),
Required = p.Required,
Type = NetNamingMapper.GetObjectName(name),
InheritanceProvenance = p.InheritanceProvenance
};
if (p.Range == null)
{
return(prop);
}
prop.OriginalName = p.Range.Name;
prop.AmfId = p.Range.Id;
prop.Description = p.Range.Description;
prop.Example = MapExample(p.Range);
prop.Type = NewNetTypeMapper.GetNetType(p.Range, existingObjects, newObjects, existingEnums, newEnums);
if (p.Range is ScalarShape scalar)
{
prop.Pattern = scalar.Pattern;
prop.MaxLength = scalar.MaxLength;
prop.MinLength = scalar.MinLength;
prop.Maximum = string.IsNullOrWhiteSpace(scalar.Maximum) ? (double?)null : Convert.ToDouble(scalar.Maximum);
prop.Minimum = string.IsNullOrWhiteSpace(scalar.Minimum) ? (double?)null : Convert.ToDouble(scalar.Minimum);
if (scalar.Values != null && scalar.Values.Any())
{
prop.IsEnum = true;
var apiEnum = CreateEnum(scalar, existingEnums, warnings, newEnums);
string amfId = apiEnum.AmfId;
if (string.IsNullOrWhiteSpace(amfId))
{
amfId = prop.AmfId ?? prop.Name;
}
prop.Type = apiEnum.Name;
if (newEnums.ContainsKey(amfId))
{
return(prop);
}
if (existingEnums.Values.Any(o => o.Name == apiEnum.Name) || newEnums.Values.Any(o => o.Name == apiEnum.Name))
{
if (UniquenessHelper.HasSamevalues(apiEnum, existingEnums, newEnums))
{
return(prop);
}
apiEnum.Name = UniquenessHelper.GetUniqueName(apiEnum.Name, existingEnums, newEnums);
prop.Type = apiEnum.Name;
}
newEnums.Add(amfId, apiEnum);
}
return(prop);
}
//if (existingObjects.ContainsKey(prop.Type) || newObjects.ContainsKey(prop.Type))
// return prop;
if (p.Range is NodeShape)
{
if (existingObjects.ContainsKey(p.Range.Id))
{
prop.Type = existingObjects[p.Range.Id].Type;
return(prop);
}
if (newObjects.ContainsKey(p.Range.Id))
{
prop.Type = newObjects[p.Range.Id].Type;
return(prop);
}
var id = Guid.NewGuid();
prop.TypeId = id;
var tuple = ParseObject(id, prop.Name, p.Range, existingObjects, warnings, existingEnums);
prop.Type = NetNamingMapper.GetObjectName(prop.Name);
}
if (p.Range is ArrayShape array)
{
if (array.Items is ScalarShape)
{
return(prop);
}
if (!string.IsNullOrWhiteSpace(array.Items.LinkTargetName))
{
return(prop);
}
var itemType = NewNetTypeMapper.GetNetType(array.Items, existingObjects, newObjects, existingEnums, newEnums);
GetCollectionType(prop, itemType);
if (array.Items is NodeShape && itemType == "Items")
{
itemType = NetNamingMapper.GetObjectName(array.Name);
prop.Type = CollectionTypeHelper.GetCollectionType(NetNamingMapper.GetObjectName(array.Name));
}
if (existingObjects.ContainsKey(array.Id))
{
return(prop);
}
if (array.Items is ScalarShape || array.Items.GetType() == typeof(AnyShape))
{
return(prop);
}
var newId = Guid.NewGuid();
prop.TypeId = newId;
ParseObject(newId, array.Name, array.Items, existingObjects, warnings, existingEnums);
}
foreach (var parent in p.Range.Inherits)
{
if (!(parent is ScalarShape) && !NewNetTypeMapper.IsPrimitiveType(prop.Type) &&
!(CollectionTypeHelper.IsCollection(prop.Type) && NewNetTypeMapper.IsPrimitiveType(CollectionTypeHelper.GetBaseType(prop.Type))) &&
string.IsNullOrWhiteSpace(parent.LinkTargetName))
{
var newId = Guid.NewGuid();
ParseObject(newId, prop.Name, parent, existingObjects, warnings, existingEnums);
}
}
return(prop);
}