Exemple #1
0
        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();
            }
        }
Exemple #2
0
        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");
            }
        }
Exemple #3
0
        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);

                DefaultHtmlClientProxyGenerator generator = new DefaultHtmlClientProxyGenerator(new DefaultBitCodeGeneratorOrderedProjectsProvider(),
                                                                                                new DefaultBitConfigProvider(), dtosProvider
                                                                                                , new DefaultHtmlClientProxyDtoGenerator(), new DefaultHtmlClientContextGenerator(), 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 MSBuildWorkspace)
                    {
                        workspaceForCodeGeneration.Dispose();
                    }
                }
            }
            catch (Exception ex)
            {
                LogException("Code Generation failed.", ex);
            }
            finally
            {
                sw?.Stop();
            }
        }
Exemple #4
0
        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 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);
                        DefaultHtmlClientProxyGenerator generator           = new DefaultHtmlClientProxyGenerator(new DefaultBitCodeGeneratorOrderedProjectsProvider(), new DefaultBitConfigProvider(), dtosProvider, new DefaultHtmlClientProxyDtoGenerator(), new DefaultHtmlClientContextGenerator(), 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();
                    }
                }
            }
        }