public string ProvideParameterType(IModelType type, bool inModelsModule = false)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
var builder = new StringBuilder("");
if (type.IsPrimaryType(KnownPrimaryType.Date) ||
type.IsPrimaryType(KnownPrimaryType.DateTime) ||
type.IsPrimaryType(KnownPrimaryType.DateTimeRfc1123) ||
type.IsPrimaryType(KnownPrimaryType.UnixTime))
{
builder.Append("Date | string");
}
else if (type.IsSequenceContainingDateKind())
{
builder.Append("Array<Date> | Array<string>");
}
else if (type.IsDictionaryContainingDateKind())
{
builder.Append("{ [key: string]: Date } | { [key: string]: string }");
}
else
{
builder.Append(type.TSType(inModelsModule));
}
return(builder.ToString());
}
public string GetTypeText(IModelType modelType, string moduleName = null)
{
var seqType = modelType as SequenceTypeTs;
var prefix = string.IsNullOrWhiteSpace(moduleName) ? "" : $"{moduleName}.";
var name = "";
if (seqType == null)
{
name = modelType.GetImplementationName();
if (modelType.IsEnumType())
{
return(name);
}
return(modelType.IsPrimaryType() ? name : $"{prefix}I{name}");
}
var elementType = seqType.ElementType;
name = elementType.GetImplementationName();
return(SequenceTypeTs.CreateSeqTypeText(elementType.IsPrimaryType() ? name : $"{prefix}I{name}"));
}
private bool NeedsSpecialSerialization(IModelType type)
{
var known = type as PrimaryType;
return(known != null &&
type.IsPrimaryType(KnownPrimaryType.ByteArray) ||
type is SequenceType);
}
/// <summary>
/// Returns true if the <paramref name="type"/> is a PrimaryType with KnownPrimaryType matching <paramref name="typeToMatch"/>
/// or a DictionaryType with ValueType matching <paramref name="typeToMatch"/> or a SequenceType matching <paramref name="typeToMatch"/>
/// </summary>
/// <param name="type"></param>
/// <param name="typeToMatch"></param>
/// <returns></returns>
public static bool IsOrContainsPrimaryType(this IModelType type, KnownPrimaryType typeToMatch)
{
if (type == null)
{
return(false);
}
if (type.IsPrimaryType(typeToMatch) ||
type.IsDictionaryContainingType(typeToMatch) ||
type.IsSequenceContainingType(typeToMatch))
{
return(true);
}
return(false);
}
protected bool IsUnixTime(IModelType modelType)
{
return(modelType.IsPrimaryType(KnownPrimaryType.DateTimeRfc1123));
}
protected bool IsDate(IModelType modelType)
{
return(modelType.IsPrimaryType(KnownPrimaryType.Date));
}
/// <summary>
/// Determine whether a model should be serializable.
/// </summary>
/// <param name="type">The type to check.</param>
public static bool IsSerializable(this IModelType type)
{
return(!type.IsPrimaryType(KnownPrimaryType.Object));
}
public ModelsModel Bind(CodeModelTs codeModel)
{
var models = new ModelsModel
{
Header = new HeaderModel
{
ApiVersion = codeModel.ApiVersion
},
RequestModels = new List <Model.Model>(),
ResponseModels = new List <Model.Model>(),
EnumModels = new List <EnumModel>()
};
var modelTypesFromDefinition = codeModel.ModelTypes.ToList();
var enumsInModels = new List <Tuple <string, IModelType> >();
Func <IVariable, ModelProperty> getPropertyModel =
variable =>
{
var propertyType = variable.ModelType;
string typeName = null;
//if (propertyType.IsEnumType())
//{
// var enumType = (EnumTypeTs) propertyType;
// typeName = enumType.GetImplementationName(variable);
// enumsInModels.Add(new Tuple<string, IModelType>(typeName, propertyType));
//}
return(new ModelProperty
{
Name = variable.Name.ToCamelCase(),
IsRequired = variable.IsRequired,
TypeName = typeName ?? GetTypeText(propertyType)
});
};
foreach (var method in codeModel.Methods)
{
string requestName = null;
string responseName = null;
IModelType modelType = null;
if (!TryGetResponseName(method, out modelType, out responseName, out requestName))
{
continue;
}
var requestModelType = new Model.Model
{
Name = requestName,
Properties = new List <ModelProperty>()
};
foreach (Parameter parameter in method.Parameters)
{
requestModelType.Properties.Add(getPropertyModel(parameter));
}
models.RequestModels.Add(requestModelType);
if (modelType.IsPrimaryType() || modelType.IsSequenceType() || modelType.IsEnumType())
{
continue;
}
var responseModelType = new Model.Model
{
Name = responseName,
Properties = new List <ModelProperty>()
};
var type = modelTypesFromDefinition.FirstOrDefault(m => m.ClassName == modelType.ClassName);
if (type == null)
{
continue;
}
modelTypesFromDefinition.Remove(type);
foreach (var property in type.Properties)
{
responseModelType.Properties.Add(getPropertyModel(property));
}
models.ResponseModels.Add(responseModelType);
}
foreach (var modelType in modelTypesFromDefinition)
{
if (modelType.IsPrimaryType() || modelType.IsSequenceType() && modelType.IsEnumType())
{
continue;
}
var model = new Model.Model
{
Name = GetTypeText(modelType),
Properties = new List <ModelProperty>()
};
models.ResponseModels.Add(model);
foreach (var property in modelType.Properties)
{
model.Properties.Add(getPropertyModel(property));
}
}
// disable enum generation for now #ranantawat.
// foreach (var pair in enumsInModels)
// {
// var enumType = (EnumTypeTs) pair.Item2;
// var enumModel = new EnumModel {Name = pair.Item1};
// if (enumType.ModelAsString)
// {
// for (var index = 0; index < enumType.EnumValues.Length; index++)
// {
// var value = enumType.Children.Cast<EnumValue>().ToArray()[index];
// enumModel.Values.Add(value.Name, index);
// }
// }
// models.EnumModels.Add(enumModel);
// }
models.EnumModels = models.EnumModels.Distinct().ToList();
foreach (EnumType enumType in codeModel.EnumTypes.ToArray())
{
models.EnumModels.Add(new EnumModel
{
Name = enumType.DeclarationName,
Values = new Dictionary <string, object>()
});
}
return(models);
}
public static string InitializePrimaryType(this IModelType paramType, string paramName, bool isBrowser = false)
{
var paramValue = "\"\"";
if (paramType.IsPrimaryType(KnownPrimaryType.String))
{
if (paramName.EqualsIgnoreCase("location"))
{
paramValue = "\"westus\"";
}
else
{
paramValue = $"\"test{paramName.ToCamelCase()}\"";
}
}
else if (paramType.IsPrimaryType(KnownPrimaryType.Date))
{
paramValue = "new Date().toISOString().substring(0, 10)";
}
else if (paramType.IsPrimaryType(KnownPrimaryType.DateTime))
{
paramValue = "new Date().toISOString()";
}
else if (paramType.IsPrimaryType(KnownPrimaryType.DateTimeRfc1123))
{
paramValue = "new Date().toUTCString()";
}
else if (paramType.IsPrimaryType(KnownPrimaryType.UnixTime))
{
paramValue = "new Date()";
}
else if (paramType.IsPrimaryType(KnownPrimaryType.TimeSpan))
{
paramValue = "\"P1Y2M3DT4H5M6S\"";
}
else if (paramType.IsPrimaryType(KnownPrimaryType.Boolean))
{
paramValue = "true";
}
else if (paramType.IsPrimaryType(KnownPrimaryType.Int) || paramType.IsPrimaryType(KnownPrimaryType.Long))
{
paramValue = "1";
}
else if (paramType.IsPrimaryType(KnownPrimaryType.Decimal) || paramType.IsPrimaryType(KnownPrimaryType.Double))
{
paramValue = "1.01";
}
else if (paramType.IsPrimaryType(KnownPrimaryType.Object))
{
paramValue = "{}";
}
else if (paramType.IsPrimaryType(KnownPrimaryType.Uuid))
{
paramValue = "ec7b1657-199d-4d8a-bbb2-89a11a42e02a";
}
else if (paramType.IsPrimaryType(KnownPrimaryType.Stream))
{
paramValue = isBrowser ? "new ReadableStream()" : "new require(\"stream\").Readable()";
}
return(paramValue);
}
protected bool IsDateTimeRfc1123(IModelType modelType)
{
return modelType.IsPrimaryType(KnownPrimaryType.DateTimeRfc1123);
}