overleaf/services/web/app/src/Features/Documents/DocumentController.js

/* eslint-disable
    camelcase,
    node/handle-callback-err,
    max-len,
*/
// TODO: This file was created by bulk-decaffeinate.
// Fix any style issues and re-enable lint.
/*
 * decaffeinate suggestions:
 * DS102: Remove unnecessary code created because of implicit returns
 * DS103: Rewrite code to no longer use __guard__
 * DS207: Consider shorter variations of null checks
 * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
 */
const ProjectGetter = require('../Project/ProjectGetter')
const OError = require('@overleaf/o-error')
const ProjectLocator = require('../Project/ProjectLocator')
const ProjectEntityHandler = require('../Project/ProjectEntityHandler')
const ProjectEntityUpdateHandler = require('../Project/ProjectEntityUpdateHandler')
const logger = require('logger-sharelatex')
const _ = require('lodash')

module.exports = {
  getDocument(req, res, next) {
    if (next == null) {
      next = function(error) {}
    }
    const project_id = req.params.Project_id
    const { doc_id } = req.params
    const plain =
      __guard__(req != null ? req.query : undefined, x => x.plain) === 'true'
    return ProjectGetter.getProject(
      project_id,
      { rootFolder: true, overleaf: true },
      function(error, project) {
        if (error != null) {
          return next(error)
        }
        if (project == null) {
          return res.sendStatus(404)
        }
        return ProjectLocator.findElement(
          { project, element_id: doc_id, type: 'doc' },
          function(error, doc, path) {
            if (error != null) {
              OError.tag(error, 'error finding element for getDocument', {
                doc_id,
                project_id
              })
              return next(error)
            }
            return ProjectEntityHandler.getDoc(project_id, doc_id, function(
              error,
              lines,
              rev,
              version,
              ranges
            ) {
              if (error != null) {
                OError.tag(
                  error,
                  'error finding doc contents for getDocument',
                  {
                    doc_id,
                    project_id
                  }
                )
                return next(error)
              }
              if (plain) {
                res.type('text/plain')
                return res.send(lines.join('\n'))
              } else {
                const projectHistoryId = _.get(project, 'overleaf.history.id')
                const projectHistoryType = _.get(
                  project,
                  'overleaf.history.display'
                )
                  ? 'project-history'
                  : undefined // for backwards compatibility, don't send anything if the project is still on track-changes
                return res.json({
                  lines,
                  version,
                  ranges,
                  pathname: path.fileSystem,
                  projectHistoryId,
                  projectHistoryType
                })
              }
            })
          }
        )
      }
    )
  },

  setDocument(req, res, next) {
    if (next == null) {
      next = function(error) {}
    }
    const project_id = req.params.Project_id
    const { doc_id } = req.params
    const { lines, version, ranges, lastUpdatedAt, lastUpdatedBy } = req.body
    return ProjectEntityUpdateHandler.updateDocLines(
      project_id,
      doc_id,
      lines,
      version,
      ranges,
      lastUpdatedAt,
      lastUpdatedBy,
      function(error) {
        if (error != null) {
          OError.tag(error, 'error finding element for getDocument', {
            doc_id,
            project_id
          })
          return next(error)
        }
        logger.log(
          { doc_id, project_id },
          'finished receiving set document request from api (docupdater)'
        )
        return res.sendStatus(200)
      }
    )
  }
}

function __guard__(value, transform) {
  return typeof value !== 'undefined' && value !== null
    ? transform(value)
    : undefined
}