ics-builder 4.1.87 → 4.1.91

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ics-builder",
-	"version": "4.1.87",
+	"version": "4.1.91",
 	"description": "",
 	"main": "./src/app.js",
 	"preferGlobal": true,

package/src/builder/api/csprojFile.js

@@ -0,0 +1,50 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CsprojFile = void 0;
+var xmlFile_1 = require("./xmlFile");
+var CsprojFile = /** @class */ (function (_super) {
+    __extends(CsprojFile, _super);
+    function CsprojFile() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CsprojFile.prototype.addPostBuildCopy = function (copyToPath) {
+        if (!this._xmlObj)
+            this._readFile();
+        if (!this._xmlObj.Project)
+            this._xmlObj.Project = {};
+        this._xmlObj.Project.Target = {
+            $: {
+                Name: "CopyTarget",
+                AfterTargets: "PostBuildEvent"
+            },
+            ItemGroup: {
+                OutputFiles: {
+                    $: {
+                        Include: "$(TargetDir)\\*.*"
+                    }
+                }
+            },
+            Copy: {
+                $: {
+                    SourceFiles: "@(OutputFiles)",
+                    DestinationFolder: copyToPath,
+                }
+            }
+        };
+    };
+    return CsprojFile;
+}(xmlFile_1.XmlFile));
+exports.CsprojFile = CsprojFile;

package/src/builder/api/net5Builder.js

@@ -20,6 +20,8 @@ var baseBuilder_1 = require("../baseBuilder");
 var utils_1 = require("../../utils");
 var dotnetUtils_1 = require("../../dotnetUtils");
 var packageStructureManager_1 = require("../../services/packageStructure/packageStructureManager");
