[WIP] embed code generation

src/cli/Commands/GenerationCommander.cs

@@ -0,0 +1,73 @@
+using cli.Model;
+using Microsoft.Extensions.CommandLineUtils;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.AspNet.Hosting;
+using Microsoft.Extensions.OptionsModel;
+
+using cli.Services;
+using cli.Settings;
+
+namespace cli.Commands
+{
+    public class GenerationCommander : ICommander
+    {
+
+        public GenerationCommander()
+        {
+        }
+
+        public CommandLineApplication Integrate(CommandLineApplication rootApp)
+        {
+            CommandArgument nsarg=null;
+            CommandArgument mdClass=null;
+            CommandArgument ctrlName=null;
+            CommandArgument rPath=null;
+            CommandArgument dbCtx=null;
+
+            var cmd = rootApp.Command("mvc", config => {
+                config.FullName = "mvc controller";
+                config.Description = "generates an mvc controller";
+                nsarg = config.Argument("ns","default name space");
+                mdClass = config.Argument("mc","Model class name");
+                ctrlName = config.Argument("cn", "Controller name");
+                rPath = config.Argument("rp", "Relative path");
+                config.HelpOption("-? | -h | --help");
+            });
+            cmd.OnExecute(() => {
+                var host = new WebHostBuilder();
+                    var hostengnine = host.UseEnvironment("Development")
+                        .UseServer("cli")
+                        .UseStartup<Startup>()
+                        .Build();
+                    var app = hostengnine.Start();
+                    var mailer = app.Services.GetService<MvcGenerator>();
+                    var loggerFactory = app.Services.GetService<ILoggerFactory>();
+                    var logger = loggerFactory.CreateLogger<GenerationCommander>();
+                    var options = app.Services.GetService<IOptions<GenMvcSettings>>();
+
+                    MvcGenerator generator = app.Services.GetService<MvcGenerator>();
+
+                    var modelFullName = mdClass?.Value ?? options?.Value.ModelFullName;
+                    var nameSpace = nsarg?.Value?? options?.Value.NameSpace;
+                    var dbContext = dbCtx?.Value?? options?.Value.DbContextFullName;
+                    var controllerName = ctrlName?.Value?? options?.Value.ControllerName;
+                    var relativePath = rPath?.Value ?? options?.Value.RelativePath;
+
+                    logger.LogInformation("Starting generation");
+                    logger.LogInformation($"Using parameters : modelFullName:{modelFullName} nameSpace:{nameSpace} dbContext:{dbContext} controllerName:{controllerName} relativePath:{relativePath}");
+
+                    generator.Generate(modelFullName,
+                     nameSpace,
+                     dbContext, 
+                     controllerName,
+                     relativePath);
+               
+                    logger.LogInformation("Finished generation");
+
+                return 0;
+            });
+            return cmd;
+        }
+    }
+}

src/cli/Commands/SendMailCommand.cs

@@ -46,6 +46,7 @@ public class SendMailCommandProvider : ICommander {
                 else
                 {
                     sendMailCommandApp.ShowHelp();
+                    return 1;
                 }
                 return 0;
             });

src/cli/Helpers/ConsoleHelpers.cs

@@ -1,11 +1,8 @@
 using System;
-using System.Collections.Generic;
 using System.Text;
-using System.Threading.Tasks;
 using cli.Model;
 using Microsoft.Extensions.CommandLineUtils;
 using Yavsc.Authentication;
-using static OAuth.AspNet.AuthServer.Constants;
 
 namespace cli.Helpers
 {
@@ -31,6 +28,7 @@ namespace cli.Helpers
             settings.Scope,
             new Uri(settings.AuthorizeUrl), new Uri(settings.RedirectUrl), new Uri(settings.AccessTokenUrl));
         }
