chore(new html): build app and define config settings after new

cmf-cli/Builders/NgBuildFileTokenReplacerCommand.cs

@@ -34,10 +34,12 @@ public bool Test
             }
             public Task Exec()
             {
+                var workingDir = cmfPackage.GetFileInfo().Directory;
+
                 foreach (var app in apps)
                 {
                     // place tokens in assets/config.json
-                    var configJsonPath = this.fileSystem.FileInfo.New($"dist/{app}/assets/config.json");
+                    var configJsonPath = this.fileSystem.FileInfo.New($"{workingDir}/dist/{app}/assets/config.json");
                     if (configJsonPath.Exists)
                     {
                         Log.Debug($"Placing tokens in config.json at {configJsonPath.FullName}");
@@ -64,7 +66,7 @@ public Task Exec()
                         // place app name in index.html
                         // TODO get app name from cmfapp.json
                         var appName = ExecutionContext.Instance.ProjectConfig.ProjectName;
-                        var indexPath = this.fileSystem.FileInfo.New($"dist/{app}/index.html");
+                        var indexPath = this.fileSystem.FileInfo.New($"{workingDir}/dist/{app}/index.html");
                         if (indexPath.Exists)
                         {
                             Log.Debug($"Setting App Name '{appName}' as title in {indexPath.FullName}");
@@ -79,7 +81,7 @@ public Task Exec()
                     }
 
                     // fix trailing slash in ngsw.json
-                    var ngswPath = this.fileSystem.FileInfo.New($"dist/{app}/ngsw.json");
+                    var ngswPath = this.fileSystem.FileInfo.New($"{workingDir}/dist/{app}/ngsw.json");
                     if (ngswPath.Exists)
                     {
                         Log.Debug($"Placing tokens in ngsw.json at {ngswPath.FullName}");

cmf-cli/Commands/new/HTMLCommand.cs

@@ -333,6 +333,7 @@ public void ExecuteV10(IDirectoryInfo workingDir, string version)
             // this won't return null because it has to success on the base.Execute call
             var ngCliVersion = "15"; // v15 for MES 10
             var packageName = base.GeneratePackageName(workingDir)!.Value.Item1;
+            var packageDir = workingDir.GetDirectories(packageName).First();
             var mesVersion = ExecutionContext.Instance.ProjectConfig.MESVersion;
 
             var schematicsVersion = ngxSchematicsVersion.ToString() ?? $"@release-{mesVersion.Major}{mesVersion.Minor}{mesVersion.Build}";
@@ -346,17 +347,61 @@ public void ExecuteV10(IDirectoryInfo workingDir, string version)
                 WorkingDirectory = workingDir,
                 ForceColorOutput = false
             }.Exec();
-
             Log.Debug($"Adding @criticalmanufacturing/ngx-schematics@{schematicsVersion} to the package, which can be used to scaffold new components and libraries");
             // cd <packageName>
             // ng add --skip-confirmation @criticalmanufacturing/ngx-schematics [--npmRegistry http://npm.example/] --lint --base-app <Core|MES>
             new NPXCommand()
             {
                 Command = $"@angular/cli@{ngCliVersion}",
                 Args = new []{ "add", "--registry", ExecutionContext.Instance.ProjectConfig.NPMRegistry.OriginalString, "--skip-confirmation", $"@criticalmanufacturing/ngx-schematics@{schematicsVersion}", "--lint", "--base-app", baseLayer.ToString(), "--version", $"release-{mesVersion.Major}{mesVersion.Minor}{mesVersion.Build}" },
-                WorkingDirectory = workingDir.GetDirectories(packageName).First(),
+                WorkingDirectory = packageDir,
                 ForceColorOutput = false
             }.Exec();
+
+            // build
+            new BuildCommand(fileSystem).Execute(packageDir);
+
+            // config.json
+            var configJsonPath = this.fileSystem.Path.Join(packageDir.FullName, "src",
+                this.fileSystem.Path.Join("assets", "config.json"));
+            var configJsonStr = fileSystem.File.ReadAllText(configJsonPath);
+            if (!configJsonStr.Contains("$("))
+            {
+                // config.json has no tokens and can be malformed. We need to make sure it parses, so we inject some dummy values that will be thrown away later
+                Log.Debug("Generated config.json does not contain tokens and is possibly malformed. Setting some dummy values so we can deserialize it.");
+                configJsonStr = configJsonStr
+                    .Replace("\"port\": ", "\"port\": 0")
+                    .Replace("\"enableSsl\": ,", "\"enableSsl\": false,");
+
+                configJsonStr = Regex.Replace(configJsonStr, "\"isLoadBalancerEnabled\": (false)?\r?\n",
+                    "\"isLoadBalancerEnabled\": false\n");
+            }
+            configJsonStr = Regex.Replace(configJsonStr, @"\$\([^\)]+\)", "0", RegexOptions.Multiline);
+            dynamic configJsonJson = null;
+            try
+            {
+                configJsonJson = JsonConvert.DeserializeObject(configJsonStr);
+            }
+            catch (Exception e)
+            {
+                throw new CliException("Could not load webapp config.json", e);
+            }
+            if (configJsonJson == null)
+            {
+                throw new CliException("Could not load webapp config.json");
+            }
+            var restPort = ExecutionContext.Instance.ProjectConfig.RESTPort;
+            configJsonJson.host.rest.enableSsl = false;
+            configJsonJson.host.rest.address = "localhost";
+            configJsonJson.host.rest.port = restPort;
+            configJsonJson.host.isLoadBalancerEnabled = false;
+            configJsonJson.host.tenant.name = ExecutionContext.Instance.ProjectConfig.Tenant;
+            configJsonJson.general.defaultDomain = ExecutionContext.Instance.ProjectConfig.DefaultDomain;
+            configJsonJson.general.environmentName = ExecutionContext.Instance.ProjectConfig.EnvironmentName;
+            configJsonJson.version = $"{ExecutionContext.Instance.ProjectConfig.ProjectName} $(Build.BuildNumber) - {mesVersion}";
+            configJsonStr = JsonConvert.SerializeObject(configJsonJson, Formatting.Indented);
+            this.fileSystem.File.WriteAllText(configJsonPath, configJsonStr);
+            Log.Verbose("Updated config.json");
         }
     }
 }

