t-comm/lib/tgit/branch-protected-script.js

专业、稳定、纯粹的工具库

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var _regeneratorRuntime = require('@babel/runtime/regenerator');
var tslib_es6 = require('../tslib.es6-0d92ef81.js');
var tgit_branchProtected = require('./branch-protected.js');
require('./helper.js');
require('axios');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

var _regeneratorRuntime__default = /*#__PURE__*/_interopDefaultLegacy(_regeneratorRuntime);

function genProjectRuleForm(ruleName) {
  return {
    name: ruleName
  };
}
function checkShouldCreateAutoProjectRule(rules) {
  var keyWord = 'REGEXP "feature/story-.*"';
  return !rules.includes(keyWord);
}
function getAutoProjectedRuleStr(ruleName) {
  return "`".concat(ruleName, "` REGEXP \"feature/story-.*\"");
}
function getTargetRule(rules) {
  if (!rules.length) return null;
  return rules.find(function (item) {
    return item.name.includes('develop');
  }) || rules[0];
}
function createAutoProtectedRuleForStoryBranch(_ref) {
  var projectName = _ref.projectName,
    baseUrl = _ref.baseUrl,
    privateToken = _ref.privateToken,
    _ref$defaultRuleName = _ref.defaultRuleName,
    defaultRuleName = _ref$defaultRuleName === void 0 ? 'rule_created_by_novlan1' : _ref$defaultRuleName,
    shouldUpdateExistingBranches = _ref.shouldUpdateExistingBranches;
  var _a;
  return tslib_es6.__awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee() {
    var rule, shouldCreateAutoProjectRules, rulesList, ruleName, ruleStr;
    return _regeneratorRuntime__default["default"].wrap(function (_context) {
      while (1) switch (_context.prev = _context.next) {
        case 0:
          _context.next = 1;
          return tgit_branchProtected.getAutoProtectedBranchRules({
            projectName: projectName,
            privateToken: privateToken,
            baseUrl: baseUrl
          });
        case 1:
          rule = _context.sent;
          console.log('[getProtectedBranchRules] res: ', rule);
          shouldCreateAutoProjectRules = checkShouldCreateAutoProjectRule(rule);
          if (shouldCreateAutoProjectRules) {
            _context.next = 2;
            break;
          }
          return _context.abrupt("return");
        case 2:
          _context.next = 3;
          return tgit_branchProtected.getProtectedBranchRules({
            projectName: projectName,
            privateToken: privateToken,
            baseUrl: baseUrl
          });
        case 3:
          rulesList = _context.sent;
          console.log('[getProtectedBranchRules] rulesList: ', rulesList);
          ruleName = defaultRuleName;
          if (rulesList.length) {
            _context.next = 5;
            break;
          }
          _context.next = 4;
          return tgit_branchProtected.createProtectedBranchRule({
            projectName: projectName,
            privateToken: privateToken,
            baseUrl: baseUrl,
            form: genProjectRuleForm(ruleName)
          });
        case 4:
          _context.next = 6;
          break;
        case 5:
          ruleName = ((_a = getTargetRule(rulesList)) === null || _a === void 0 ? void 0 : _a.name) || '';
        case 6:
          if (ruleName) {
            _context.next = 7;
            break;
          }
          throw new Error('No ruleName');
        case 7:
          ruleStr = getAutoProjectedRuleStr(ruleName);
          console.log('[ruleStr]', ruleStr);
          _context.next = 8;
          return tgit_branchProtected.modifyAutoProtectedBranchRules({
            projectName: projectName,
            privateToken: privateToken,
            baseUrl: baseUrl,
            rules: ruleStr,
            shouldUpdateExistingBranches: shouldUpdateExistingBranches
          });
        case 8:
        case "end":
          return _context.stop();
      }
    }, _callee);
  }));
}

exports.createAutoProtectedRuleForStoryBranch = createAutoProtectedRuleForStoryBranch;