files tree made better.

src/cli/Services/EMailer.cs

@@ -0,0 +1,187 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Emit;
+using Microsoft.AspNet.Razor;
+using Microsoft.Extensions.Localization;
+using Microsoft.Extensions.Logging;
+using Microsoft.AspNet.Identity.EntityFramework;
+
+using Yavsc.Models;
+using Yavsc.Templates;
+using Yavsc.Abstract.Templates;
+using Yavsc.Services;
+using Yavsc.Abstract.Manage;
+
+namespace cli.Services
+{
+
+    public class EMailer
+    {
+        const string DefaultBaseClassName = "ATemplate";
+        const string DefaultBaseClass = nameof(UserOrientedTemplate);
+        const string DefaultNamespace = "CompiledRazorTemplates";
+
+        RazorTemplateEngine razorEngine;
+        IStringLocalizer<EMailer> stringLocalizer;
+        ILogger logger;
+        ApplicationDbContext dbContext;
+        IEmailSender mailSender;
+        RazorEngineHost host;
+
+        public EMailer(ApplicationDbContext context, IEmailSender sender, IStringLocalizer<EMailer> localizer, ILoggerFactory loggerFactory)
+        {
+            stringLocalizer = localizer;
+            mailSender = sender;
+
+            logger = loggerFactory.CreateLogger<EMailer>();
+
+            var language = new CSharpRazorCodeLanguage();
+
+            host = new RazorEngineHost(language)
+            {
+                DefaultBaseClass = DefaultBaseClass,
+                DefaultClassName = DefaultBaseClassName,
+                DefaultNamespace = DefaultNamespace
+            };
+
+            host.NamespaceImports.Add("System");
+            host.NamespaceImports.Add("Yavsc.Templates");
+            host.NamespaceImports.Add("Yavsc.Models");
+            host.NamespaceImports.Add("Yavsc.Models.Identity");
+            host.NamespaceImports.Add("Microsoft.AspNet.Identity.EntityFramework");
+            host.InstrumentedSourceFilePath = ".";
+            host.StaticHelpers = true;
+            dbContext = context;
+            razorEngine = new RazorTemplateEngine(host);
+        }
+
+
+        public void SendMonthlyEmail(long templateCode, string baseclassName = DefaultBaseClassName)
+        {
+            string className = "Generated" + baseclassName;
+
+            string subtemp = stringLocalizer["MonthlySubjectTemplate"].Value;
+
+            logger.LogInformation($"Generating {subtemp}[{className}]");
+
+            var templateInfo = dbContext.MailingTemplate.FirstOrDefault(t => t.Id == templateCode);
+
+            if (templateInfo==null) throw new Exception($"No template found under id {templateCode}.");  
+            logger.LogInformation($"Using code: {templateCode},  subject: {subtemp} ");
+            logger.LogInformation("And body:\n"+templateInfo.Body);
+            using (StringReader reader = new StringReader(templateInfo.Body))
+            {
+                
+                // Generate code for the template
+                var razorResult = razorEngine.GenerateCode(reader, className, DefaultNamespace, DefaultNamespace+".cs");
+
+                logger.LogInformation("Razor exited " + (razorResult.Success ? "Ok" : "Ko") + ".");
+
+                logger.LogInformation(razorResult.GeneratedCode);
+                SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(razorResult.GeneratedCode);
+                logger.LogInformation("CSharp parsed");
+                List<MetadataReference> references = new List<MetadataReference>();
+
+                foreach (var type in new Type[] { 
+                    typeof(object),
+                    typeof(Enumerable),
+                    typeof(IdentityUser), 
+                    typeof(ApplicationUser), 
+                    typeof(Template), 
+                    typeof(UserOrientedTemplate),
+                    typeof(System.Threading.Tasks.TaskExtensions)
+                 } )
+                {
+                    var location = type.Assembly.Location;
+                    if (!string.IsNullOrWhiteSpace(location)) {
+                        references.Add(
+                            MetadataReference.CreateFromFile(location)
+                        );
+                        logger.LogInformation($"Assembly for {type.Name} found at {location}");
+                    } else logger.LogWarning($"Assembly Not found for {type.Name}");
+                }
+
+                logger.LogInformation("Compilation creation ...");
+
+                var compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
+                    .WithAllowUnsafe(true).WithOptimizationLevel(OptimizationLevel.Debug)
+                    .WithOutputKind(OutputKind.DynamicallyLinkedLibrary).WithPlatform(Platform.AnyCpu)
+                    .WithUsings("Yavsc.Templates")
+                    ;
+                string assemblyName = DefaultNamespace;
+                CSharpCompilation compilation = CSharpCompilation.Create(
+                    assemblyName,
+                    syntaxTrees: new[] { syntaxTree },
+                    references: references,
+                    options: compilationOptions
+                    );
+
+                using (var ms = new MemoryStream())
+                {
+                    logger.LogInformation("Emitting result ...");
+                    EmitResult result = compilation.Emit(ms);
+                    foreach (Diagnostic diagnostic in result.Diagnostics.Where(diagnostic =>
+                            diagnostic.Severity < DiagnosticSeverity.Error && !diagnostic.IsWarningAsError))
+                    {
+                        logger.LogWarning("{0}: {1}", diagnostic.Id, diagnostic.GetMessage());
+                        logger.LogWarning("{0}: {1}", diagnostic.Id, diagnostic.Location.GetLineSpan());
+                    }
+                    if (!result.Success)
+                    {
+                        logger.LogInformation(razorResult.GeneratedCode);
+                        IEnumerable<Diagnostic> failures = result.Diagnostics.Where(diagnostic =>
+                            diagnostic.IsWarningAsError ||
+                            diagnostic.Severity == DiagnosticSeverity.Error);
+                        foreach (Diagnostic diagnostic in failures)
+                        {
+                            logger.LogCritical("{0}: {1}", diagnostic.Id, diagnostic.GetMessage());
+                            logger.LogCritical("{0}: {1}", diagnostic.Id, diagnostic.Location.GetLineSpan());
+                        }
+                    }
+                    else
+                    {
+                        logger.LogInformation(razorResult.GeneratedCode);
+                        ms.Seek(0, SeekOrigin.Begin);
+                        Assembly assembly = Assembly.Load(ms.ToArray());
+
+                        Type type = assembly.GetType(DefaultNamespace + "." + className);
+                        var generatedtemplate = (UserOrientedTemplate) Activator.CreateInstance(type);
+                        if (generatedtemplate==null) {
+                            logger.LogError("No generated template ... exiting.");
+                            throw new InvalidOperationException("No generated template");
+                        }
+                        foreach (var user in dbContext.ApplicationUser.Where(
+                            u => u.AllowMonthlyEmail
+                        ))
+                        {
+                            logger.LogInformation("Generation for " + user.UserName);
+                            generatedtemplate.Init();
+                            generatedtemplate.User = user;
+                            generatedtemplate.ExecuteAsync(); 
+                            logger.LogInformation(generatedtemplate.GeneratedText);
+                            EmailSentViewModel mailSentInfo = this.mailSender.SendEmailAsync
+                                (user.UserName, user.Email, $"monthly email", generatedtemplate.GeneratedText).Result;
+                            if (mailSentInfo==null) 
+                                logger.LogError("No info on sending");
+                            else if (!mailSentInfo.Sent)
+                                logger.LogError($"{mailSentInfo.ErrorMessage}");
+                            else 
+                                logger.LogInformation($"mailId:{mailSentInfo.MessageId} \nto:{user.UserName}");
+
+
+                            
+                        }
+
+                    }
+                }
+            }
+
+        }
+    }
+}

src/cli/Services/YaRazorEngineHost.cs

@@ -0,0 +1,11 @@
+using Microsoft.AspNet.Razor;
+
+namespace cli
+{
+    public class YaRazorEngineHost: RazorEngineHost
+    {
+        public YaRazorEngineHost(): base()
+        {
+        }
+    }
+}