oa-jira/src/model/helpers/fields.helper.js

Octet Agile's JIRA connectivity project.

const Cache = require('../../cache/classes/cache.class');
const Category = require('../classes/category.class');
const Project = require('../classes/project.class');
const Resolution = require('../classes/resolution.class');
const Sprint = require('../classes/sprint.class');
const Status = require('../classes/status.class');
const Type = require('../classes/type.class');
const Version = require('../classes/version.class');

const parseSprintFromFields = data => {
  const sprint = { id: data.id, state: data.state, name: data.name };
  if (data.boardId) sprint.originBoardId = data.boardId;
  if (data.goal) sprint.goal = data.goal;
  if (data.startDate) sprint.startDate = new Date(data.startDate);
  if (data.endDate) sprint.endDate = new Date(data.endDate);
  if (data.completeDate) sprint.completeDate = new Date(data.completeDate);
  return Sprint.create(sprint);
};

const storeSprint = (sprints, cache, lastSprint) => {
  if (sprints.length === 0) return Promise.resolve(lastSprint);

  return parseSprintFromFields(sprints.pop())
    .then(sprint => cache.sprints.set(sprint.getId(), sprint))
    .then(sprint => {
      return !lastSprint || sprint.compare(lastSprint) > 0
        ? storeSprint(sprints, cache, sprint)
        : storeSprint(sprints, cache, lastSprint);
    })
    .catch(error => Promise.reject(error));
};

const storeSprints = (sprints, cache) => (Array.isArray(sprints) ? storeSprint(sprints, cache) : Promise.resolve());

const parseStatusFromFields = data => {
  return (data.statusCategory ? Category.create(data.statusCategory) : Promise.resolve()).then(category => {
    return Status.create({
      id: data.id,
      name: data.name,
      description: data.description,
      iconUrl: data.iconUrl,
      category
    });
  });
};

const storeStatus = (data, cache) => {
  if (cache.statuses.has(data.id)) return cache.statuses.get(data.id);
  return parseStatusFromFields(data)
    .then(status => {
      return Promise.all([
        cache.categories.set(status.getCategory().getId(), status.getCategory()),
        cache.statuses.set(status.getId(), status)
      ]);
    })
    .then(([_, status]) => Promise.resolve(status))
    .catch(error => Promise.reject(error));
};

const parseProject = data => {
  return Project.create({
    id: data.id,
    key: data.key,
    name: data.name,
    type: data.projectTypeKey
  });
};

const storeProject = (data, cache) => {
  if (cache.projects.has(data.id)) return cache.projects.get(data.id);
  return parseProject(data)
    .then(project => cache.projects.set(project.getId(), project))
    .catch(error => Promise.reject(error));
};

const storeResolution = (data, cache) => {
  if (!data) return Promise.resolve();
  if (cache.resolutions.has(data.id)) return cache.resolutions.get(data.id);
  return Resolution.create(data)
    .then(resolution => cache.resolutions.set(resolution.getId(), resolution))
    .catch(error => Promise.reject(error));
};

const storeType = (data, cache) => {
  if (cache.types.has(data.id)) return cache.types.get(data.id);
  return Type.create(data)
    .then(type => cache.types.set(type.getId(), type))
    .catch(error => Promise.reject(error));
};

const parseVersion = data => {
  return Version.create({
    id: data.id,
    description: data.description,
    name: data.name,
    archived: data.archived,
    released: data.released,
    releaseDate: data.releaseDate ? new Date(data.releaseDate) : null
  });
};

const storeVersion = (data, cache) => {
  if (cache.versions.has(data.id)) return cache.versions.get(data.id);
  return parseVersion(data)
    .then(version => cache.versions.set(version.getId(), version))
    .catch(error => Promise.reject(error));
};

const storeVersions = (data, cache) => {
  return Array.isArray(data)
    ? Promise.all(data.map(versionData => storeVersion(versionData, cache)))
    : Promise.resolve();
};

/**
 * @param {*} fields The fields.
 * @param {Cache} cache A jira cache.
 */
exports.parse = ({ fields, cache }) => {
  const issueData = { summary: fields.summary, updated: new Date(fields.updated) };
  if (Number.isInteger(fields.customfield_10016)) issueData.complexity = fields.customfield_10016;

  return Promise.all([
    storeSprints(fields.customfield_10020, cache),
    storeStatus(fields.status, cache),
    storeProject(fields.project, cache),
    storeResolution(fields.resolution, cache),
    storeType(fields.issuetype, cache),
    storeVersions(fields.fixVersions, cache)
  ])
    .then(([sprint, status, project, resolution, type, versions]) => {
      issueData.status = status;
      issueData.project = project;
      issueData.type = type;
      if (sprint) issueData.sprint = sprint;
      if (resolution) issueData.resolution = resolution;
      if (versions) issueData.versions = versions;
      return Promise.resolve(issueData);
    })
    .catch(error => Promise.reject(error));
};