oa-jira/src/core/services/core.services.js

Octet Agile's JIRA connectivity project.

const model = require('../../model/');
const commons = require('../../commons');
const Connection = require('../../connection/classes/connection.class');
const Cache = require('../../cache/classes/cache.class');

const resolveCache = cache => {
  return Cache.resolve(cache)
    .then(cache => Promise.resolve(cache))
    .catch(_ => Promise.resolve(new Cache()));
};

exports.getBoardById = ({ connection, id, cache }) => {
  return Promise.all([
    Connection.resolve(connection),
    commons.int.resolve(id, { name: 'id', required: true, min: 0 }),
    resolveCache(cache)
  ])
    .then(([connection, id, cache]) => model.boards.getById({ connection, id, cache }))
    .catch(error => Promise.reject(error));
};

exports.getCategoryById = ({ connection, id, cache }) => {
  return Promise.all([
    Connection.resolve(connection),
    commons.int.resolve(id, { name: 'id', required: true, min: 0 }),
    resolveCache(cache)
  ])
    .then(([connection, id, cache]) => model.categories.getById({ connection, id, cache }))
    .catch(error => Promise.reject(error));
};

exports.getIssueByKey = ({ connection, key, cache }) => {
  return Promise.all([
    Connection.resolve(connection),
    commons.string.resolve(key, { name: 'key', required: true, trim: true, minLength: 1 }),
    resolveCache(cache)
  ])
    .then(([connection, key, cache]) => model.issues.getByKey({ connection, key, cache }))
    .catch(error => Promise.reject(error));
};

exports.getIssuesByBoardId = ({ connection, boardId, cache, offset, size }) => {
  return Promise.all([
    Connection.resolve(connection),
    commons.int.resolve(boardId, { name: 'board id', required: true }),
    resolveCache(cache),
    commons.int.resolve(offset, { name: 'offset', required: false, min: 0 }),
    commons.int.resolve(size, { name: 'size', required: false, min: 0, max: 1000 })
  ])
    .then(([connection, boardId, cache, offset, size]) => {
      return model.issues.getByBoardId({ connection, boardId, cache, offset, size });
    })
    .catch(error => Promise.reject(error));
};

exports.getProjectById = ({ connection, id, cache }) => {
  return Promise.all([
    Connection.resolve(connection),
    commons.string.resolve(id, { name: 'id', required: true, trim: true, minLength: 1 }),
    resolveCache(cache)
  ])
    .then(([connection, id, cache]) => model.projects.getById({ connection, id, cache }))
    .catch(error => Promise.reject(error));
};

exports.getResolutionById = ({ connection, id, cache }) => {
  return Promise.all([
    Connection.resolve(connection),
    commons.string.resolve(id, { name: 'id', required: true, trim: true, minLength: 1 }),
    resolveCache(cache)
  ])
    .then(([connection, id, cache]) => model.resolutions.getById({ connection, id, cache }))
    .catch(error => Promise.reject(error));
};

exports.getSprintById = ({ connection, id, cache }) => {
  return Promise.all([
    Connection.resolve(connection),
    commons.int.resolve(id, { name: 'id', required: true, min: 0 }),
    resolveCache(cache)
  ])
    .then(([connection, id, cache]) => model.sprints.getById({ connection, id, cache }))
    .catch(error => Promise.reject(error));
};

exports.getSprintsByIds = ({ connection, ids, cache }) => {
  return Promise.all([
    Connection.resolve(connection),
    commons.int.resolveBulk(ids, { name: 'sprint ids', required: true, min: 0 }),
    resolveCache(cache)
  ])
    .then(([connection, ids, cache]) => model.sprints.getByIds({ connection, ids, cache }))
    .catch(error => Promise.reject(error));
};

exports.getLastSprintByIds = ({ connection, ids, cache }) => {
  return Promise.all([
    Connection.resolve(connection),
    commons.int.resolveBulk(ids, { name: 'sprint ids', required: true, min: 0 }),
    resolveCache(cache)
  ])
    .then(([connection, ids, cache]) => model.sprints.getLastByIds({ connection, ids, cache }))
    .catch(error => Promise.reject(error));
};

exports.getStatusById = ({ connection, id, cache }) => {
  return Promise.all([
    Connection.resolve(connection),
    commons.string.resolve(id, { name: 'id', required: true, trim: true, minLength: 1 }),
    resolveCache(cache)
  ])
    .then(([connection, id, cache]) => model.statuses.getById({ connection, id, cache }))
    .catch(error => Promise.reject(error));
};

exports.getTypeById = ({ connection, id, cache }) => {
  return Promise.all([
    Connection.resolve(connection),
    commons.string.resolve(id, { name: 'id', required: true, trim: true, minLength: 1 }),
    resolveCache(cache)
  ])
    .then(([connection, id, cache]) => model.types.getById({ connection, id, cache }))
    .catch(error => Promise.reject(error));
};

exports.getVersionById = ({ connection, id, cache }) => {
  return Promise.all([
    Connection.resolve(connection),
    commons.string.resolve(id, { name: 'id', required: true, trim: true, minLength: 1 }),
    resolveCache(cache)
  ])
    .then(([connection, id, cache]) => model.versions.getById({ connection, id, cache }))
    .catch(error => Promise.reject(error));
};