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 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();
}
}
public void IPropertySymbolExtensionsShouldDeterminateConcurrencyCheckPropertiesAsDesired()
{
string dtoCode = @"
public interface IDto {
}
public class SampleDto : IDto {
[ConcurrencyCheckAttribute]
public virtual int Concurrency{get;set;}
public virtual int NonConcurrency{get;set;}
}
public class DtoController<TDto>
where TDto : IDto
{
}
public class SamplesController : DtoController<SampleDto>
{
}
";
DefaultProjectDtosProvider dtosProvider = new DefaultProjectDtosProvider(new DefaultProjectDtoControllersProvider());
Dto dto = dtosProvider.GetProjectDtos(CreateProjectFromSourceCodes(dtoCode)).Single();
Assert.IsTrue(dto.Properties.ElementAt(0).HasConcurrencyCheck());
Assert.AreEqual(1, dto.Properties.Count(p => p.HasConcurrencyCheck()));
}
public void ITypeSymbolExtensionsShouldDetectUnderlyingTypeSymbolAsDesired()
{
string dtoCode = @"
public interface IDto {
}
public class SampleDto : IDto {
public virtual int Id {get;set;}
public virtual int? Id2 {get;set;}
public virtual Task<int> Id3 {get;set;}
}
public class DtoController<TDto>
where TDto : IDto
{
}
public class SamplesController : DtoController<SampleDto>
{
}
";
DefaultProjectDtosProvider dtosProvider = new DefaultProjectDtosProvider(new DefaultProjectDtoControllersProvider());
Dto dto = dtosProvider.GetProjectDtos(CreateProjectFromSourceCodes(dtoCode)).Single();
Assert.AreEqual("Int32", dto.Properties.ElementAt(0).Type.GetUnderlyingTypeSymbol().Name);
Assert.AreEqual("Int32", dto.Properties.ElementAt(1).Type.GetUnderlyingTypeSymbol().Name);
Assert.AreEqual("Int32", dto.Properties.ElementAt(2).Type.GetUnderlyingTypeSymbol().Name);
}
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");
}
}
public async Task ITypeSymbolExtensionsShouldDetectNullableTypeSymbolAsDesired()
{
string dtoCode = @"
public interface IDto {
}
public class SampleDto : IDto {
public virtual int Id {get;set;}
public virtual int? Id2 {get;set;}
public virtual string Id3 {get;set;}
}
public class DtoController<TDto>
where TDto : IDto
{
}
public class SamplesController : DtoController<SampleDto>
{
}
";
DefaultProjectDtosProvider dtosProvider = new DefaultProjectDtosProvider(new DefaultProjectDtoControllersProvider());
Dto dto = (await dtosProvider.GetProjectDtos(CreateProjectFromSourceCodes(dtoCode))).Single();
Assert.IsFalse(dto.Properties.ElementAt(0).Type.IsNullable());
Assert.IsTrue(dto.Properties.ElementAt(1).Type.IsNullable());
Assert.IsTrue(dto.Properties.ElementAt(2).Type.IsNullable());
}
public async Task ITypeSymbolExtensionsShouldReturnTypeScriptElementTypeNameAsDesired()
{
string dtoCode = @"
public interface IDto {
}
public class SampleDto : IDto {
public virtual System.Linq.IQueryable<int> Id {get;set;}
}
public class DtoController<TDto>
where TDto : IDto
{
}
public class SamplesController : DtoController<SampleDto>
{
}
";
DefaultProjectDtosProvider dtosProvider = new DefaultProjectDtosProvider(new DefaultProjectDtoControllersProvider());
Dto dto = (await dtosProvider.GetProjectDtos(CreateProjectFromSourceCodes(dtoCode))).Single();
Assert.AreEqual("number", (dto.Properties.ElementAt(0).Type as INamedTypeSymbol).GetTypeScriptElementTypeName());
}
public virtual async Task ISyncableDtoShouldHaveISVProperty()
{
const string sourceCodeOfDtoControllerWithActionAndParameter = @"
public interface IDto {
}
public interface ISyncableDto : IDto {
}
public class TestDto : ISyncableDto {
public bool ISV { get; set; }
}
public class DtoController<TDto>
where TDto : IDto
{
}
public class TestController : DtoController<TestDto>
{
}
";
IProjectDtosProvider projectDtosProvider = new DefaultProjectDtosProvider(new DefaultProjectDtoControllersProvider());
Assert.AreEqual(1, projectDtosProvider.GetProjectDtos(CreateProjectFromSourceCodes(sourceCodeOfDtoControllerWithActionAndParameter)).Single().Properties.Count);
}
public virtual async Task IDtoShouldNotHaveIsSyncedPropertyWhenItIsNotISyncable()
{
const string sourceCodeOfDtoControllerWithActionAndParameter = @"
public interface IDto {
}
public interface ISyncableDto : IDto {
}
public class TestDto : IDto {
}
public class DtoController<TDto>
where TDto : IDto
{
}
public class TestController : DtoController<TestDto>
{
}
";
IProjectDtosProvider projectDtosProvider = new DefaultProjectDtosProvider(new DefaultProjectDtoControllersProvider());
Assert.AreEqual(0, (await projectDtosProvider.GetProjectDtos(CreateProjectFromSourceCodes(sourceCodeOfDtoControllerWithActionAndParameter))).Single().Properties.Count);
}
public virtual async Task DefaultDtosProviderShouldReturnDtosInOrdered()
{
const string sourceCodes = @"
public interface IDto {
}
public class DtoController<TDto>
where TDto : IDto
{
}
public class XDto : CityDto
{
public CustomerDto Customer { get; set; }
}
public class PersonDto : IDto
{
public int Id { get; set; }
}
public class CustomerDto : PersonDto
{
public CityDto City { get; set; }
}
public class CityDto : IDto
{
public int Id { get; set; }
}
public class PeopleController : DtoController<PersonDto>
{
}
public class CustomersController : DtoController<CustomerDto>
{
}
public class CitiesController : DtoController<CityDto>
{
}
public class XController : DtoController<XDto>
{
}
";
IProjectDtosProvider projectDtosProvider = new DefaultProjectDtosProvider(new DefaultProjectDtoControllersProvider());
IList <Dto> result = projectDtosProvider.GetProjectDtos(CreateProjectFromSourceCodes(sourceCodes));
Assert.IsTrue(result.Select(dto => dto.DtoSymbol.Name).SequenceEqual(new[] { "CityDto", "XDto", "PersonDto", "CustomerDto" }));
}
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 ITypeSymbolExtensionsShouldFindDtosAsDesired()
{
string dtoCode = @"
public interface IDto {
}
public interface ISyncableDto : IDto {
}
public class Person : IDto {
}
public class Person2 : ISyncableDto {
}
public class Person3 : IDto , ISyncableDto {
}
public class Person4 {
}
public class DtoController<TDto>
where TDto : IDto
{
}
public class PeopleController : DtoController<Person>
{
}
public class People2Controller : DtoController<Person2>
{
}
public class People3Controller : DtoController<Person3>
{
}
";
DefaultProjectDtosProvider dtosProvider = new DefaultProjectDtosProvider(new DefaultProjectDtoControllersProvider());
Dto[] dtos = (await dtosProvider.GetProjectDtos(CreateProjectFromSourceCodes(dtoCode))).ToArray();
Assert.IsTrue(new[] { "Person3", "Person2", "Person" }.SequenceEqual(dtos.Select(d => d.DtoSymbol.Name).ToArray()));
}
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 DefaultProjectDtosProviderShouldReturnDtosOfTestProjectAsDesired()
{
using (Workspace workspace = GetWorkspace())
{
Solution solution = workspace.CurrentSolution;
IProjectDtosProvider projectDtosProvider = new DefaultProjectDtosProvider(new DefaultProjectDtoControllersProvider());
IList <Dto> dtos = projectDtosProvider.GetProjectDtos(solution.Projects.Single(p => p.Name == "Foundation.Test")).ToList();
Assert.AreEqual(11, dtos.Count);
}
}
public virtual async Task DefaultProjectDtosProviderShouldReturnDtosAsDesired()
{
using (Workspace workspace = await GetWorkspace())
{
Solution solution = workspace.CurrentSolution;
IProjectDtosProvider projectDtosProvider = new DefaultProjectDtosProvider(new DefaultProjectDtoControllersProvider());
IList <Dto> dtos = (await projectDtosProvider.GetProjectDtos(solution.Projects.Single(p => p.Name == "Bit.OData"))).ToList();
Assert.IsTrue(dtos.Select(d => d.DtoSymbol.Name).SequenceEqual(new[] { "UserSetting", "JobInfoDto", "ClientLogDto" }));
}
}
public async Task ITypeSymbolExtensionsShouldReturnEdmTypeNameAsDesired()
{
string dtoCode = @"
public interface IDto {
}
public class Person : IDto {
}
public class SampleDto : IDto {
public virtual int Id {get;set;}
public virtual string Id2 {get;set;}
public virtual Task<string> Id3 {get;set;}
public virtual int? Id4 {get;set;}
public virtual IEnumerable<int> Id5 {get;set;}
public virtual System.Linq.IQueryable<int> Id6 {get;set;}
public virtual System.Threading.Tasks.Task<int[]> Id7 {get;set;}
public virtual System.Threading.Tasks.Task<System.Linq.IQueryable<int>> Id8 {get;set;}
public virtual Person Id9 {get;set;}
}
public class DtoController<TDto>
where TDto : IDto
{
}
public class SamplesController : DtoController<SampleDto>
{
}
";
DefaultProjectDtosProvider dtosProvider = new DefaultProjectDtosProvider(new DefaultProjectDtoControllersProvider());
Dto dto = (await dtosProvider.GetProjectDtos(CreateProjectFromSourceCodes(dtoCode))).Last();
Assert.AreEqual("Edm.Int32", (dto.Properties.ElementAt(0).Type as INamedTypeSymbol).GetEdmTypeName(useArrayForIEnumerableTypes: true));
Assert.AreEqual("Edm.String", (dto.Properties.ElementAt(1).Type as INamedTypeSymbol).GetEdmTypeName(useArrayForIEnumerableTypes: true));
Assert.AreEqual("Edm.String", (dto.Properties.ElementAt(2).Type as INamedTypeSymbol).GetEdmTypeName(useArrayForIEnumerableTypes: true));
Assert.AreEqual("Edm.Int32", (dto.Properties.ElementAt(3).Type as INamedTypeSymbol).GetEdmTypeName(useArrayForIEnumerableTypes: true));
Assert.AreEqual("Array", (dto.Properties.ElementAt(4).Type as INamedTypeSymbol).GetEdmTypeName(useArrayForIEnumerableTypes: true));
Assert.AreEqual("Array", (dto.Properties.ElementAt(5).Type as INamedTypeSymbol).GetEdmTypeName(useArrayForIEnumerableTypes: true));
Assert.AreEqual("Array", (dto.Properties.ElementAt(6).Type as INamedTypeSymbol).GetEdmTypeName(useArrayForIEnumerableTypes: true));
Assert.AreEqual("Array", (dto.Properties.ElementAt(7).Type as INamedTypeSymbol).GetEdmTypeName(useArrayForIEnumerableTypes: true));
Assert.AreEqual("Person", (dto.Properties.ElementAt(8).Type as INamedTypeSymbol).GetEdmTypeName(useArrayForIEnumerableTypes: true));
}
public virtual async Task DefaultDtosProviderShouldReturnDtosOfGenericDesign()
{
const string sourceCodes = @"
public interface IDto {
}
public class DtoController<TDto>
where TDto : IDto
{
}
public class PersonDto : IDto
{
public int Id { get; set; }
}
public class CustomerDto : PersonDto
{
}
public class EmployeeDto : PersonDto
{
}
public class PeopleController<TPersonDto> : DtoController<TPersonDto>
where TPersonDto : PersonDto
{
}
public class CustomersController : PeopleController<CustomerDto>
{
}
public class EmployeesController : PeopleController<EmployeeDto>
{
}
";
IProjectDtosProvider projectDtosProvider = new DefaultProjectDtosProvider(new DefaultProjectDtoControllersProvider());
IList <Dto> result = projectDtosProvider.GetProjectDtos(CreateProjectFromSourceCodes(sourceCodes));
Assert.IsTrue(result.Select(dto => dto.DtoSymbol.Name).SequenceEqual(new[] { "PersonDto", "EmployeeDto", "CustomerDto" }));
}
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);
}
}
public async Task ITypeSymbolExtensionsShouldDetectIsCollectionTypeAsDesired()
{
string dtoCode = @"
public interface IDto {
}
public class SampleDto : IDto {
public virtual int Id {get;set;}
public virtual string Id2 {get;set;}
public virtual Task<string> Id3 {get;set;}
public virtual int? Id4 {get;set;}
public virtual IEnumerable<int> Id5 {get;set;}
public virtual int[] Id6 {get;set;}
public virtual System.Linq.IQueryable<int> Id7 {get;set;}
public virtual System.Threading.Tasks.Task<int[]> Id8 {get;set;}
public virtual System.Threading.Tasks.Task<System.Linq.IQueryable<int>> Id9 {get;set;}
}
public class DtoController<TDto>
where TDto : IDto
{
}
public class SamplesController : DtoController<SampleDto>
{
}
";
DefaultProjectDtosProvider dtosProvider = new DefaultProjectDtosProvider(new DefaultProjectDtoControllersProvider());
Dto dto = (await dtosProvider.GetProjectDtos(CreateProjectFromSourceCodes(dtoCode))).Single();
Assert.IsFalse(dto.Properties.ElementAt(0).Type.IsCollectionType());
Assert.IsFalse(dto.Properties.ElementAt(1).Type.IsCollectionType());
Assert.IsFalse(dto.Properties.ElementAt(2).Type.IsCollectionType());
Assert.IsFalse(dto.Properties.ElementAt(3).Type.IsCollectionType());
Assert.IsTrue(dto.Properties.ElementAt(4).Type.IsCollectionType());
Assert.IsTrue(dto.Properties.ElementAt(5).Type.IsCollectionType());
Assert.IsTrue(dto.Properties.ElementAt(6).Type.IsCollectionType());
Assert.IsTrue(dto.Properties.ElementAt(7).Type.IsCollectionType());
Assert.IsTrue(dto.Properties.ElementAt(8).Type.IsCollectionType());
}
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);
}
}
public async Task ISymbolExtensionsShouldReturnCommentsAsDesired()
{
string dtoCode = @"
public interface IDto {
}
public class SampleDto : IDto {
/// <summary>
/// Test
/// </summary>
public virtual int Id {get;set;}
public virtual string Test {get;set;}
}
public class DtoController<TDto>
where TDto : IDto
{
}
public class SamplesController : DtoController<SampleDto>
{
}
";
DefaultProjectDtosProvider dtosProvider = new DefaultProjectDtosProvider(new DefaultProjectDtoControllersProvider());
Dto dto = (await dtosProvider.GetProjectDtos(CreateProjectFromSourceCodes(dtoCode))).Single();
Assert.AreEqual(@"/**
Test
*/", dto.Properties.ElementAt(0).GetDocumentationSummary());
Assert.AreEqual("", dto.Properties.ElementAt(1).GetDocumentationSummary());
}
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;
}
}
public void IPropertySymbolExtensionsShouldDeterminateKeyPropertiesAsDesired()
{
string dtoCode = @"
public interface IDto {
}
public class SampleDto : IDto {
public virtual int Id {get;set;}
public virtual int SampleDtoId {get;set;}
[KeyAttribute]
public virtual int SomeKye{get;set;}
public virtual string NotAKey{get;set;}
}
public class DtoController<TDto>
where TDto : IDto
{
}
public class SamplesController : DtoController<SampleDto>
{
}
";
DefaultProjectDtosProvider dtosProvider = new DefaultProjectDtosProvider(new DefaultProjectDtoControllersProvider());
Dto dto = dtosProvider.GetProjectDtos(CreateProjectFromSourceCodes(dtoCode)).Single();
Assert.IsFalse(dto.Properties.ElementAt(0).IsKey());
Assert.IsFalse(dto.Properties.ElementAt(1).IsKey());
Assert.IsTrue(dto.Properties.ElementAt(2).IsKey());
Assert.IsFalse(dto.Properties.ElementAt(3).IsKey());
}
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 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" }));
}
public virtual void DefaultDtosProviderShouldReturnComplexTypesOfSourceProjectsOnly()
{
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 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; }
}
";
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; }
}
";
Project otherProject = CreateProjectFromSourceCodes(otherProjectCodes);
Project sourceProject = CreateProjectFromSourceCodesWithExistingSolution(otherProject.Solution, sourceProjectCodes);
sourceProject = sourceProject.AddProjectReference(new ProjectReference(otherProject.Id));
DefaultProjectDtosProvider projectDtosProvider = new DefaultProjectDtosProvider(new DefaultProjectDtoControllersProvider());
Dto[] dtos = projectDtosProvider.GetProjectDtos(sourceProject).ToArray();
Assert.IsTrue(dtos.Select(d => d.DtoSymbol.Name).SequenceEqual(new[] { "ComplexObj3", "ComplexObj", "TestComplexDto" }));
}
