Common

- GlobalOptions renamed to GlobalSettings
- Service for license check added
- File compare before overwrite fixed
- Formatter support for tools like Prettier added

Fluent
- force overwrite a file added
- Formatter support added
- rename a member added
- change return type added
- documentation improved

Author: ky-one

AspDotNet/Fluent/IAspDotNetReadSyntax.cs

@@ -1,4 +1,6 @@
-namespace KY.Generator.AspDotNet.Fluent
+using System;
+
+namespace KY.Generator.AspDotNet.Fluent
 {
     public interface IAspDotNetReadSyntax
     {

Common.Tests/Models/TestOutput.cs

@@ -10,7 +10,7 @@ public class TestOutput : IOutput
 
         public long Lines { get; }
 
-        public void Write(string fileName, string content, bool ignoreOutputId = false, bool forceOverwrite = false)
+        public void Write(string fileName, string content, IOptions options, bool ignoreOutputId = false, bool forceOverwrite = false)
         {
             this.Files.Add(new TestFile(fileName, content));
         }

Common/Commands/OptionsCommand.cs

@@ -2,54 +2,43 @@
 using System.Collections.Generic;
 using KY.Core;
 using KY.Generator.Command;
+using KY.Generator.Settings;
 using KY.Generator.Statistics;
 
 namespace KY.Generator.Commands
 {
     internal class OptionsCommand : GeneratorCommand<OptionsCommandParameters>
     {
-        private readonly GlobalOptions globalOptions;
         private readonly StatisticsService statisticsService;
         private readonly GlobalStatisticsService globalStatisticsService;
+        private readonly GlobalSettingsService globalSettingsService;
         public override string[] Names { get; } = { "set" };
 
-        public OptionsCommand(GlobalOptions globalOptions, StatisticsService statisticsService, GlobalStatisticsService globalStatisticsService)
+        public OptionsCommand(StatisticsService statisticsService, GlobalStatisticsService globalStatisticsService, GlobalSettingsService globalSettingsService)
         {
-            this.globalOptions = globalOptions;
             this.statisticsService = statisticsService;
             this.globalStatisticsService = globalStatisticsService;
+            this.globalSettingsService = globalSettingsService;
         }
 
         public override IGeneratorCommandResult Run()
         {
             if ("statistics".Equals(this.Parameters.Option, StringComparison.CurrentCultureIgnoreCase))
             {
+                List<Guid> ids = this.globalStatisticsService.GetIds();
                 if ("disable".Equals(this.Parameters.Value, StringComparison.CurrentCultureIgnoreCase))
                 {
-                    this.globalOptions.StatisticsEnabled = false;
+                    this.statisticsService.Disable(ids);
                 }
                 else if ("enable".Equals(this.Parameters.Value, StringComparison.CurrentCultureIgnoreCase))
                 {
-                    this.globalOptions.StatisticsEnabled = true;
+                    this.statisticsService.Enable(ids);
                 }
                 else
                 {
                     Logger.Error($"Invalid value '{this.Parameters.Value}' for option '{this.Parameters.Option}'. Valid values are 'enable' or 'disable'");
                     return this.Error();
                 }
-                this.globalOptions.Save();
-                List<Guid> ids = this.globalStatisticsService.GetIds();
-                if (ids.Count > 0)
-                {
-                    if (this.globalOptions.StatisticsEnabled)
-                    {
-                        this.statisticsService.Enable(ids);
-                    }
-                    else
-                    {
-                        this.statisticsService.Disable(ids);
-                    }
-                }
             }
             else
             {

Common/Commands/StatisticsCommand.cs

@@ -1,5 +1,6 @@
 using KY.Core.DataAccess;
 using KY.Generator.Command;
+using KY.Generator.Settings;
 using KY.Generator.Statistics;
 
 namespace KY.Generator.Commands
@@ -8,12 +9,14 @@ internal class StatisticsCommand : GeneratorCommand<StatisticsCommandParameters>
     {
         private readonly GlobalStatisticsService globalStatisticsService;
         private readonly StatisticsService statisticsService;
+        private readonly GlobalSettingsService globalSettingsService;
         public override string[] Names { get; } = { "statistics", "statistic", "stats", "stat" };
 
-        public StatisticsCommand(GlobalStatisticsService globalStatisticsService, StatisticsService statisticsService)
+        public StatisticsCommand(GlobalStatisticsService globalStatisticsService, StatisticsService statisticsService, GlobalSettingsService globalSettingsService)
         {
             this.globalStatisticsService = globalStatisticsService;
             this.statisticsService = statisticsService;
+            this.globalSettingsService = globalSettingsService;
         }
 
         public override IGeneratorCommandResult Run()
@@ -27,8 +30,11 @@ public override IGeneratorCommandResult Run()
             this.globalStatisticsService.Append(statistic);
             this.globalStatisticsService.Analyze();
             this.globalStatisticsService.Write();
-            this.statisticsService.Anonymize(statistic);
-            this.statisticsService.Submit(statistic);
+            if (this.globalSettingsService.Read().StatisticsEnabled)
+            {
+                this.statisticsService.Anonymize(statistic);
+                this.statisticsService.Submit(statistic);
+            }
             return this.Success();
         }
     }

Common/Extensions/FileTemplateExtension.cs

@@ -17,7 +17,7 @@ public static void Write(this FileTemplate file, IOutput output)
             // Logger.Trace($"Start generate file {file.Name}");
             FileWriter writer = new(file.Options);
             writer.Add(file);
-            output.Write(file.FullPath, writer.ToString(), !file.WriteOutputId, file.ForceOverwrite);
+            output.Write(file.FullPath, writer.ToString(), file.Options, !file.WriteOutputId, file.ForceOverwrite);
             // Logger.Trace($"Finish generate file {file.Name}");
         }
     }

Common/Generator.cs

@@ -15,9 +15,11 @@
 using KY.Generator.Commands;
 using KY.Generator.Extensions;
 using KY.Generator.Languages;
+using KY.Generator.Licensing;
 using KY.Generator.Mappings;
 using KY.Generator.Models;
 using KY.Generator.Output;
+using KY.Generator.Settings;
 using KY.Generator.Statistics;
 using KY.Generator.Syntax;
 using KY.Generator.Templates;
@@ -35,9 +37,8 @@ public class Generator : IGeneratorRunSyntax
 
         public Generator()
         {
+            DateTime start = DateTime.Now;
             Logger.CatchAll();
-            this.statisticsService = new StatisticsService(this.environment);
-            this.statisticsService.ProgramStart();
             Assembly callingAssembly = Assembly.GetEntryAssembly() ?? Assembly.GetCallingAssembly();
             FrameworkName framework = callingAssembly.GetTargetFramework();
             Logger.Trace($"KY-Generator v{callingAssembly.GetName().Version} ({framework.Identifier.Replace("App", string.Empty)} {framework.Version.Major}.{framework.Version.Minor})");
@@ -56,9 +57,14 @@ public Generator()
             this.output = new FileOutput(this.resolver.Get<IEnvironment>(), Environment.CurrentDirectory);
             this.resolver.Bind<IOutput>().To(this.output);
             this.resolver.Bind<List<FileTemplate>>().To(new List<FileTemplate>());
-            this.resolver.Bind<StatisticsService>().To(this.statisticsService);
+            this.resolver.Bind<StatisticsService>().ToSingleton();
             this.resolver.Bind<GlobalStatisticsService>().ToSingleton();
-            this.resolver.Bind<IGlobalOptions>().ToSingleton<GlobalOptions>();
+            this.resolver.Bind<GlobalSettingsService>().ToSingleton();
+            this.resolver.Bind<LicenseService>().ToSingleton();
+            this.resolver.Get<LicenseService>().Check();
+
+            this.statisticsService = this.resolver.Get<StatisticsService>();
+            this.statisticsService.ProgramStart(start);
 
             ModuleFinder moduleFinder = this.resolver.Get<ModuleFinder>();
             this.InitializeModules(moduleFinder.Modules);
@@ -140,6 +146,10 @@ public bool Run()
                 IGeneratorCommandResult switchContext = null;
                 bool switchAsync = false;
                 this.commands.ForEach(command => command.Prepare());
+                if (!this.resolver.Get<LicenseService>().Wait(TimeSpan.FromMilliseconds(250)))
+                {
+                    Logger.Warning($"Can not check license. Some modules may be deactivated.");
+                }
                 foreach (IGeneratorCommand command in this.commands)
                 {
                     IGeneratorCommandResult result = runner.Run(command);
@@ -176,7 +186,7 @@ public bool Run()
                     return this.SwitchContext(switchContext, asyncCommands);
                 }
                 this.statisticsService.ProgramEnd(files.Count);
-                if (!this.commands.OfType<StatisticsCommand>().Any() && this.resolver.Get<GlobalOptions>().StatisticsEnabled)
+                if (!this.commands.OfType<StatisticsCommand>().Any() && this.resolver.Get<GlobalSettingsService>().Read().StatisticsEnabled)
                 {
                     string fileName = this.statisticsService.Write();
                     this.resolver.Get<GlobalStatisticsService>().StartCalculation(fileName);

Common/Languages/BaseLanguage.cs

@@ -9,7 +9,6 @@
 using KY.Generator.Templates;
 using KY.Generator.Writers;
 using FileWriter = KY.Generator.Writers.FileWriter;
-using OutputFileWriter = KY.Generator.Output.FileWriter;
 
 namespace KY.Generator.Languages
 {

Common/Licensing/LicenseService.cs

@@ -0,0 +1,71 @@
+using System;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using KY.Core;
+using KY.Generator.Settings;
+using Newtonsoft.Json;
+
+namespace KY.Generator.Licensing
+{
+    public class LicenseService
+    {
+        private readonly GlobalSettingsService globalSettingsService;
+        private readonly ManualResetEvent waitForCheck = new(false);
+        private string license;
+
+        public LicenseService(GlobalSettingsService globalSettingsService)
+        {
+            this.globalSettingsService = globalSettingsService;
+        }
+
+        public async void Check()
+        {
+            try
+            {
+                this.license = await this.SendCommand<string>($"{this.globalSettingsService.Read().License}/check");
+                this.waitForCheck.Set();
+            }
+            catch (Exception exception)
+            {
+                Logger.Warning(exception.Message + Environment.NewLine + exception.StackTrace);
+            }
+        }
+
+        public string Get()
+        {
+            return this.license;
+        }
+
+        /// <summary>Blocks the current thread until the license is checked, using a <see cref="T:System.TimeSpan" /> to specify a optional timeout.</summary>
+        /// <param name="timeout">A <see cref="T:System.TimeSpan" /> that represents the number of milliseconds to wait, or a null to wait indefinitely.</param>
+        /// <returns>
+        /// <see langword="true" /> if the was checked successful; otherwise, <see langword="false" />.</returns>
+        public bool Wait(TimeSpan? timeout = null)
+        {
+            return timeout.HasValue ? this.waitForCheck.WaitOne(timeout.Value) : this.waitForCheck.WaitOne();
+        }
+
+        private async Task<T> SendCommand<T>(string command, string query = "")
+        {
+#if DEBUG
+            string baseUri = "http://localhost:8087/api/v1/license";
+#else
+            string baseUri = "https://generator.ky-programming.de/api/v1/license";
+#endif
+            HttpWebRequest request = WebRequest.CreateHttp($"{baseUri}/{command}?{query}");
+            request.Method = WebRequestMethods.Http.Get;
+            WebResponse response = request.GetResponse();
+            using Stream responseStream = response.GetResponseStream();
+            string responseString = await responseStream.ReadStringAsync();
+            if (responseString.StartsWith("[") || responseString.StartsWith("{") || responseString.StartsWith("\""))
+            {
+                return JsonConvert.DeserializeObject<T>(responseString);
+            }
+            Logger.Warning(responseString);
+            throw new InvalidOperationException("Can not parse the response. No valid json");
+        }
+    }
+}

Common/Options/GlobalOptions.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using KY.Generator.Languages;
+using KY.Generator.Transfer;
 
 namespace KY.Generator
 {
@@ -19,6 +20,10 @@ public interface IOptions
         bool AddHeader { get; set; }
         bool SkipNamespace { get; set; }
         bool OnlySubTypes { get; set; }
+        string Rename { get; set; }
+        TypeTransferObject ReturnType { get; set; }
+        string Formatter { get; set; }
+        bool ForceOverwrite { get; set; }
 
         // TODO: Should be moved to ITypeScriptOptions
         bool Strict { get; set; }

Common/Options/IOptions.cs

@@ -1,6 +1,6 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using KY.Generator.Languages;
+using KY.Generator.Transfer;
 
 namespace KY.Generator
 {
@@ -21,5 +21,9 @@ public class OptionsPart
         public bool? NoIndex { get; set; }
         public Dictionary<string, string> ReplaceName { get; } = new();
         public ILanguage Language { get; set; }
+        public string Rename { get; set; }
+        public TypeTransferObject ReturnType { get; set; }
+        public string Formatter { get; set; }
+        public bool? ForceOverwrite { get; set; }
     }
 }

Common/Options/OptionsPart.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using KY.Core;
 using KY.Generator.Languages;
+using KY.Generator.Transfer;
 
 namespace KY.Generator
 {
@@ -82,6 +83,24 @@ bool IOptions.OnlySubTypes
             set => this.Part.OnlySubTypes = value;
         }
 
+        string IOptions.Rename
+        {
+            get => this.Part.Rename;
+            set => this.Part.Rename = value;
+        }
+
+        TypeTransferObject IOptions.ReturnType
+        {
+            get => this.Part.ReturnType;
+            set => this.Part.ReturnType = value;
+        }
+
+        string IOptions.Formatter
+        {
+            get => this.GetValue(x => x?.Formatter);
+            set => this.Part.Formatter = value;
+        }
+
         bool IOptions.NoIndex
         {
             get => this.Part.NoIndex ?? this.Global?.Part.NoIndex ?? false;
@@ -97,6 +116,12 @@ ILanguage IOptions.Language
             set => this.Part.Language = value;
         }
 
+        bool IOptions.ForceOverwrite
+        {
+            get => this.GetPrimitive(x => x?.ForceOverwrite);
+            set => this.Part.ForceOverwrite = value;
+        }
+
         public OptionsSet(OptionsSet parent, OptionsSet global, OptionsSet caller = null, object target = null)
             : base(parent, global, caller, target)
         {