@digital-ai/plugin-dai-release-backend/dist/api/ReleaseOverviewApi.cjs.js

Backend functionalities for the dai-release backstage plugin

'use strict';

var apiConfig = require('./apiConfig.cjs.js');
var dateService = require('./date-service.cjs.js');
var FoldersApi = require('./FoldersApi.cjs.js');
var responseUtil = require('./responseUtil.cjs.js');

class ReleaseOverviewApi {
  logger;
  config;
  foldersApi;
  constructor(logger, config) {
    this.logger = logger;
    this.config = config;
    this.foldersApi = FoldersApi.FoldersApi.fromConfig(config, logger);
  }
  static fromConfig(config, logger) {
    return new ReleaseOverviewApi(logger, config);
  }
  async getReleases(failing, planned, completed, paused, aborted, inProgress, failed, title, fromDate, toDate, orderBy, pageNumber, resultsPerPage, instanceName) {
    this.logger?.debug(
      `Calling Release Overview api, start from: ${fromDate} to: ${toDate}, in order of ${orderBy}`
    );
    const instanceConfig = this.config.getInstanceConfig(instanceName);
    const accessToken = apiConfig.getCredentials(instanceConfig);
    const apiUrl = apiConfig.getReleaseApiHost(instanceConfig);
    const requestBody = {
      failing,
      planned,
      completed,
      paused,
      aborted,
      inProgress,
      failed,
      title,
      tags: [],
      from: fromDate,
      to: toDate,
      orderBy,
      onlyFlagged: false,
      onlyArchived: false,
      onlyMine: false
    };
    const data = await this.getReleasesList(
      apiUrl,
      accessToken,
      requestBody,
      pageNumber,
      resultsPerPage
    );
    const folderIdTitleMap = await this.getFolderIdAndTitleMap(apiUrl, accessToken);
    const releases = [];
    data.forEach(
      (d) => releases.push({
        id: d.id,
        title: d.title,
        folder: this.getFolderTitle(folderIdTitleMap, d.id),
        status: d.status,
        fromDate: d.startDate,
        endDate: d.endDate,
        releaseRedirectUri: apiConfig.getReleaseDetailsRedirectUri(instanceConfig, d.id)
      })
    );
    const countData = await this.getReleasesCount(
      apiUrl,
      accessToken,
      requestBody
    );
    return {
      total: countData.live.total,
      releases
    };
  }
  async getReleasesList(apiUrl, accessToken, requestBody, pageNumber, resultsPerPage) {
    const response = await fetch(
      `${apiUrl}${apiConfig.RELEASE_OVERVIEW_API_PATH}?page=${pageNumber}&resultsPerPage=${resultsPerPage}`,
      {
        method: "POST",
        headers: {
          "x-release-personal-token": `${accessToken}`,
          "Content-Type": "application/json",
          Accept: "application/json"
        },
        body: JSON.stringify(requestBody)
      }
    );
    if (!response.ok && response.status === 404) {
      this.logger?.warn(`Calling Fallback Release search API.`);
      return await this.getFallBackReleasesList(
        apiUrl,
        accessToken,
        requestBody,
        pageNumber,
        resultsPerPage
      );
    } else if (!response.ok) {
      await responseUtil.parseErrorResponse(this.logger, response);
    }
    return await response.json();
  }
  async getFallBackReleasesList(apiUrl, accessToken, requestBody, pageNumber, resultsPerPage) {
    const response = await fetch(
      `${apiUrl}${apiConfig.RELEASE_OVERVIEW_EXISTING_API_PATH}?page=${pageNumber}&resultsPerPage=${resultsPerPage}`,
      {
        method: "POST",
        headers: {
          "x-release-personal-token": `${accessToken}`,
          "Content-Type": "application/json",
          Accept: "application/json"
        },
        body: JSON.stringify(requestBody)
      }
    );
    if (!response.ok) {
      await responseUtil.parseErrorResponse(this.logger, response);
    }
    const fallBackOverviews = await response.json();
    const releasesOverview = [];
    fallBackOverviews.forEach(
      (d) => releasesOverview.push({
        id: d.id,
        title: d.title,
        status: d.status,
        startDate: dateService.getStartOrScheduledDate(d),
        endDate: dateService.getEndOrDueDate(d),
        type: d.type,
        kind: d.kind
      })
    );
    return releasesOverview;
  }
  async getReleasesCount(apiUrl, accessToken, requestBody) {
    const response = await fetch(`${apiUrl}${apiConfig.RELEASE_COUNT_API_PATH}`, {
      method: "POST",
      headers: {
        "x-release-personal-token": `${accessToken}`,
        "Content-Type": "application/json",
        Accept: "application/json"
      },
      body: JSON.stringify(requestBody)
    });
    if (!response.ok) {
      await responseUtil.parseErrorResponse(this.logger, response);
    }
    return await response.json();
  }
  async getFoldersList(apiUrl, accessToken) {
    const response = await fetch(`${apiUrl}${apiConfig.RELEASE_FOLDERS_LIST_API_PATH}`, {
      method: "GET",
      headers: {
        "x-release-personal-token": `${accessToken}`,
        "Content-Type": "application/json",
        Accept: "application/json"
      }
    });
    if (!response.ok) {
      await responseUtil.parseErrorResponse(this.logger, response);
    }
    return await response.json();
  }
  async getFolderIdAndTitleMap(apiUrl, authCredentials) {
    const foldersList = await this.foldersApi.getFoldersList(
      apiUrl,
      authCredentials
    );
    const folderIdTitleMap = /* @__PURE__ */ new Map();
    foldersList.forEach((folder) => {
      iterateFol(folder, folderIdTitleMap, "");
    });
    function iterateFol(folder, map, parentTitle) {
      const titleWithPath = parentTitle ? `${parentTitle} > ${folder.title}` : folder.title;
      map.set(folder.id, titleWithPath);
      folder.children.forEach((child) => iterateFol(child, map, titleWithPath));
    }
    return folderIdTitleMap;
  }
  getFolderTitle = (folderIdTitleMap, releaseId) => {
    return folderIdTitleMap.get(
      releaseId.substring(0, releaseId.lastIndexOf("/"))
    );
  };
  async getReleaseInstances() {
    return this.config.getInstanceList();
  }
  async getTemplates(title, tags, pageNumber, resultsPerPage, instanceName) {
    const instanceConfig = this.config.getInstanceConfig(instanceName);
    const accessToken = apiConfig.getCredentials(instanceConfig);
    const apiUrl = apiConfig.getReleaseApiHost(instanceConfig);
    const data = await this.getTemplateList(
      apiUrl,
      title,
      tags,
      accessToken,
      pageNumber,
      resultsPerPage
    );
    const folderIdTitleMap = await this.getFolderIdAndTitleMap(apiUrl, accessToken);
    const templates = [];
    data.forEach(
      (d) => templates.push({
        id: d.id,
        title: d.title,
        folder: this.getFolderTitle(folderIdTitleMap, d.id),
        folderId: d.id.substring(0, d.id.lastIndexOf("/")),
        newReleaseRedirectUri: apiConfig.getCreateReleaseRedirectUri(
          instanceConfig,
          d.id
        ),
        titleRedirectUri: apiConfig.getTemplateDetailsRedirectUri(instanceConfig, d.id)
      })
    );
    return {
      templates
    };
  }
  async getTemplateList(apiUrl, title, tags, accessToken, pageNumber, resultsPerPage) {
    let url = `${apiUrl}${apiConfig.RELEASE_TEMPLATE_LIST_API_PATH}?page=${pageNumber}&resultsPerPage=${resultsPerPage}`;
    if (title && title !== "") {
      url += `&title=${title}`;
    }
    if (tags && tags.length > 0) {
      tags.forEach((tag) => {
        url += `&tag=${tag}`;
      });
    }
    const response = await fetch(url, {
      method: "GET",
      headers: {
        "x-release-personal-token": `${accessToken}`,
        "Content-Type": "application/json",
        Accept: "application/json"
      }
    });
    if (!response.ok) {
      await responseUtil.parseErrorResponse(this.logger, response);
    }
    return await response.json();
  }
}

exports.ReleaseOverviewApi = ReleaseOverviewApi;
//# sourceMappingURL=ReleaseOverviewApi.cjs.js.map