+var csprojFile_1 = require("./csprojFile");
+var webConfigFile_1 = require("./webConfigFile");
 var Net5ApiBuilder = /** @class */ (function (_super) {
     __extends(Net5ApiBuilder, _super);
     function Net5ApiBuilder(config) {
@@ -33,7 +35,6 @@ var Net5ApiBuilder = /** @class */ (function (_super) {
     }
     Net5ApiBuilder.prototype.run = function () {
         var _this = this;
-        var _a;
         this.config.packages.forEach(function (pkg) {
             _this.collectModuleInfo(pkg);
         });
@@ -41,20 +42,44 @@ var Net5ApiBuilder = /** @class */ (function (_super) {
         this.allProjects.forEach(function (p) {
             _this.clearCache(path.dirname(p));
         });
+        this._build();
+    };
+    Net5ApiBuilder.prototype._build = function () {
+        var _this = this;
+        var _a;
+        var coreModule = this.modules.find(function (m) { return m.IsCoreModule; });
+        var slnName = "Mdt";
+        var slnDir = path.dirname(coreModule.Project);
         var configuration = ((_a = this.config.api) === null || _a === void 0 ? void 0 : _a.configuration) || "Debug";
-        this.modules.forEach(function (m) {
-            dotnetUtils_1.DotnetUtils.restoreNugetPackages(m.Project);
-            var isCoreModule = m.Module.name == "_core" && m.Package == "mdt";
-            var outputPath = isCoreModule ? _this.buildApiFolder : path.join(_this.buildApiFolder, "modules", utils_1.Utils.getFileName(m.Project));
-            utils_1.Utils.exec("dotnet publish " + m.Project + " --no-restore -c " + configuration + " -o " + outputPath + " -nologo -v q", {
-                silent: false,
-                skipLog: true
-            });
-            if (!isCoreModule) {
-                var projectDir = path.dirname(m.Project);
-                _this.copyModuleConfig(projectDir, outputPath, _this.configFile);
+        var tempSlnPath = path.join(slnDir, slnName + ".sln");
+        try {
+            dotnetUtils_1.DotnetUtils.createTempSln(slnDir, slnName);
+            for (var _i = 0, _b = this.modules; _i < _b.length; _i++) {
+                var m = _b[_i];
+                utils_1.Utils.copyFile(m.Project, m.TempProject);
+                var csproj = new csprojFile_1.CsprojFile(m.Project);
+                csproj.addPostBuildCopy(m.OutputPath);
+                csproj.save(m.Project);
             }
-        });
+            dotnetUtils_1.DotnetUtils.addProjectsToSln(tempSlnPath, this.modules.map(function (m) { return m.Project; }));
+            dotnetUtils_1.DotnetUtils.restoreNugetPackages(tempSlnPath);
+            dotnetUtils_1.DotnetUtils.publish(tempSlnPath, configuration);
+            var webConfigFilePath = path.join(coreModule.OutputPath, "web.config");
+            var webConfigFile = new webConfigFile_1.WebConfigFile(webConfigFilePath);
+            webConfigFile.addDotnetProcessPath();
+            webConfigFile.save();
+            this.modules.filter(function (m) { return !m.IsCoreModule; }).forEach(function (m) {
+                var projectDir = path.dirname(m.Project);
+                _this.copyModuleConfig(projectDir, m.OutputPath, _this.configFile);
+            });
+        }
+        finally {
+            utils_1.Utils.deleteFile(tempSlnPath);
+            this.modules.forEach(function (m) {
+                utils_1.Utils.copyFile(m.TempProject, m.Project);
+                utils_1.Utils.deleteFile(m.TempProject);
+            });
+        }
     };
     Net5ApiBuilder.prototype.collectModuleInfo = function (pkg) {
         var _this = this;
@@ -74,18 +99,18 @@ var Net5ApiBuilder = /** @class */ (function (_super) {
                 utils_1.Logger.error(csprojPath + " does not exist");
                 return;
             }
-            this.modules.push({ Module: md, Package: pkg, Project: csprojPath });
+            this.modules.push(new ApiModuleInfo(pkg, md, csprojPath, this.buildApiFolder));
             projectFile.push(csprojPath);
         }
         else {
             var files_1 = shell.ls(path.join(modulePath, "*.sln"));
             if (files_1.length) {
-                this.modules.push({ Module: md, Package: pkg, Project: files_1[0] });
+                this.modules.push(new ApiModuleInfo(pkg, md, files_1[0], this.buildApiFolder));
                 return;
             }
             files_1 = shell.ls(path.join(modulePath, "*.csproj"));
             if (files_1.length) {
-                this.modules.push({ Module: md, Package: pkg, Project: files_1[0] });
+                this.modules.push(new ApiModuleInfo(pkg, md, files_1[0], this.buildApiFolder));
             }
             else {
                 utils_1.Logger.warn("Module " + md.name + " does not have .csproj file and will be skipped");
@@ -104,3 +129,17 @@ var Net5ApiBuilder = /** @class */ (function (_super) {
     return Net5ApiBuilder;
 }(baseBuilder_1.BaseBuilder));
 exports.Net5ApiBuilder = Net5ApiBuilder;
+var ApiModuleInfo = /** @class */ (function () {
+    function ApiModuleInfo(pkg, module, project, buildApiFolder) {
+        this.Package = pkg;
+        this.Module = module;
+        this.Project = project;
+        var dir = path.dirname(project);
+        this.TempProject = path.join(dir, utils_1.Utils.getFileName(project) + "_temp.csproj");
+        this.IsCoreModule = module.name == "_core" && pkg == "mdt";
+        this.OutputPath = this.IsCoreModule
+            ? buildApiFolder
+            : path.join(buildApiFolder, "modules", utils_1.Utils.getFileName(project));
+    }
+    return ApiModuleInfo;
+}());

package/src/builder/api/webConfigFile.js

@@ -0,0 +1,33 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebConfigFile = void 0;
+var xmlFile_1 = require("./xmlFile");
+var WebConfigFile = /** @class */ (function (_super) {
+    __extends(WebConfigFile, _super);
+    function WebConfigFile() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    WebConfigFile.prototype.addDotnetProcessPath = function () {
+        if (!this._xmlObj)
+            this._readFile();
+        var aspNetCoreSectionOptions = this._xmlObj.configuration.location[0]["system.webServer"][0].aspNetCore[0].$;
+        aspNetCoreSectionOptions.processPath = "dotnet";
+        aspNetCoreSectionOptions.arguments = ".\\Mdt.WebApi.dll";
+        aspNetCoreSectionOptions.stdoutLogEnabled = "false";
+    };
+    return WebConfigFile;
+}(xmlFile_1.XmlFile));
+exports.WebConfigFile = WebConfigFile;

package/src/builder/api/xmlFile.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XmlFile = void 0;
+var xml2js = require("xml2js");
+var fs = require("fs");
+var XmlFile = /** @class */ (function () {
+    function XmlFile(_path) {
+        this._path = _path;
+    }
+    XmlFile.prototype._readFile = function () {
+        var _this = this;
+        var file = fs.readFileSync(this._path);
+        xml2js.parseString(file, function (err, result) { return _this._xmlObj = result; });
+    };
+    XmlFile.prototype.save = function (path) {
+        if (path === void 0) { path = null; }
+        var builder = new xml2js.Builder();
+        var xml = builder.buildObject(this._xmlObj);
+        fs.writeFileSync(path !== null && path !== void 0 ? path : this._path, xml);
+    };
+    return XmlFile;
+}());
+exports.XmlFile = XmlFile;

package/src/dotnetUtils.js

@@ -10,10 +10,18 @@ var DotnetUtils = /** @class */ (function () {
         utils_1.Utils.deleteFiles(slnFilePath, [slnFileName + ".sln"]);
         utils_1.Utils.exec("dotnet new sln -n " + slnFileName + " -o " + slnFilePath);
     };
-    DotnetUtils.restoreNugetPackages = function (projectPath, dropSlnOnFail) {
-        utils_1.Utils.exec(
-        //			`dotnet restore ${projectPath} -s "https://stage.ics-it.ru/nuget/nuget/" -s "https://api.nuget.org/v3/index.json" -nologo -v q`);
-        "dotnet restore " + projectPath + " -nologo -v q");
+    DotnetUtils.restoreNugetPackages = function (projectPath) {
+        utils_1.Utils.exec("dotnet restore " + projectPath + " -nologo -v q");
+    };
+    DotnetUtils.publish = function (projectPath, configuration, outputPath) {
+        if (outputPath === void 0) { outputPath = null; }
+        var command = "dotnet publish " + projectPath + " --no-restore -c " + configuration + " -nologo -v q";
+        if (outputPath)
+            command += " -o " + outputPath;
+        utils_1.Utils.exec(command, {
+            silent: false,
+            skipLog: true
+        });
     };
     DotnetUtils.addProjectsToSln = function (slnFilePath, projects, dropSlnOnFail) {
         var _this = this;

package/src/exceptions/BuilderException.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var BuilderException = /** @class */ (function () {
+    function BuilderException(message) {
+        this.message = message;
+    }
+    return BuilderException;
+}());
+exports.default = BuilderException;

package/src/services/packageStructure/structureUtils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.structureUtils = void 0;
+var BuilderException_1 = require("../../exceptions/BuilderException");
 exports.structureUtils = {
     getModules: function (pkg, pkgDependencies, config, getAllPackageModuleNames, getModuleDeps) {
         if (getModuleDeps === void 0) { getModuleDeps = null; }
@@ -11,16 +12,19 @@ exports.structureUtils = {
             });
         var modules;
         var core = "_core";
+        var allModuleNames = getAllPackageModuleNames(pkg, isIgnoredDirectory, config);
         if (config.modules && config.modules.length > 0)
             modules = config.modules
                 .filter(function (m) { return pkg.name == m.split(".")[0]; })
                 .map(function (val) {
                 var split = val.split(".");
                 var moduleName = split.length == 1 ? core : split.slice(1).join(".");
+                if (!isIgnoredModule(pkg.name, moduleName) && !allModuleNames.includes(moduleName))
+                    throw new BuilderException_1.default("Module " + val + " not found!");
                 return createModule(mappedPkgDependencies, moduleName, pkg, getModuleDeps, config);
             });
         else {
-            modules = getAllPackageModuleNames(pkg, isIgnoredDirectory, config).map(function (moduleName) {
+            modules = allModuleNames.map(function (moduleName) {
                 return createModule(mappedPkgDependencies, moduleName, pkg, getModuleDeps, config);
             });
         }
@@ -29,6 +33,15 @@ exports.structureUtils = {
         return modules;
     }
 };
+function isIgnoredModule(packageName, moduleName) {
+    if (moduleName === "_core")
+        return true;
+    if (packageName === "mdt") {
+        if (moduleName === "storage" || moduleName === "template")
+            return true;
+    }
+    return false;
+}
 function isIgnoredDirectory(name) {
     return name == "node_modules" || name == "_core" || name.startsWith(".");
 }

package/src/utils.js

@@ -136,10 +136,13 @@ var Utils = /** @class */ (function () {
     Utils.deleteFiles = function (dir, files) {
         for (var i = 0; i < files.length; i++) {
             var file = path.join(dir, files[i]);
-            if (fs.existsSync(file))
-                fs.unlinkSync(file);
+            this.deleteFile(file);
         }
     };
+    Utils.deleteFile = function (path) {
+        if (fs.existsSync(path))
+            fs.unlinkSync(path);
+    };
     Utils.prepareDir = function (dir) {
         Utils.clearFolder(dir);
         Utils.ensureFolder(dir);