tests/Fixtures/init/infrastructure.json

@@ -1,5 +1,5 @@
 {
     "ISOLocation": "\\\\share\\iso_location",
     "NPMRegistry": "http://npm_registry",
-    "NuGetRegistry": "htt://nuget_registry"
+    "NuGetRegistry": "http://nuget_registry"
 }

tests/Specs/New.cs

@@ -689,15 +689,39 @@ public void SecurityPortal()
             Assert.True(File.Exists($"{dir}/Cmf.Custom.SecurityPortal/config.json"), "Package config.json is missing");
         }
 
+        [Fact(Skip = "awaiting for NGXSchematics public release"), Trait("TestCategory", "LongRunning")]
+        public void UI_v10()
+        {
+            UI_internal_v10();
+        }
+
+        private void UI_internal_v10()
+        {
+            RunNew(new HTMLCommand(), "Cmf.Custom.HTML", mesVersion: "10.0.2", extraAsserts: args =>
+            {
+                var configJson = File.ReadAllText("Cmf.Custom.HTML/src/assets/config.json");
+                try
+                {
+                    JsonConvert.DeserializeObject(configJson);
+                }
+                catch (Exception e)
+                {
+                    Assert.Fail($"config.json is malformed: {e.Message}");
+                }
+            });
+        }
+
         private TestConsole RunNew<T>(T newCommand, string packageId, string scaffoldingDir = null,
             string[] extraArguments = null, bool defaultAsserts = true, Action<(string, string)> extraAsserts = null,
             string mesVersion = "8.2.0",
+            string ngxSchematicsVersion = "1.1.0",
             BaseLayer baseLayer = BaseLayer.MES,
             RepositoryType repositoryType = RepositoryType.Customization) where T : TemplateCommand
         {
             var dir = scaffoldingDir ?? TestUtilities.GetTmpDirectory();
 
-            var rnd = new Random();
+
+             var rnd = new Random();
             var pkgVersion = $"{rnd.Next(10)}.{rnd.Next(10)}.{rnd.Next(10)}";
 
             var cur = Directory.GetCurrentDirectory();
@@ -717,6 +741,8 @@ private TestConsole RunNew<T>(T newCommand, string packageId, string scaffolding
                             .Replace(@"""MESVersion"": ""8.2.0""", $@"""MESVersion"": ""{mesVersion}""")
                             .Replace(@"""BaseLayer"": ""MES""", $@"""BaseLayer"": ""{baseLayer}""")
                             .Replace(@"""RepositoryType"": ""Customization""", $@"""RepositoryType"": ""{repositoryType}""")
+                            .Replace(@"""NGXSchematicsVersion"": ""10.0.0""", $@"""NGXSchematicsVersion"": ""{ngxSchematicsVersion}""")
+                            .Replace(@"""NPMRegistry"": ""http://npm_registry/""", $@"""NPMRegistry"": ""http://cmf-nuget:4873/""")
                             .Replace("install_path", MockUnixSupport.Path(@"x:\install_path").Replace(@"\", @"\\"))
                             .Replace("backup_share", MockUnixSupport.Path(@"y:\backup_share").Replace(@"\", @"\\"))
                             .Replace("temp_folder", MockUnixSupport.Path(@"z:\temp_folder").Replace(@"\", @"\\"))
@@ -742,13 +768,15 @@ private TestConsole RunNew<T>(T newCommand, string packageId, string scaffolding
                 if (defaultAsserts)
                 {
                     string errors = console.Error.ToString().Trim();
-                    Assert.True(errors.Length == 0, $"Errors found in console: {errors}");
-                    Assert.True(Directory.Exists(packageId), "Package folder is missing");
-                    Assert.True(File.Exists($"{packageId}/cmfpackage.json"), "Package cmfpackage.json is missing");
-                    Assert.Equal(packageId, TestUtilities.GetPackageProperty("packageId", $"{packageId}/cmfpackage.json"), "Package Id does not match expected");
-                    Assert.Equal(pkgVersion, TestUtilities.GetPackageProperty("version", $"{packageId}/cmfpackage.json"), "Package version does not match expected");
+                    errors.Length.Should().Be(0, $"Errors found in console: {errors}");
+                    Directory.Exists(packageId).Should().BeTrue();
+                    File.Exists($"{packageId}/cmfpackage.json").Should().BeTrue();
+                    TestUtilities.GetPackageProperty("packageId", $"{packageId}/cmfpackage.json").Should().Be(packageId);
+                    TestUtilities.GetPackageProperty("version", $"{packageId}/cmfpackage.json").Should().Be(pkgVersion);
+
                     var pkg = TestUtilities.GetPackage("cmfpackage.json");
                     pkg.GetProperty("dependencies").EnumerateArray().ToArray().FirstOrDefault(d => d.GetProperty("id").GetString() == packageId).Should().NotBeNull("Package not found in root package dependencies");
+
                 }
 
                 if (extraAsserts != null)