public ClientGroupsModel Bind(CodeModelTs codeModel)
{
var model = new ClientGroupsModel
{
ModelModuleName = "model",
Header = new HeaderModel(),
Clients = new List <ClientModel>()
};
foreach (var group in codeModel.MethodGroups)
{
var groupName = group.Key;
var methods = group.ToArray();
var client = new ClientModel
{
Name = $"{groupName.ToPascalCase().Replace("Api", "")}Api",
Methods = new List <ClientMethodModel>()
};
client.InterfaceName = $"I{client.Name}";
foreach (var method in methods)
{
IModelType modelType = null;
string responseName = null;
string requestName = null;
if (!TryGetResponseName(method, out modelType, out responseName, out requestName, model.ModelModuleName))
{
continue;
}
var clientMethod = new ClientMethodModel
{
OperationId = method.SerializedName.ToString(),
UrlTemplate = GetUrlTemplate(method),
QueryStringTemplate = GetQueryParameterTemplate(method),
HttpMethod = method.HttpMethod.ToString().ToLower(),
MethodName = method.Name.Value.Replace($"{groupName}_", "").ToCamelCase(),
RequestTypeName = requestName,
ResponseTypeName = responseName,
ParamNamesInPath =
method.Parameters.Where(p => p.Location == ParameterLocation.Path)
.Select(p => p.Name.Value)
.ToList(),
ParamNamesInQuery =
method.Parameters.Where(p => p.Location == ParameterLocation.Query)
.Select(p => p.Name.Value)
.ToList(),
ParamNamesInBody =
method.Parameters.Where(p => p.Location == ParameterLocation.Body)
.Select(p => p.Name.Value)
.ToList(),
ParamNamesInHeader =
method.Parameters.Where(p => p.Location == ParameterLocation.Header)
.Select(p => p.Name.Value)
.ToList()
};
clientMethod.ResponsePromiseTypeName = $"Promise<{clientMethod.ResponseTypeName}>";
client.Methods.Add(clientMethod);
}
model.Clients.Add(client);
}
return(model);
}
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);
}
