private async void CallGenerateCodes(Workspace workspace, string solutionFullName)
{
Stopwatch sw = null;
try
{
sw = Stopwatch.StartNew();
IProjectDtoControllersProvider controllersProvider = new DefaultProjectDtoControllersProvider();
IProjectDtosProvider dtosProvider = new DefaultProjectDtosProvider(controllersProvider);
DefaultTypeScriptClientProxyGenerator generator = new DefaultTypeScriptClientProxyGenerator(new DefaultBitCodeGeneratorOrderedProjectsProvider(),
new BitSourceGeneratorBitConfigProvider(solutionFullName), dtosProvider
, new DefaultTypeScriptClientProxyDtoGenerator(), new DefaultTypeScriptClientContextGenerator(), controllersProvider, new DefaultProjectEnumTypesProvider(controllersProvider, dtosProvider));
await generator.GenerateCodes(workspace);
Log($"Code Generation Completed in {sw.ElapsedMilliseconds} ms using {workspace.GetType().Name}");
}
catch (Exception ex)
{
LogException("Code Generation failed.", ex);
throw;
}
finally
{
sw?.Stop();
}
}
private void _buildEvents_OnBuildDone_Internal(vsBuildScope scope, vsBuildAction action)
{
Solution solution = _workspace.CurrentSolution;
if (action == vsBuildAction.vsBuildActionClean)
{
DefaultHtmlClientProxyCleaner cleaner = new DefaultHtmlClientProxyCleaner(new DefaultBitCodeGeneratorMappingsProvider(new DefaultBitConfigProvider()));
cleaner.GetType().GetTypeInfo().GetMethod(nameof(DefaultHtmlClientProxyCleaner.DeleteCodes))
.Invoke(cleaner, new object[] { _workspace, solution, _isBeingBuiltProjects });
Log("Generated codes were deleted");
}
else
{
Stopwatch watch = Stopwatch.StartNew();
IProjectDtoControllersProvider controllersProvider = new DefaultProjectDtoControllersProvider();
IProjectDtosProvider dtosProvider = new DefaultProjectDtosProvider(controllersProvider);
DefaultHtmlClientProxyGenerator generator = new DefaultHtmlClientProxyGenerator(new DefaultBitCodeGeneratorOrderedProjectsProvider(),
new DefaultBitCodeGeneratorMappingsProvider(new DefaultBitConfigProvider()), dtosProvider
, new DefaultHtmlClientProxyDtoGenerator(), new DefaultHtmlClientContextGenerator(), controllersProvider, new DefaultProjectEnumTypesProvider(controllersProvider, dtosProvider));
generator.GetType().GetTypeInfo().GetMethod(nameof(DefaultHtmlClientProxyGenerator.GenerateCodes))
.Invoke(generator, new object[] { _workspace, solution, _isBeingBuiltProjects });
watch.Stop();
Log($"Code Generation Completed in {watch.ElapsedMilliseconds} milli seconds");
}
}
private void CallGenerateCodes()
{
Stopwatch sw = null;
try
{
sw = Stopwatch.StartNew();
IProjectDtoControllersProvider controllersProvider = new DefaultProjectDtoControllersProvider();
IProjectDtosProvider dtosProvider = new DefaultProjectDtosProvider(controllersProvider);
DefaultHtmlClientProxyGenerator generator = new DefaultHtmlClientProxyGenerator(new DefaultBitCodeGeneratorOrderedProjectsProvider(),
new DefaultBitCodeGeneratorMappingsProvider(new DefaultBitConfigProvider()), dtosProvider
, new DefaultHtmlClientProxyDtoGenerator(), new DefaultHtmlClientContextGenerator(), controllersProvider, new DefaultProjectEnumTypesProvider(controllersProvider, dtosProvider));
System.Threading.Tasks.Task.Run(async() => await generator.GenerateCodes(_visualStudioWorkspace, _shouldGeneratedProjectNames)).GetAwaiter().GetResult();
Log($"Code Generation Completed in {sw.ElapsedMilliseconds} ms.");
}
catch (Exception ex)
{
LogException($"Code Generation failed.", ex);
}
finally
{
sw?.Stop();
}
}
private async Task CallGenerateCodes(MSBuildWorkspace workspace, Project beingCompiledProject, string solutionFullName)
{
Stopwatch sw = null;
try
{
sw = Stopwatch.StartNew();
workspace.WorkspaceFailed += MSBuildWorkspace_WorkspaceFailed;
workspace.SkipUnrecognizedProjects = workspace.LoadMetadataForReferencedProjects = true;
IReadOnlyList <ProjectInSolution> allProjects = SolutionFile.Parse(solutionFullName).ProjectsInOrder;
BitSourceGeneratorBitConfigProvider bitConfigProvider = new BitSourceGeneratorBitConfigProvider(solutionFullName);
foreach (BitCodeGeneratorMapping mapping in bitConfigProvider.GetConfiguration(workspace).BitCodeGeneratorConfigs.BitCodeGeneratorMappings.Where(config => config.SourceProjects.Any(sp => sp.Name == beingCompiledProject.Name)))
{
foreach (BitTools.Core.Model.ProjectInfo proj in mapping.SourceProjects)
{
if (workspace.CurrentSolution.Projects.Any(p => p.Name == proj.Name))
{
continue; /*It's already loaded*/
}
await workspace.OpenProjectAsync(allProjects.ExtendedSingle($"Trying to find source project {proj.Name}", p => p.ProjectName == proj.Name).AbsolutePath);
}
if (!workspace.CurrentSolution.Projects.Any(p => p.Name == mapping.DestinationProject.Name))
{
await workspace.OpenProjectAsync(allProjects.ExtendedSingle($"Trying to find destination project {mapping.DestinationProject.Name}", p => p.ProjectName == mapping.DestinationProject.Name).AbsolutePath);
}
}
IProjectDtoControllersProvider controllersProvider = new DefaultProjectDtoControllersProvider();
IProjectDtosProvider dtosProvider = new DefaultProjectDtosProvider(controllersProvider);
DefaultTypeScriptClientProxyGenerator generator = new DefaultTypeScriptClientProxyGenerator(new DefaultBitCodeGeneratorOrderedProjectsProvider(),
bitConfigProvider, dtosProvider
, new DefaultTypeScriptClientProxyDtoGenerator(), new DefaultTypeScriptClientContextGenerator(), controllersProvider, new DefaultProjectEnumTypesProvider(controllersProvider, dtosProvider));
await generator.GenerateCodes(workspace);
Log($"Code Generation Completed in {sw.ElapsedMilliseconds} ms using {workspace.GetType().Name}.");
}
catch (Exception ex)
{
LogException("Code Generation failed.", ex);
throw;
}
finally
{
sw?.Stop();
workspace.WorkspaceFailed -= MSBuildWorkspace_WorkspaceFailed;
}
}
public virtual async Task DefaultProjectDtoControllersProviderShouldReturnDtoControllersOfTestProjectAsDesired()
{
using (Workspace workspace = GetWorkspace())
{
Solution solution = workspace.CurrentSolution;
IList <DtoController> controllers = new DefaultProjectDtoControllersProvider()
.GetProjectDtoControllersWithTheirOperations(solution.Projects.Single(p => p.Name == "Foundation.Test"));
Assert.AreEqual(9, controllers.Count);
}
}
static async Task GenerateCodes()
{
BitSourceGeneratorBitConfigProvider bitConfigProvider = new BitSourceGeneratorBitConfigProvider(_bitConfigFilePath !, BeingCompiledProjectName);
BitConfig bitConfig = bitConfigProvider.GetConfiguration();
using (MSBuildWorkspace workspace = MSBuildWorkspace.Create(new Dictionary <string, string>
{
{ "TargetFramework", bitConfig.TargetFramework ?? "net5.0" }
}))
{
workspace.SkipUnrecognizedProjects = workspace.LoadMetadataForReferencedProjects = true;
workspace.WorkspaceFailed += MSBuildWorkspace_WorkspaceFailed;
foreach (BitCodeGeneratorMapping mapping in bitConfigProvider.GetConfiguration().BitCodeGeneratorConfigs.BitCodeGeneratorMappings)
{
foreach (Bit.Tooling.Core.Model.ProjectInfo proj in mapping.SourceProjects)
{
if (workspace.CurrentSolution.Projects.Any(p => proj.IsThisProject(p)))
{
continue; /*It's already loaded*/
}
string sourceProjetctPath = proj.Name == BeingCompiledProjectName ? ProjectPath : (AllProjectsPaths ?? throw new InvalidOperationException($"There is no solution project and we're unable to find {proj.Name}")).ExtendedSingle($"Trying to find source project {proj.Name}", projPath => Path.GetFileNameWithoutExtension(projPath) == proj.Name);
await workspace.OpenProjectAsync(sourceProjetctPath);
}
if (!workspace.CurrentSolution.Projects.Any(p => mapping.DestinationProject.IsThisProject(p)))
{
string DestProjetctPath = mapping.DestinationProject.Name == BeingCompiledProjectName ? ProjectPath : (AllProjectsPaths ?? throw new InvalidOperationException($"There is no solution project and we're unable to find {mapping.DestinationProject.Name}")).ExtendedSingle($"Trying to find destination project {mapping.DestinationProject.Name}", projPath => Path.GetFileNameWithoutExtension(projPath) == mapping.DestinationProject.Name);
await workspace.OpenProjectAsync(DestProjetctPath);
}
}
IProjectDtoControllersProvider controllersProvider = new DefaultProjectDtoControllersProvider();
IProjectDtosProvider dtosProvider = new DefaultProjectDtosProvider(controllersProvider);
IBitCodeGeneratorOrderedProjectsProvider bitCodeGeneratorOrderedProjectsProvider = new DefaultBitCodeGeneratorOrderedProjectsProvider();
IProjectEnumTypesProvider projectEnumTypesProvider = new DefaultProjectEnumTypesProvider(controllersProvider, dtosProvider);
DefaultTypeScriptClientProxyGenerator tsGenerator = new DefaultTypeScriptClientProxyGenerator(bitCodeGeneratorOrderedProjectsProvider,
bitConfigProvider, dtosProvider
, new DefaultTypeScriptClientProxyDtoGenerator(), new DefaultTypeScriptClientContextGenerator(), controllersProvider, projectEnumTypesProvider);
await tsGenerator.GenerateCodes(workspace);
DefaultCSharpClientProxyGenerator csGenerator = new DefaultCSharpClientProxyGenerator(bitCodeGeneratorOrderedProjectsProvider,
bitConfigProvider, controllersProvider, new DefaultCSharpClientContextGenerator());
await csGenerator.GenerateCodes(workspace);
}
}
public virtual async Task DefaultProjectDtoControllersProviderShouldReturnDtoControllersAsDesired()
{
using (Workspace workspace = GetWorkspace())
{
Solution solution = workspace.CurrentSolution;
IList <DtoController> controllers = new DefaultProjectDtoControllersProvider()
.GetProjectDtoControllersWithTheirOperations(solution.Projects.Single(p => p.Name == "Foundation.Api"));
Assert.IsTrue(
controllers.Select(c => c.Name).SequenceEqual(new[] { "ClientsLogs", "JobsInfo", "UsersSettings" }));
}
}
public async Task ITypeSymbolExtensionsShouldDetectVoidReturnTypeAsDesired()
{
string controllerCode = @"
public interface IDto{
}
public class SampleDto:IDto{
}
public class SamplesController : DtoController<SampleDto> {
[ActionAttribute]
public void Do(){
}
[ActionAttribute]
public Task Do2(){
}
[ActionAttribute]
public int Do3(){
return 0;
}
[ActionAttribute]
public async Task<int> Do4(){
return 0;
}
}
public class DtoController<TDto>
where TDto : IDto
{
}
";
DefaultProjectDtoControllersProvider controllersProvider = new DefaultProjectDtoControllersProvider();
DtoController controller = (await controllersProvider.GetProjectDtoControllersWithTheirOperations(CreateProjectFromSourceCodes(controllerCode))).Single();
Assert.IsTrue(controller.Operations.ElementAt(0).ReturnType.IsVoid());
Assert.IsTrue(controller.Operations.ElementAt(1).ReturnType.IsVoid());
Assert.IsFalse(controller.Operations.ElementAt(2).ReturnType.IsVoid());
Assert.IsFalse(controller.Operations.ElementAt(3).ReturnType.IsVoid());
}
static async Task GenerateCodes(BitConfig bitConfig, BitSourceGeneratorBitConfigProvider bitConfigProvider)
{
using (MSBuildWorkspace workspace = MSBuildWorkspace.Create(new Dictionary <string, string>
{
{ "TargetFramework", bitConfig.TargetFramework ?? "net6.0" }
}))
{
workspace.SkipUnrecognizedProjects = workspace.LoadMetadataForReferencedProjects = true;
workspace.WorkspaceFailed += MSBuildWorkspace_WorkspaceFailed;
foreach (BitCodeGeneratorMapping mapping in bitConfig.BitCodeGeneratorConfigs.BitCodeGeneratorMappings)
{
foreach (Bit.Tooling.Core.Model.ProjectInfo proj in mapping.SourceProjects.Union(new[] { mapping.DestinationProject }))
{
if (workspace.CurrentSolution.Projects.Any(p => proj == p))
{
continue; /*It's already loaded*/
}
string sourceProjetctPath = proj.Name == BeingCompiledProjectName ? ProjectPath : (AllProjectsPaths ?? throw new InvalidOperationException($"There is no solution project and we're unable to find {proj.Name}")).ExtendedSingle($"Trying to find project {proj.Name}", projPath => Path.GetFileNameWithoutExtension(projPath) == proj.Name);
await workspace.OpenProjectAsync(sourceProjetctPath).ConfigureAwait(false);
}
}
IProjectDtoControllersProvider controllersProvider = new DefaultProjectDtoControllersProvider();
IProjectDtosProvider dtosProvider = new DefaultProjectDtosProvider(controllersProvider);
IBitCodeGeneratorOrderedProjectsProvider bitCodeGeneratorOrderedProjectsProvider = new DefaultBitCodeGeneratorOrderedProjectsProvider();
IProjectEnumTypesProvider projectEnumTypesProvider = new DefaultProjectEnumTypesProvider(controllersProvider, dtosProvider);
TypeScriptJayDataClientProxyGenerator typeScriptJayDataGeneratedCode = new TypeScriptJayDataClientProxyGenerator(bitCodeGeneratorOrderedProjectsProvider,
bitConfigProvider, dtosProvider
, new TypeScriptJayDataClientProxyDtoGenerator(), new TypeScriptJayDataClientContextGenerator(), controllersProvider, projectEnumTypesProvider);
await typeScriptJayDataGeneratedCode.GenerateCodes(workspace).ConfigureAwait(false);
CSharpSimpleODataClientProxyGenerator csharpSimpleODataClientGeneratedCode = new CSharpSimpleODataClientProxyGenerator(bitCodeGeneratorOrderedProjectsProvider,
bitConfigProvider, controllersProvider, new CSharpSimpleODataClientContextGenerator(), new CSharpSimpleODataClientMetadataGenerator(), dtosProvider, projectEnumTypesProvider);
await csharpSimpleODataClientGeneratedCode.GenerateCodes(workspace).ConfigureAwait(false);
CSharpHttpClientProxyGenerator csharpHttpClientProxyGenerator = new CSharpHttpClientProxyGenerator(bitCodeGeneratorOrderedProjectsProvider,
bitConfigProvider, controllersProvider, new CSharpHttpClientContextGenerator(), dtosProvider, projectEnumTypesProvider);
await csharpHttpClientProxyGenerator.GenerateCodes(workspace).ConfigureAwait(false);
}
}
private async System.Threading.Tasks.Task CallGenerateCodes()
{
if (bitWorkspaceIsPrepared == false)
{
return;
}
Stopwatch sw = null;
try
{
sw = Stopwatch.StartNew();
IProjectDtoControllersProvider controllersProvider = new DefaultProjectDtoControllersProvider();
IProjectDtosProvider dtosProvider = new DefaultProjectDtosProvider(controllersProvider);
DefaultTypeScriptClientProxyGenerator generator = new DefaultTypeScriptClientProxyGenerator(new DefaultBitCodeGeneratorOrderedProjectsProvider(),
new DefaultBitConfigProvider(), dtosProvider
, new DefaultTypeScriptClientProxyDtoGenerator(), new DefaultTypeScriptClientContextGenerator(), controllersProvider, new DefaultProjectEnumTypesProvider(controllersProvider, dtosProvider));
Workspace workspaceForCodeGeneration = await GetWorkspaceForCodeGeneration();
try
{
await generator.GenerateCodes(workspaceForCodeGeneration);
Log($"Code Generation Completed in {sw.ElapsedMilliseconds} ms using {workspaceForCodeGeneration.GetType().Name}");
}
finally
{
if (!(workspaceForCodeGeneration is VisualStudioWorkspace))
{
workspaceForCodeGeneration.Dispose();
}
}
}
catch (Exception ex)
{
LogException("Code Generation failed.", ex);
}
finally
{
sw?.Stop();
}
}
private async Task GenerateCodes()
{
try
{
IProjectDtoControllersProvider controllersProvider = new DefaultProjectDtoControllersProvider();
IProjectDtosProvider dtosProvider = new DefaultProjectDtosProvider(controllersProvider);
DefaultHtmlClientProxyGenerator generator = new DefaultHtmlClientProxyGenerator(new DefaultBitCodeGeneratorOrderedProjectsProvider(),
new DefaultBitCodeGeneratorMappingsProvider(new DefaultBitConfigProvider()), dtosProvider
, new DefaultHtmlClientProxyDtoGenerator(), new DefaultHtmlClientContextGenerator(), controllersProvider, new DefaultProjectEnumTypesProvider(controllersProvider, dtosProvider));
await generator.GenerateCodes(_workspace.CurrentSolution, _shouldGeneratedProjects);
Log($"Code Generation Completed.");
}
catch (Exception ex)
{
LogException("Code Generation failed.", ex);
}
}
private void _buildEvents_OnBuildDone(vsBuildScope scope, vsBuildAction action)
{
try
{
Solution solution = _workspace.CurrentSolution;
if (action == vsBuildAction.vsBuildActionClean)
{
new DefaultHtmlClientProxyCleaner(new DefaultBitCodeGeneratorMappingsProvider(new DefaultBitConfigProvider()))
.DeleteCodes(_workspace, solution, _isBeingBuiltProjects);
Log("Generated codes were deleted");
}
else
{
Stopwatch watch = Stopwatch.StartNew();
IProjectDtoControllersProvider controllersProvider = new DefaultProjectDtoControllersProvider();
IProjectDtosProvider dtosProvider = new DefaultProjectDtosProvider(controllersProvider);
new DefaultHtmlClientProxyGenerator(new DefaultBitCodeGeneratorOrderedProjectsProvider(),
new DefaultBitCodeGeneratorMappingsProvider(new DefaultBitConfigProvider()), dtosProvider
, new DefaultHtmlClientProxyDtoGenerator(), new DefaultHtmlClientContextGenerator(), controllersProvider, new DefaultProjectEnumTypesProvider(controllersProvider, dtosProvider))
.GenerateCodes(_workspace, solution, _isBeingBuiltProjects);
watch.Stop();
Log($"Code Generation Completed in {watch.ElapsedMilliseconds} milli seconds");
}
}
catch (Exception ex)
{
Log(ex.ToString());
throw;
}
}
private static async Task AsyncMain(string[] args)
{
FluentCommandLineParser <BitCLIV1Args> commandLineParser = new FluentCommandLineParser <BitCLIV1Args>();
commandLineParser.Setup(arg => arg.Action)
.As('a', "action")
.SetDefault(BitCLIV1Action.Generate)
.WithDescription($"Action to perform. {nameof(BitCLIV1Action.Clean)} || {nameof(BitCLIV1Action.Generate)} || {nameof(BitCLIV1Action.Validate)}. Required");
commandLineParser.Setup(arg => arg.Path)
.As('p', "path")
.Required()
.WithDescription("Path to solution file. Required.");
commandLineParser.SetupHelp("?", "help")
.Callback(helpText => WriteInfo(helpText));
ICommandLineParserResult result = commandLineParser.Parse(args);
if (result.HasErrors == true)
{
throw new Exception(result.ErrorText);
}
else
{
BitCLIV1Args typedArgs = commandLineParser.Object;
typedArgs.Path = Path.Combine(Environment.CurrentDirectory, typedArgs.Path);
if (!File.Exists(typedArgs.Path))
{
throw new FileNotFoundException($"Solution could not be found at {typedArgs.Path}");
}
WriteInfo($"Solution Path: {typedArgs.Path}");
WriteInfo($"Action: {typedArgs.Action}");
try
{
WriteMessage("DotNetBuild started...");
using (AutoResetEvent outputWaitHandle = new AutoResetEvent(false))
using (AutoResetEvent errorWaitHandle = new AutoResetEvent(false))
{
using (Process dotnetBuildProcess = new Process())
{
dotnetBuildProcess.StartInfo.UseShellExecute = false;
dotnetBuildProcess.StartInfo.RedirectStandardOutput = dotnetBuildProcess.StartInfo.RedirectStandardError = true;
dotnetBuildProcess.StartInfo.FileName = "dotnet";
dotnetBuildProcess.StartInfo.Arguments = $"build {typedArgs.Path}";
dotnetBuildProcess.StartInfo.CreateNoWindow = true;
dotnetBuildProcess.StartInfo.WorkingDirectory = Directory.GetParent(typedArgs.Path).FullName;
dotnetBuildProcess.OutputDataReceived += (sender, e) =>
{
if (e.Data != null)
{
WriteMessage(e.Data);
}
else
{
outputWaitHandle.Set();
}
};
dotnetBuildProcess.ErrorDataReceived += (sender, e) =>
{
if (e.Data != null)
{
WriteError(e.Data);
}
else
{
errorWaitHandle.Set();
}
};
dotnetBuildProcess.Start();
dotnetBuildProcess.BeginOutputReadLine();
dotnetBuildProcess.BeginErrorReadLine();
dotnetBuildProcess.WaitForExit();
outputWaitHandle.WaitOne();
errorWaitHandle.WaitOne();
}
}
WriteMessage("DotNetBuild completed");
}
catch (Exception ex)
{
WriteError($"DotNetBuild Error => {ex.ToString()}");
}
using (MSBuildWorkspace workspace = MSBuildWorkspace.Create())
{
workspace.LoadMetadataForReferencedProjects = workspace.SkipUnrecognizedProjects = true;
workspace.WorkspaceFailed += Workspace_WorkspaceFailed;
await workspace.OpenSolutionAsync(typedArgs.Path);
switch (typedArgs.Action)
{
case BitCLIV1Action.Generate:
IProjectDtoControllersProvider controllersProvider = new DefaultProjectDtoControllersProvider();
IProjectDtosProvider dtosProvider = new DefaultProjectDtosProvider(controllersProvider);
DefaultTypeScriptClientProxyGenerator generator = new DefaultTypeScriptClientProxyGenerator(new DefaultBitCodeGeneratorOrderedProjectsProvider(), new DefaultBitConfigProvider(), dtosProvider, new DefaultTypeScriptClientProxyDtoGenerator(), new DefaultTypeScriptClientContextGenerator(), controllersProvider, new DefaultProjectEnumTypesProvider(controllersProvider, dtosProvider));
await generator.GenerateCodes(workspace);
break;
case BitCLIV1Action.Validate:
throw new NotImplementedException("Validate");
case BitCLIV1Action.Clean:
throw new NotImplementedException("Clean");
default:
throw new NotSupportedException();
}
}
}
}
public virtual async Task DefaultEnumTypesProviderShouldReturnEnumTypes()
{
const string sourceCodes = @"
public interface IDto {
}
public class DtoController<TDto>
where TDto : IDto
{
}
public class DtoWithEnum : IDto
{
public virtual int Id { get; set; }
public virtual TestGender? Gender { get; set; }
public virtual string Test { get; set; }
}
public enum TestGender
{
Man = 3, Woman = 12, Other
}
public enum TestGender2
{
Man = 3, Woman = 12, Other
}
public class DtoWithEnumController : DtoController<DtoWithEnum>
{
public class GetDtoWithEnumsByGenderParameters
{
public virtual TestGender gender { get; set; }
}
[ActionAttribute]
public virtual int GetDtoWithEnumsByGender(GetDtoWithEnumsByGenderParameters parameters)
{
return 1;
}
public class GetDtoWithEnumsByGender2Parameters
{
public virtual TestGender2 gender { get; set; }
}
[ActionAttribute]
public virtual int GetDtoWithEnumsByGender2(GetDtoWithEnumsByGender2Parameters parameters)
{
return 1;
}
}
";
IProjectDtoControllersProvider projectDtoControllersProvider = new DefaultProjectDtoControllersProvider();
IProjectEnumTypesProvider projectEnumTypesProvider = new DefaultProjectEnumTypesProvider(projectDtoControllersProvider, new DefaultProjectDtosProvider(projectDtoControllersProvider));
Project proj = CreateProjectFromSourceCodes(sourceCodes);
IList <EnumType> result = await projectEnumTypesProvider.GetProjectEnumTypes(proj, new[] { proj });
Assert.IsTrue(result.Select(enumType => enumType.EnumTypeSymbol.Name).SequenceEqual(new[] { "TestGender", "TestGender2" }));
Assert.IsTrue(result.First().Members.SequenceEqual(new[]
{
new EnumMember {
Name = "Man", Value = 3, Index = 0
},
new EnumMember {
Name = "Woman", Value = 12, Index = 1
},
new EnumMember {
Name = "Other", Value = 13, Index = 2
}
}, new EnumMemberEqualityComparer()));
}
public virtual async Task DefaultProjectDtoControllersProviderShouldFindODataOperationParametersCorrectly()
{
const string sourceCodeOfDtoControllerWithActionAndParameter = @"
using System;
using System.Threading.Tasks;
using System.Web.OData;
using Foundation.Api.ApiControllers;
using Foundation.Test.Model.DomainModels;
namespace Foundation.Api.ApiControllers
{
[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
public sealed class ParameterAttribute : Attribute
{
public string Name { get; private set; }
public Type Type { get; private set; }
public bool IsOptional { get; private set; }
public ParameterAttribute(string name, Type type, bool isOptional = false)
{
if (name == null)
throw new ArgumentNullException(nameof(name));
if (type == null)
throw new ArgumentNullException(nameof(type));
Name = name;
Type = type;
IsOptional = isOptional;
}
}
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public sealed class ActionAttribute : Attribute
{
}
}
public interface IDto {
}
public class TestModel : IDto {
}
public class DtoController<TDto>
where TDto : IDto
{
}
[System.ComponentModel.DataAnnotations.Schema.ComplexType]
public class ComplexObj3
{
public virtual string Name { get; set; }
}
namespace Foundation.Test.Api.ApiControllers
{
public class TestController : DtoController<TestModel>
{
[Action]
[Parameter(""Parameter1"", typeof(string), isOptional : true )]
[ParameterAttribute(""Parameter1"", typeof(string) , isOptional : false )]
[Foundation.Api.ApiControllers.Parameter(""Parameter1"", typeof(string))]
[Foundation.Api.ApiControllers.ParameterAttribute(""Parameter1"", typeof(string))]
public virtual async Task Do(ODataActionParameters actionParameters)
{
}
[Action]
public virtual async System.Threading.Tasks.Task<int[]> Do1()
{
}
[Action]
[Parameter(""values"", typeof(int[]))]
public virtual async System.Threading.Tasks.Task<ComplexObj3[]> Do3()
{
}
}
}
";
IList <DtoController> controllers = new DefaultProjectDtoControllersProvider()
.GetProjectDtoControllersWithTheirOperations(CreateProjectFromSourceCodes(sourceCodeOfDtoControllerWithActionAndParameter));
Assert.AreEqual(true, controllers.Single()
.Operations.ElementAt(0)
.Parameters.First().IsOptional);
Assert.IsTrue(controllers.Single()
.Operations.ElementAt(0)
.Parameters.Skip(1)
.All(p => p.IsOptional == false));
Assert.AreEqual("Edm.Int32", controllers.Single()
.Operations.ElementAt(1)
.ReturnType.GetEdmElementTypeName());
Assert.AreEqual("ComplexObj3", controllers.Single()
.Operations.ElementAt(2)
.ReturnType.GetEdmElementTypeName());
Assert.AreEqual("Edm.Int32", controllers.Single()
.Operations.ElementAt(2)
.Parameters.Single().Type.GetEdmElementTypeName());
}
public virtual async Task NestedObjectsTest()
{
string sourceProjectCodes = @"
public interface IDto {
}
public class DtoController<TDto>
where TDto : IDto
{
}
public class TestComplexController : DtoController<TestComplexDto>
{
[FunctionAttribute]
public System.Threading.Tasks.Task<ComplexObj3[]> GetComplexObjects()
{
return null;
}
public class SomeActionArgs
{
public ComplexObj5 Test5 { get; set; }
public string Test { get; set; }
}
[ActionAttribute]
public void SomeAction(SomeActionArgs args)
{
}
}
public class TestComplexDto : IDto
{
public virtual int EntityId { get; set; }
public virtual ComplexObj ComplexObj { get; set; }
public virtual ComplexObj2 ComplexObj2 { get; set; }
}
[System.ComponentModel.DataAnnotations.Schema.ComplexType]
public class ComplexObj
{
public virtual string Name { get; set; }
}
[System.ComponentModel.DataAnnotations.Schema.ComplexType]
public class ComplexObj3
{
public virtual string Name { get; set; }
public virtual ComplexObj4 Obj4 { get; set; }
}
[System.ComponentModel.DataAnnotations.Schema.ComplexType]
public class ComplexObj4
{
public virtual string Name { get; set; }
public virtual Test Test { get; set; }
}
[System.ComponentModel.DataAnnotations.Schema.ComplexType]
public class ComplexObj5
{
public virtual string Name { get; set; }
public virtual Test2 Test2 { get; set; }
}
public enum Test
{
}
public enum Test2
{
}
";
string otherProjectCodes = @"
namespace System.ComponentModel.DataAnnotations.Schema
{
public class ComplexTypeAttribute : Attribute
{
}
}
[System.ComponentModel.DataAnnotations.Schema.ComplexType]
public class ComplexObj2
{
public virtual string Name { get; set; }
public virtual Test Test { get; set; }
}
public enum Test3
{
}
";
Project otherProject = CreateProjectFromSourceCodes(otherProjectCodes);
Project sourceProject = CreateProjectFromSourceCodesWithExistingSolution(otherProject.Solution, sourceProjectCodes);
sourceProject = sourceProject.AddProjectReference(new ProjectReference(otherProject.Id));
DefaultProjectDtoControllersProvider dtoControllersProvider = new DefaultProjectDtoControllersProvider();
DefaultProjectDtosProvider projectDtosProvider = new DefaultProjectDtosProvider(dtoControllersProvider);
DefaultProjectEnumTypesProvider enumTypesProvider = new DefaultProjectEnumTypesProvider(dtoControllersProvider, projectDtosProvider);
Dto[] dtos = (await projectDtosProvider.GetProjectDtos(sourceProject)).ToArray();
EnumType[] enums = (await enumTypesProvider.GetProjectEnumTypes(sourceProject)).ToArray();
Assert.IsTrue(dtos.Select(d => d.DtoSymbol.Name).SequenceEqual(new[] { "ComplexObj5", "ComplexObj4", "ComplexObj3", "ComplexObj2", "ComplexObj", "TestComplexDto" }));
Assert.IsTrue(enums.Select(d => d.EnumTypeSymbol.Name).SequenceEqual(new[] { "Test2", "Test" }));
}
