@devops-flow/devops-flow-pipeline-detail 0.0.37

package/es/components/PipelineFlowEdit/FlowDocument/FlowSourceEntry.d.ts

@@ -0,0 +1,170 @@
+import { Pair } from 'yaml';
+import { EntryNodeItem } from './FlowNodeBase';
+import { DefService } from './DefService';
+import { JSONSchemaMap, JSONSchema } from './jsonSchema';
+export declare class FlowSourceEntry extends EntryNodeItem {
+    children: any[];
+    defService: DefService;
+    agentlessStepDefService?: DefService;
+    agentlessStepDef: any;
+    constructor(astNode: Pair, parent: any);
+    initChildren(): void;
+    getSchemaPropertyEntry(): Promise<JSONSchemaMap>;
+    getPackagesProperties(): Promise<{
+        version?: undefined;
+        artifact?: undefined;
+        repo?: undefined;
+        repoType: {
+            enum: string[];
+        };
+    } | {
+        version: {
+            oneOf?: undefined;
+        };
+        artifact?: undefined;
+        repo?: undefined;
+        repoType: {
+            enum: string[];
+        };
+    } | {
+        version: {
+            oneOf: JSONSchema[];
+        };
+        artifact?: undefined;
+        repo?: undefined;
+        repoType: {
+            enum: string[];
+        };
+    } | {
+        version?: undefined;
+        artifact: {
+            oneOf: JSONSchema[];
+        };
+        repo?: undefined;
+        repoType: {
+            enum: string[];
+        };
+    } | {
+        version: {
+            oneOf?: undefined;
+        };
+        artifact: {
+            oneOf: JSONSchema[];
+        };
+        repo?: undefined;
+        repoType: {
+            enum: string[];
+        };
+    } | {
+        version: {
+            oneOf: JSONSchema[];
+        };
+        artifact: {
+            oneOf: JSONSchema[];
+        };
+        repo?: undefined;
+        repoType: {
+            enum: string[];
+        };
+    } | {
+        version?: undefined;
+        artifact?: undefined;
+        repo: {
+            oneOf: any[];
+        };
+        repoType: {
+            enum: string[];
+        };
+    } | {
+        version: {
+            oneOf?: undefined;
+        };
+        artifact?: undefined;
+        repo: {
+            oneOf: any[];
+        };
+        repoType: {
+            enum: string[];
+        };
+    } | {
+        version: {
+            oneOf: JSONSchema[];
+        };
+        artifact?: undefined;
+        repo: {
+            oneOf: any[];
+        };
+        repoType: {
+            enum: string[];
+        };
+    } | {
+        version?: undefined;
+        artifact: {
+            oneOf: JSONSchema[];
+        };
+        repo: {
+            oneOf: any[];
+        };
+        repoType: {
+            enum: string[];
+        };
+    } | {
+        version: {
+            oneOf?: undefined;
+        };
+        artifact: {
+            oneOf: JSONSchema[];
+        };
+        repo: {
+            oneOf: any[];
+        };
+        repoType: {
+            enum: string[];
+        };
+    } | {
+        version: {
+            oneOf: JSONSchema[];
+        };
+        artifact: {
+            oneOf: JSONSchema[];
+        };
+        repo: {
+            oneOf: any[];
+        };
+        repoType: {
+            enum: string[];
+        };
+    }>;
+    getPackagesRepos(): Promise<{
+        repo?: undefined;
+    } | {
+        repo: {
+            oneOf: any[];
+        };
+    }>;
+    getPackagesArtifacts(): Promise<{
+        artifact?: undefined;
+    } | {
+        artifact: {
+            oneOf: JSONSchema[];
+        };
+    }>;
+    getPackagesVersions(): Promise<{
+        version?: undefined;
+    } | {
+        version: {
+            oneOf?: undefined;
+        };
+    } | {
+        version: {
+            oneOf: JSONSchema[];
+        };
+    }>;
+    getFlowPipelineRules(): Promise<{
+        flowPipeline: {
+            title: any;
+            oneOf: any[];
+        };
+    }>;
+    getPipelineIds(): Promise<any[]>;
+}

package/es/components/PipelineFlowEdit/FlowDocument/FlowSourceEntry.js