+        /* TODO add OAut console client
 
         public static async Task<IDictionary<string, string>> GetAuthFromPass(
             string login,
@@ -41,7 +39,7 @@ namespace cli.Helpers
             query[Parameters.Password] = pass;
             query[Parameters.GrantType] = GrantTypes.Password;
             return await OAuthorInstance.RequestAccessTokenAsync(query);
-        }
+        }  */
 
         public static string GetPassword()
         {

src/cli/Program.cs

@@ -1,6 +1,7 @@
 
 using System;
 using cli.Commands;
+using cli.Services;
 using Microsoft.Extensions.CommandLineUtils;
 
 namespace cli
@@ -24,6 +25,7 @@ namespace cli
             (new GenerateJsonSchema()).Integrate(cliapp);
             (new AuthCommander()).Integrate(cliapp);
             (new CiBuildCommand()).Integrate(cliapp);
+            (new GenerationCommander()).Integrate(cliapp);
 
             if (args.Length == 0)
             {

src/cli/Services/EMailer.cs

@@ -172,7 +172,7 @@ namespace cli.Services
                             else if (!mailSentInfo.Sent)
                                 logger.LogError($"{mailSentInfo.ErrorMessage}");
                             else 
-                                logger.LogInformation($"mailId:{mailSentInfo.MessageId} \nto:{user.UserName}");
+                                logger.LogInformation($"mailId:{mailSentInfo?.MessageId} \nto:{user.UserName}");
 
 
                             

src/cli/Services/MvcGenerator.cs

@@ -0,0 +1,30 @@
+using System;
+using Microsoft.Extensions.CodeGenerators.Mvc.Controller;
+
+namespace cli.Services
+{
+    
+    public class MvcGenerator  : CommandLineGenerator
+    {
+        CommandLineGeneratorModel _model;
+        public MvcGenerator (IServiceProvider services): base (services)
+        {
+            _model = new CommandLineGeneratorModel();
+        }
+
+        public async void Generate(
+            string modelClass, 
+            string ns, 
+            string dbContextFullName,
+            string controllerName,
+            string relativeFolderPath
+            )
+        {
+            _model.ControllerName = controllerName;
+            _model.ModelClass = modelClass;
+            _model.DataContextClass = dbContextFullName;
+            _model.RelativeFolderPath = relativeFolderPath;
+            await GenerateCode(_model);
+        }
+    }
+}

src/cli/Settings/GenMvcSettings.cs

@@ -0,0 +1,16 @@
+namespace cli.Settings
+{
+    public class GenMvcSettings
+    {
+        public string NameSpace { get; set; }
+        public string ModelFullName { get; set; }
+        public string ControllerName { get; set; }
+        public string AppBase { get; set; }
+        public string RelativePath { get; set; }
+        public string DbContextFullName { get; set; }
+        
+        // FIXME this appears to be dropped soon ... as all configuration should be concerned
+        public string ConfigurationName { get; set; } = "Development";
+        
+    }
+}

src/cli/Startup.cs

@@ -9,10 +9,24 @@ using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.OptionsModel;
 using Microsoft.Extensions.PlatformAbstractions;
 using Microsoft.Extensions.WebEncoders;
+using Microsoft.Dnx.Compilation;
 using Yavsc;
 using Yavsc.Models;
 using Yavsc.Services;
 using cli.Services;
+using cli.Settings;
+using Microsoft.Extensions.CodeGeneration;
+using Microsoft.Dnx.Runtime.Compilation;
+using Microsoft.Dnx.Runtime;
+using Microsoft.Dnx.Compilation.Caching;
+using Microsoft.Dnx.Host;
+using System.IO;
+using System.Runtime.Versioning;
+using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.CodeGeneration.EntityFramework;
+using Microsoft.Extensions.CodeGeneration.Templating.Compilation;
+using System.Linq;
 
 namespace cli
 {
@@ -20,7 +34,7 @@ namespace cli
     {
         public string ConnectionString
         {
-            get ; set;
+            get; set;
         }
 
         public static ConnectionSettings Settings { get; private set; }
@@ -28,12 +42,16 @@ namespace cli
 
         public static string HostingFullName { get; private set; }
 
-        ILogger logger;
+        public static IServiceCollection Services { get; private set; }
+
+
+
+        Microsoft.Extensions.Logging.ILogger logger;
         public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
         {
-            var devtag = env.IsDevelopment()?"D":"";
+            var devtag = env.IsDevelopment() ? "D" : "";
-            var prodtag = env.IsProduction()?"P":"";
+            var prodtag = env.IsProduction() ? "P" : "";
-            var stagetag = env.IsStaging()?"S":"";
+            var stagetag = env.IsStaging() ? "S" : "";
 
             HostingFullName = $"{appEnv.RuntimeFramework.FullName} [{env.EnvironmentName}:{prodtag}{devtag}{stagetag}]";
             // Set up configuration sources.
@@ -44,10 +62,10 @@ namespace cli
                 .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true);
 
             Configuration = builder.Build();
-            ConnectionString = Configuration["Data:DefaultConnection:ConnectionString"];
+            ConnectionString = Configuration["ConnectionStrings:Default"];
         }
 
-        public void ConfigureServices (IServiceCollection services)
+        public void ConfigureServices(IServiceCollection services)
         {
             services.AddOptions();
             var cxSettings = Configuration.GetSection("Connection");
@@ -55,11 +73,18 @@ namespace cli
             var smtpSettingsconf = Configuration.GetSection("Smtp");
 
             services.Configure<SmtpSettings>(smtpSettingsconf);
+            services.Configure<GenMvcSettings>(Configuration.GetSection("gen_mvc"));
             services.AddInstance(typeof(ILoggerFactory), new LoggerFactory());
             services.AddTransient(typeof(IEmailSender), typeof(MailSender));
             services.AddTransient(typeof(RazorEngineHost), typeof(YaRazorEngineHost));
-            services.AddEntityFramework().AddNpgsql().AddDbContext<ApplicationDbContext>();
+            services.AddTransient(typeof(MvcGenerator), typeof(MvcGenerator));
+            services.AddEntityFramework().AddNpgsql().AddDbContext<ApplicationDbContext>(
+                  db => db.UseNpgsql(ConnectionString)
+              );
+
             services.AddTransient((s) => new RazorTemplateEngine(s.GetService<RazorEngineHost>()));
+            services.AddTransient(typeof(IModelTypesLocator), typeof(ModelTypesLocator));
+            services.AddTransient(typeof(ILibraryExporter), typeof(RuntimeLibraryExporter));
             services.AddLogging();
             services.AddTransient<EMailer>();
             services.AddLocalization(options =>
@@ -67,11 +92,6 @@ namespace cli
                 options.ResourcesPath = "Resources";
             });
 
-            services.AddEntityFramework()
-              .AddNpgsql() 
-              .AddDbContext<ApplicationDbContext>(
-                  db => db.UseNpgsql(ConnectionString)
-              );
             services.Configure<SharedAuthenticationOptions>(options =>
             {
                 options.SignInScheme = "Bearer";
@@ -81,9 +101,120 @@ namespace cli
 
             services.AddAuthentication();
 
+            services.AddSingleton(typeof(IApplicationEnvironment), svs => PlatformServices.Default.Application);
+            services.AddSingleton(typeof(IRuntimeEnvironment), svs => PlatformServices.Default.Runtime);
+            services.AddSingleton(typeof(IAssemblyLoadContextAccessor), svs => PlatformServices.Default.AssemblyLoadContextAccessor);
+            services.AddSingleton(typeof(IAssemblyLoaderContainer), svs => PlatformServices.Default.AssemblyLoaderContainer);
+            services.AddSingleton(typeof(ILibraryManager), svs => PlatformServices.Default.LibraryManager);
+
+            services.AddSingleton(typeof(BootstrapperContext),
+                svs => new BootstrapperContext
+                {
+                    RuntimeDirectory = Path.GetDirectoryName(typeof(BootstrapperContext).Assembly.Location),
+                    ApplicationBase = Configuration["gen_mvc:AppBase"],
+                    // NOTE(anurse): Mono is always "dnx451" (for now).
+                    TargetFramework = new FrameworkName("DNX", new Version(4, 5, 1)),
+                    RuntimeType = "Mono"
+                }
+            );
+
+
+            services.AddTransient(typeof(CompilationEngine),
+              svs => {
+                  var logger =  svs.GetService<ILoggerFactory>().CreateLogger<Startup>();
+                  var project = svs.GetService<Project>();
+                  var env = new ApplicationEnvironment(project,
+                    PlatformServices.Default.Application.RuntimeFramework,
+                    PlatformServices.Default.Application.Configuration,
+                    PlatformServices.Default.Application
+                  );
+                  logger.LogInformation("app name: "+env.ApplicationName);
+
+                  return new CompilationEngine(
+              new CompilationEngineContext(PlatformServices.Default.Application,
+                PlatformServices.Default.Runtime,
+                PlatformServices.Default.AssemblyLoadContextAccessor.Default, new CompilationCache()));
+              });
+            services.AddTransient(typeof(IFrameworkReferenceResolver),
+                    svs => new FrameworkReferenceResolver());
+
+            services.AddTransient(
+                typeof(Project), svs =>
+               {
+                   Project project = null;
+                   var diag = new List<DiagnosticMessage>();
+                   var settings = svs.GetService<IOptions<GenMvcSettings>>();
+                   if (Project.TryGetProject(settings.Value.AppBase, out project, diag))
+                   {
+                       return project;
+                   }
+                   return null;
+               }
+            );
+
+            services.AddTransient(
+                typeof(ILibraryExporter),
+                svs =>
+                {
+                    var settings = svs.GetService<IOptions<GenMvcSettings>>();
+                    var compilationEngine = svs.GetService<CompilationEngine>();
+                    var bootstrappercontext = svs.GetService<BootstrapperContext>();
+                    var project = svs.GetService<Project>();
+                    if (settings == null)
+                        throw new Exception("settings are missing to generate some server code (GenMvcSettings) ");
+
+                    return
+                    new RuntimeLibraryExporter(
+                        () => compilationEngine.CreateProjectExporter
+                        (project, bootstrappercontext.TargetFramework, settings.Value.ConfigurationName));
+
+                }
+
+            );
+            services.AddTransient(typeof(IEntityFrameworkService), typeof(EntityFrameworkServices));
+            services.AddTransient(typeof(IDbContextEditorServices), typeof(DbContextEditorServices));
+            services.AddTransient(typeof(IFilesLocator), typeof(FilesLocator));
+            services.AddTransient(typeof(
+                Microsoft.Extensions.CodeGeneration.Templating.ITemplating), typeof(
+                Microsoft.Extensions.CodeGeneration.Templating.RazorTemplating));
+            services.AddTransient(
+                typeof(Microsoft.Extensions.CodeGeneration.Templating.Compilation.ICompilationService),
+                typeof(Microsoft.Extensions.CodeGeneration.Templating.Compilation.RoslynCompilationService));
+
+services.AddTransient(
+                typeof(
+Microsoft.Extensions.CodeGeneration.ICodeGeneratorActionsService),
+                typeof(Microsoft.Extensions.CodeGeneration.CodeGeneratorActionsService));
+
+
+            services.AddTransient(typeof(Microsoft.Dnx.Compilation.ICompilerOptionsProvider),
+                svs =>
+                {
+                    var bsContext = svs.GetService<BootstrapperContext>();
+                    var compileEngine = svs.GetService<ICompilationEngine>();
+
+                    var applicationHostContext = new ApplicationHostContext
+                    {
+                        ProjectDirectory = bsContext.ApplicationBase,
+                        RuntimeIdentifiers = new string[] { "dnx451" },
+                        TargetFramework = bsContext.TargetFramework
+                    };
+
+                    var libraries = ApplicationHostContext.GetRuntimeLibraries(applicationHostContext, throwOnInvalidLockFile: true);
+                    var projects = libraries.Where(p => p.Type == LibraryTypes.Project)
+                                            .ToDictionary(p => p.Identity.Name, p => (ProjectDescription)p);
+
+                    return new CompilerOptionsProvider(projects);
+                });
+            services.AddMvc();
+            services.AddTransient(typeof(IPackageInstaller),typeof(PackageInstaller));
+            services.AddTransient(typeof(Microsoft.Extensions.CodeGeneration.ILogger),typeof(Microsoft.Extensions.CodeGeneration.ConsoleLogger));
+
+            Services = services;
+
         }
 
-        public void Configure (IApplicationBuilder app, IHostingEnvironment env,
+        public void Configure(IApplicationBuilder app, IHostingEnvironment env,
         IOptions<SiteSettings> siteSettings, ILoggerFactory loggerFactory)
         {
             loggerFactory.AddConsole(Configuration.GetSection("Logging"));

src/cli/appsettings.Development.json

@@ -18,9 +18,15 @@
             "Microsoft": "Warning"
         }
     },
-    "Data": {
+    "ConnectionStrings": {
-        "DefaultConnection": {
+        "Default":"Server=localhost;Port=5432;Database=YavscDev;Username=yavscdev;Password=admin;"
-            "ConnectionString": "Server=localhost;Port=5432;Database=YavscDev;Username=yavscdev;Password=admin;"
+    },
-        }
+    "gen_mvc" : {
+        "NameSpace": "Yavsc",
+        "AppBase": "../Yavsc",
+        "RelativePath": "Controllers/Generated",
+        "DbContextFullName": "Yavsc.Models.ApplicationDbContext",
+        "ControllerName": "LiveFlowController",
+        "ModelFullName": "Yavsc.Models.Streaming.LiveFlow"
     }
 }

src/cli/appsettings.json

@@ -22,9 +22,15 @@
             "Microsoft": "Warning"
         }
     },
-    "Data": {
+    "ConnectionStrings": {
-      "DefaultConnection": {
+        "Default":"[your default connection string]"
-        "ConnectionString": "[sbConStr]"
+    },
-      }
+    "gen_mvc" : {
+        "NameSpace": "Yavsc",
+        "AppBase": "../Yavsc",
+        "RelativePath": "../Yavsc/Controllers/Generated",
+        "DbContextFullName": "Yavsc.Models.ApplicationDbContext",
+        "ControllerName": "LiveFlowController",
+        "ModelFullName": "Yavsc.Models.Streaming.LiveFlow"
     }
 }

src/cli/project.json

@@ -26,7 +26,8 @@
     "Microsoft.AspNet.Mvc": "6.0.0-rc1-*",
     "Microsoft.AspNet.SignalR.Client": "2.2.1",
     "Microsoft.CodeAnalysis": "1.1.0-rc1-20151109-01",
-    "Microsoft.Extensions.CodeGeneration": "1.0.0-rc1-final",
+    "Microsoft.Extensions.CodeGeneration": "1.0.0-beta5",
+    "Microsoft.Extensions.CodeGenerators.Mvc": "1.0.0-rc1-final",
     "Microsoft.Extensions.Configuration.Abstractions": "1.0.0-rc1-final",
     "Microsoft.Extensions.Configuration.FileProviderExtensions": "1.0.0-rc1-final",
     "Microsoft.Extensions.Configuration.UserSecrets": "1.0.0-rc1-final",
@@ -58,12 +59,14 @@
       "version": "1.0.5-rc22",
       "target": "package"
     },
-    "Yavsc.Lib.Portable": "1.0.2",
+    "Microsoft.Dnx.Host": "1.0.0-rc1-final",
-    "OAuth.AspNet.AuthServer": { "target": "project" }
+    "Microsoft.Dnx.Runtime": "1.0.0-rc1-final",
+    "Microsoft.Dnx.DesignTimeHost": "1.0.0-rc1-final"
   },
   "frameworks": {
     "dnx451": {
-      "System.Net": "4.0.0"
+      "System.Net": "4.0.0.0",
+      "System.Xml": "4.0.0.0"
     }
   }
 }