public Result Handle()
{
var analyzer = new WebApiAnalyzer(new WebApiAnalysisContext());
var analysisResult = analyzer.Analyze(_configuration.InputPath);
if (!analysisResult.Success)
{
return(Result.CreateError($"Source analysis error: {analysisResult.ErrorMessage}"));
}
log.Debug("Source analyzed");
var converter = new WebApiConverter();
var generator = new WebClientGenerator();
var emitter = new TypeScriptEmitter();
var serviceModels = converter.ConvertControllers(analysisResult.Value);
log.Debug("Models converted");
foreach (var tsModel in serviceModels)
{
var contents = generator.GenerateService(tsModel);
emitter.Emit(_configuration.OutputPath, tsModel.Name, EmittedFileType.Service, contents);
log.Debug($"Service {tsModel.Name} emitted");
new TsGenerator().GenerateServiceAST(tsModel, _configuration.OutputPath);
}
return(Result.CreateSuccess());
}
public AnalysisResult <CSharpSyncModels> Synchronize(string path)
{
_context.Init(path);
var typesForGeneration = new List <ITypeSymbol>();
// get all controller classes
var controllers = ControllerHelper.GetControllers(_context.Project, _context.Compilation);
// process controllers
foreach (var controller in controllers)
{
// get all controller methods that are exposed via HTTP
var httpMethods = ControllerHelper.GetPublicMethods(controller);
foreach (var httpMethod in httpMethods)
{
// collect unique return types
if (!typesForGeneration.Exists(t => t.Equals(httpMethod.ReturnType)))
{
typesForGeneration.Add(httpMethod.ReturnType);
}
// collect unique parameter types
foreach (var parameter in httpMethod.Parameters)
{
if (!typesForGeneration.Exists(t => t.Equals(parameter.Type)))
{
typesForGeneration.Add(parameter.Type);
}
}
}
}
var namedTypes = new List <INamedTypeSymbol>();
// process collected types
foreach (var type in typesForGeneration)
{
var namedType = type as INamedTypeSymbol;
if (!namedTypes.Exists(t => t.Equals(namedType)) && TypeHelper.IsSupportedType(type))
{
namedTypes.Add(namedType);
}
// handle type arguments
if (!namedType.TypeArguments.IsDefaultOrEmpty)
{
// TODO: get type members recursively
foreach (var typeArgument in namedType.TypeArguments)
{
var namedArgument = typeArgument as INamedTypeSymbol;
if (!namedTypes.Exists(t => t.Equals(namedArgument)) && TypeHelper.IsSupportedType(namedArgument))
{
namedTypes.Add(namedArgument);
}
}
}
}
var depGraphs = new List <DirectedSparseGraph <DependencyNode> >();
foreach (var namedType in namedTypes)
{
var depGraphFactory = new DependencyGraphService();
var graph = depGraphFactory.BuildForNamedTypeSymbol(namedType);
var readable = graph.ToReadable();
depGraphs.Add(graph);
}
var nodes = depGraphs.SelectMany(g => g.Vertices).Distinct().ToList();
var uniqueNodes = nodes
.GroupBy(n => n.NamedTypeSymbol.ContainingNamespace + "." + n.NamedTypeSymbol.Name)
.Select(n => n.First())
.ToList();
var modelAnalyzer = new ModelAnalyzer(_context);
var classModels = new List <CSharpClassModel>();
var enumModels = new List <CSharpEnumModel>();
foreach (var node in uniqueNodes)
{
var symbol = node.NamedTypeSymbol;
if (symbol.TypeKind == TypeKind.Class || symbol.TypeKind == TypeKind.Struct)
{
classModels.Add(modelAnalyzer.AnalyzeClassSymbol(symbol));
}
else if (symbol.TypeKind == TypeKind.Enum)
{
enumModels.Add(modelAnalyzer.AnalyzeEnumSymbol(symbol));
}
}
var webApiAnalyzer = new WebApiAnalyzer(_context);
var controllerModels = new List <CSharpControllerModel>();
foreach (var controller in controllers)
{
controllerModels.Add(webApiAnalyzer.AnalyzeController(controller, false));
}
return(new AnalysisResult <CSharpSyncModels>()
{
Success = true,
Value = new CSharpSyncModels()
{
DataModels = new CSharpDataModels()
{
Classes = classModels,
Enums = enumModels
},
Controllers = controllerModels
}
});
}