@@ -0,0 +1,492 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { EntryNodeItem } from "./FlowNodeBase";
+import { exceedFetchWithCache5min } from "./cache";
+import { monacoYamlCompletionItemDescMark } from "../utils";
+import { insertIf } from "../../../utils";
+import { uniqBy } from 'lodash-es';
+import intl from "../../../locale";
+import exceed from "../../../utils/apimap";
+export var FlowSourceEntry = /*#__PURE__*/function (_EntryNodeItem) {
+  function FlowSourceEntry(astNode, parent) {
+    var _this;
+    _this = _EntryNodeItem.call(this, astNode, parent) || this;
+    _this.children = [];
+    _this.defService = null;
+    _this.agentlessStepDefService = null;
+    _this.agentlessStepDef = void 0;
+    _this.initChildren();
+    return _this;
+  }
+  _inheritsLoose(FlowSourceEntry, _EntryNodeItem);
+  var _proto = FlowSourceEntry.prototype;
+  _proto.initChildren = function initChildren() {};
+  _proto.getSchemaPropertyEntry = /*#__PURE__*/function () {
+    var _getSchemaPropertyEntry = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+      var _ref;
+      var type, codeTypes, allType, conns, hasSshKey, getConnections, _getConnections;
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            _getConnections = function _getConnections3() {
+              _getConnections = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(scType) {
+                var map, resp;
+                return _regeneratorRuntime.wrap(function _callee$(_context) {
+                  while (1) switch (_context.prev = _context.next) {
+                    case 0:
+                      map = {
+                        acr: 'docker_register_aliyun'
+                      };
+                      _context.next = 3;
+                      return exceedFetchWithCache5min({
+                        api: 'service-connection.list',
+                        data: {
+                          pageOrder: 'DESC',
+                          scType: map[scType] || scType,
+                          userId: window.AK_GLOBAL.currentUser.workid || '',
+                          // id: props.value || (connection && connection.id) || '',
+                          version: 'v2'
+                        }
+                      });
+                    case 3:
+                      resp = _context.sent;
+                      return _context.abrupt("return", resp.object);
+                    case 5:
+                    case "end":
+                      return _context.stop();
+                  }
+                }, _callee);
+              }));
+              return _getConnections.apply(this, arguments);
+            };
+            getConnections = function _getConnections2(_x) {
+              return _getConnections.apply(this, arguments);
+            };
+            type = this.getValueFromAstNode(['type']);
+            /** 代码库有 sshkey */
+            codeTypes = ['codeup', 'aliyunCode', 'customGitlab', 'gitee', 'git', 'github', 'gitlab', 'bitbucket', 'svn'];
+            allType = ['acr', 'jenkins', 'packages', 'flowPipeline'].concat(codeTypes);
+            if (allType.includes(type)) {
+              _context2.next = 7;
+              break;
+            }
+            return _context2.abrupt("return", {});
+          case 7:
+            _context2.next = 9;
+            return getConnections(type);
+          case 9:
+            conns = _context2.sent;
+            hasSshKey = codeTypes.includes(type); // const flowPipelineRules = await this.getFlowPipelineRules();
+            _ref = {};
+            _context2.t0 = _extends;
+            _context2.t1 = {
+              certificate: {
+                type: 'object',
+                title: intl.get({
+                  id: 'rdc-tb-cd-assets.PipelineFlowEdit.FlowDocument.FlowSourceEntry.SetTheAuthorizationInformationFor',
+                  defaultMessage: '设置克隆代码源，或调用外部 Jenkins 服务的授权信息'
+                }),
+                markdownDescription: intl.get({
+                  id: 'rdc-tb-cd-assets.PipelineFlowEdit.FlowDocument.FlowSourceEntry.RequiredIfYouUseA',
+                  defaultMessage: '必填。使用服务连接，则 type 为 serviceConnection，并填写 **服务连接 ID** 信息（服务连接ID请前往 **全局设置-服务连接管理** 获取），如：\n```yaml\nsources:\n  my_repo:\n    type: codeup\n    endpoint: https://codeup.aliyun.com/abc/Codeup-Demo.git\n    branch: master\n    certificate:\n      type: serviceConnection\n      serviceConnection: <your-service-connection-id>\n```\n部分代码源（如通用 Git、自建 Gitlab等）支持通过企业公钥克隆代码，则可设置使用企业公钥，type 为 sshKey，如：\n```yaml\nsources:\n  my_repo:\n    type: customGit\n    endpoint: https://codeup.aliyun.com/abc/Codeup-Demo.git\n    branch: master\n    certificate:\n      type: sshKey\n```'
+                }),
+                properties: {
+                  type: {
+                    type: 'string',
+                    title: intl.get({
+                      id: 'rdc-tb-cd-assets.PipelineFlowEdit.FlowDocument.FlowSourceEntry.CredentialType',
+                      defaultMessage: '凭证类型'
+                    }),
+                    description: intl.get({
+                      id: 'rdc-tb-cd-assets.PipelineFlowEdit.FlowDocument.FlowSourceEntry.IfYouUseAService',
+                      defaultMessage: '使用服务连接，则 type 为 serviceConnection，并填写 服务连接 ID 信息（服务连接ID请前往 企业设置-服务连接管理 获取）；部分代码源（如通用 Git、自建 Gitlab等）支持通过企业公钥克隆代码，则可设置使用企业公钥，type 为 sshKey'
+                    }),
+                    "enum": ['serviceConnection'].concat(insertIf(hasSshKey, 'sshKey'))
+                  },
+                  serviceConnection: {
+                    type: 'string',
+                    title: intl.get({
+                      id: 'rdc-tb-cd-assets.PipelineFlowEdit.FlowDocument.FlowSourceEntry.ServiceConnectionId',
+                      defaultMessage: '服务连接ID'
+                    }),
+                    description: intl.get({
+                      id: 'rdc-tb-cd-assets.PipelineFlowEdit.FlowDocument.FlowSourceEntry.RequiredWhenUsingServiceConnection',
+                      defaultMessage: '使用服务连接时必填，服务连接ID请前往 全局设置-服务连接管理 获取'
+                    }),
+                    oneOf: conns.map(function (conn) {
+                      var schm = {
+                        "const": conn.uuid,
+                        description: monacoYamlCompletionItemDescMark(conn.connectionName)
+                      };
+                      return schm;
+                    })
+                  }
+                },
+                required: ['type'],
+                "if": {
+                  properties: {
+                    type: {
+                      "const": 'serviceConnection'
+                    }
+                  }
+                },
+                then: {
+                  required: ['serviceConnection']
+                }
+              }
+            };
+            if (!(type === 'packages')) {
+              _context2.next = 23;
+              break;
+            }
+            _context2.t3 = _extends;
+            _context2.t4 = {};
+            _context2.next = 19;
+            return this.getPackagesProperties();
+          case 19:
+            _context2.t5 = _context2.sent;
+            _context2.t2 = (0, _context2.t3)(_context2.t4, _context2.t5);
+            _context2.next = 24;
+            break;
+          case 23:
+            _context2.t2 = {};
+          case 24:
+            _context2.t6 = _context2.t2;
+            _context2.t7 = (0, _context2.t0)(_context2.t1, _context2.t6);
+            _ref[this.astNode.key.value] = {
+              type: 'object',
+              properties: _context2.t7
+            };
+            return _context2.abrupt("return", _ref);
+          case 28:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, this);
+    }));
+    function getSchemaPropertyEntry() {
+      return _getSchemaPropertyEntry.apply(this, arguments);
+    }
+    return getSchemaPropertyEntry;
+  }();
+  _proto.getPackagesProperties = /*#__PURE__*/function () {
+    var _getPackagesProperties = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+      var supportedRepoTypes, repoType, reposP, artifactsP, versionsP;
+      return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            supportedRepoTypes = ['generic'];
+            repoType = {
+              repoType: {
+                "enum": supportedRepoTypes
+              }
+            };
+            reposP = this.getPackagesRepos();
+            artifactsP = this.getPackagesArtifacts();
+            versionsP = this.getPackagesVersions();
+            _context3.t0 = _extends;
+            _context3.t1 = {};
+            _context3.t2 = repoType;
+            _context3.next = 10;
+            return reposP;
+          case 10:
+            _context3.t3 = _context3.sent;
+            _context3.next = 13;
+            return artifactsP;
+          case 13:
+            _context3.t4 = _context3.sent;
+            _context3.next = 16;
+            return versionsP;
+          case 16:
+            _context3.t5 = _context3.sent;
+            return _context3.abrupt("return", (0, _context3.t0)(_context3.t1, _context3.t2, _context3.t3, _context3.t4, _context3.t5));
+          case 18:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3, this);
+    }));
+    function getPackagesProperties() {
+      return _getPackagesProperties.apply(this, arguments);
+    }
+    return getPackagesProperties;
+  }();
+  _proto.getPackagesRepos = /*#__PURE__*/function () {
+    var _getPackagesRepos = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+      var _this$getValueFromAst;
+      var serviceConnection, repoType, reposResp, repos;
+      return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            /*
+             * repo 列表
+             */
+            serviceConnection = (_this$getValueFromAst = this.getValueFromAstNode(['certificate'])) === null || _this$getValueFromAst === void 0 ? void 0 : _this$getValueFromAst.serviceConnection;
+            repoType = this.getValueFromAstNode(['repoType']);
+            if (!(!serviceConnection || !repoType)) {
+              _context4.next = 4;
+              break;
+            }
+            return _context4.abrupt("return", {});
+          case 4:
+            _context4.next = 6;
+            return exceedFetchWithCache5min({
+              api: 'Packages.userRepos',
+              data: {
+                connectionUUID: serviceConnection,
+                repoType: repoType,
+                showProxy: true
+              }
+            });
+          case 6:
+            reposResp = _context4.sent;
+            repos = (reposResp.object || []).map(function (v) {
+              var oneOfItem = {
+                title: v.repoName,
+                "const": v.repoId,
+                description: monacoYamlCompletionItemDescMark(v.repoName)
+              };
+              return oneOfItem;
+            });
+            return _context4.abrupt("return", {
+              repo: {
+                oneOf: [].concat(repos)
+              }
+            });
+          case 9:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4, this);
+    }));
+    function getPackagesRepos() {
+      return _getPackagesRepos.apply(this, arguments);
+    }
+    return getPackagesRepos;
+  }();
+  _proto.getPackagesArtifacts = /*#__PURE__*/function () {
+    var _getPackagesArtifacts = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+      var _this$getValueFromAst2;
+      var serviceConnection, repoType, repo, artifact, artifactsRespP, artifactsSearchRespP, artifactsData, artifacts;
+      return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            /*
+             * artifact 列表
+             */
+            serviceConnection = (_this$getValueFromAst2 = this.getValueFromAstNode(['certificate'])) === null || _this$getValueFromAst2 === void 0 ? void 0 : _this$getValueFromAst2.serviceConnection;
+            repoType = this.getValueFromAstNode(['repoType']);
+            repo = this.getValueFromAstNode(['repo']);
+            artifact = this.getValueFromAstNode(['artifact']);
+            if (!(!serviceConnection || !repoType || !repo)) {
+              _context5.next = 6;
+              break;
+            }
+            return _context5.abrupt("return", {});
+          case 6:
+            artifactsRespP = exceedFetchWithCache5min({
+              api: 'Packages.REPO.artifacts',
+              data: {
+                repoType: repoType,
+                repoId: repo,
+                connectionUUID: serviceConnection
+              }
+            });
+            artifactsSearchRespP = artifact ? exceedFetchWithCache5min({
+              api: 'Packages.REPO.artifacts',
+              data: {
+                repoType: repoType,
+                repoId: repo,
+                connectionUUID: serviceConnection,
+                search: artifact
+              }
+            }) : {
+              object: []
+            };
+            _context5.next = 10;
+            return Promise.all([artifactsRespP, artifactsSearchRespP]).then(function (_ref2) {
+              var a = _ref2[0],
+                b = _ref2[1];
+              return uniqBy([].concat(a.object || [], b.object || []), 'module');
+            });
+          case 10:
+            artifactsData = _context5.sent;
+            artifacts = artifactsData.map(function (v) {
+              var oneOfItem = {
+                "const": v.module
+              };
+              return oneOfItem;
+            });
+            return _context5.abrupt("return", {
+              artifact: {
+                oneOf: artifacts
+              }
+            });
+          case 13:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5, this);
+    }));
+    function getPackagesArtifacts() {
+      return _getPackagesArtifacts.apply(this, arguments);
+    }
+    return getPackagesArtifacts;
+  }();
+  _proto.getPackagesVersions = /*#__PURE__*/function () {
+    var _getPackagesVersions = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
+      var _this$getValueFromAst3;
+      var serviceConnection, repoType, repo, artifact, versionsRespP, versionsSearchRespP, versionsData, versions;
+      return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            /*
+             * version 列表
+             */
+            serviceConnection = (_this$getValueFromAst3 = this.getValueFromAstNode(['certificate'])) === null || _this$getValueFromAst3 === void 0 ? void 0 : _this$getValueFromAst3.serviceConnection;
+            repoType = this.getValueFromAstNode(['repoType']);
+            repo = this.getValueFromAstNode(['repo']);
+            artifact = this.getValueFromAstNode(['artifact']);
+            if (!(!serviceConnection || !repoType || !repo || !artifact)) {
+              _context6.next = 6;
+              break;
+            }
+            return _context6.abrupt("return", {});
+          case 6:
+            versionsRespP = exceedFetchWithCache5min({
+              api: 'Packages.REPO.artifacts.versions',
+              data: {
+                repoType: repoType,
+                repoId: repo,
+                module: artifact,
+                connectionUUID: serviceConnection,
+                search: ''
+              }
+            });
+            versionsSearchRespP = exceedFetchWithCache5min({
+              api: 'Packages.REPO.artifacts.versions',
+              data: {
+                repoType: repoType,
+                repoId: repo,
+                module: artifact,
+                connectionUUID: serviceConnection,
+                search: this.getValueFromAstNode(['version'])
+              }
+            });
+            _context6.next = 10;
+            return Promise.all([versionsRespP, versionsSearchRespP]).then(function (_ref3) {
+              var a = _ref3[0],
+                b = _ref3[1];
+              return uniqBy([].concat(a.object || [], b.object || []), 'version');
+            });
+          case 10:
+            versionsData = _context6.sent;
+            versions = versionsData.map(function (v) {
+              var oneOfItem = {
+                "const": v.version
+              };
+              return oneOfItem;
+            });
+            if (versions !== null && versions !== void 0 && versions.length) {
+              _context6.next = 14;
+              break;
+            }
+            return _context6.abrupt("return", {
+              version: {}
+            });
+          case 14:
+            return _context6.abrupt("return", {
+              version: {
+                oneOf: [{
+                  "const": 'latest'
+                }].concat(versions)
+              }
+            });
+          case 15:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6, this);
+    }));
+    function getPackagesVersions() {
+      return _getPackagesVersions.apply(this, arguments);
+    }
+    return getPackagesVersions;
+  }();
+  _proto.getFlowPipelineRules = /*#__PURE__*/function () {
+    var _getFlowPipelineRules = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
+      var oneOf;
+      return _regeneratorRuntime.wrap(function _callee7$(_context7) {
+        while (1) switch (_context7.prev = _context7.next) {
+          case 0:
+            _context7.next = 2;
+            return this.getPipelineIds();
+          case 2:
+            oneOf = _context7.sent;
+            return _context7.abrupt("return", {
+              flowPipeline: {
+                title: intl.get({
+                  id: 'rdc-tb-cd-assets.PipelineFlowEdit.FlowDocument.FlowSourceEntry.PipelineId',
+                  defaultMessage: '流水线ID'
+                }),
+                oneOf: oneOf
+              }
+            });
+          case 4:
+          case "end":
+            return _context7.stop();
+        }
+      }, _callee7, this);
+    }));
+    function getFlowPipelineRules() {
+      return _getFlowPipelineRules.apply(this, arguments);
+    }
+    return getFlowPipelineRules;
+  }();
+  _proto.getPipelineIds = /*#__PURE__*/function () {
+    var _getPipelineIds = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
+      var res, oneOf, _res$object$dataList, dataList;
+      return _regeneratorRuntime.wrap(function _callee8$(_context8) {
+        while (1) switch (_context8.prev = _context8.next) {
+          case 0:
+            _context8.next = 2;
+            return exceed.fetch({
+              api: 'Pipeline.query.by.region',
+              data: {
+                refObjectType: 'PERSON',
+                refObjectId: window.AK_GLOBAL.currentUser.workid,
+                type: 'all',
+                pageSize: 99,
+                pageStart: 0,
+                pipelineName: this.getValueFromAstNode(['flowPipeline']),
+                pageOrder: 'DESC'
+              }
+            });
+          case 2:
+            res = _context8.sent;
+            oneOf = [];
+            if (res.successful && res.object) {
+              _res$object$dataList = res.object.dataList, dataList = _res$object$dataList === void 0 ? [] : _res$object$dataList;
+              oneOf = dataList.map(function (item) {
+                return {
+                  "const": item.uuid,
+                  description: monacoYamlCompletionItemDescMark(item.pipelineName)
+                };
+              });
+            }
+            return _context8.abrupt("return", oneOf);
+          case 6:
+          case "end":
+            return _context8.stop();
+        }
+      }, _callee8, this);
+    }));
+    function getPipelineIds() {
+      return _getPipelineIds.apply(this, arguments);
+    }
+    return getPipelineIds;
+  }();
+  return FlowSourceEntry;
+}(EntryNodeItem);

package/es/components/PipelineFlowEdit/FlowDocument/FlowSources.d.ts

@@ -0,0 +1,12 @@
+import { YAMLMap } from 'yaml';
+import { FlowNode } from './FlowNodeBase';
+export declare class FlowSources extends FlowNode {
+    constructor(astNode: YAMLMap, parent: any);
+    initChildren(): void;
+    getSchema(): Promise<{
+        sources: {
+            type: string;
+            properties: {};
+        };
+    }>;
+}