ipp-printer/lib/operations.js

Create a printer on the network

'use strict'

var C = require('ipp-encoder').CONSTANTS
var once = require('once')
var utils = require('./utils')
var groups = require('./groups')
var Job = require('./job')

exports.printJob = printJob
exports.validateJob = validateJob
exports.getPrinterAttributes = getPrinterAttributes
exports.getJobs = getJobs
exports.cancelJob = cancelJob
exports.getJobAttributes = getJobAttributes

function printJob (printer, req, res) {
  var job = new Job(printer, req)
  var send = once(res.send)

  job.on('abort', function (statusCode) {
    send(statusCode)
  })

  req.on('end', function () {
    send({
      tag: C.JOB_ATTRIBUTES_TAG,
      attributes: job.attributes(['job-uri', 'job-id', 'job-state'])
    })
  })

  job.process()
}

function validateJob (printer, req, res) {
  // we could add a more elaborate form of validation, but for now it
  // must be ok that we were just able to parse the request
  res.send()
}

function getPrinterAttributes (printer, req, res) {
  var requested = utils.requestedAttributes(req._body) || ['all']
  var attributes = printer.attributes(requested)
  var group1 = groups.unsupportedAttributesTag(attributes, requested)
  var group2 = groups.printerAttributesTag(attributes)
  res.send(group1.attributes.length > 0 ? [group1, group2] : [group2])
}

function getJobs (printer, req, res) {
  var attributes = utils.getAttributesForGroup(req._body, C.OPERATION_ATTRIBUTES_TAG)
  var limit = utils.getFirstValueForName(attributes, 'limit') || Infinity
  var which = utils.getFirstValueForName(attributes, 'which-jobs')
  var states

  switch (which) {
    case 'completed':
      states = [C.JOB_COMPLETED, C.JOB_CANCELED, C.JOB_ABORTED]
      break
    case 'not-completed':
      states = [C.JOB_PENDING, C.JOB_PROCESSING, C.JOB_PROCESSING_STOPPED, C.JOB_PENDING_HELD]
      break
    case undefined:
      // all is good :)
      break
    default:
      res.send(
        C.CLIENT_ERROR_ATTRIBUTES_OR_VALUES_NOT_SUPPORTED,
        { tag: C.UNSUPPORTED_ATTRIBUTES_TAG, attributes: [
          { tag: C.UNSUPPORTED, name: 'which-jobs', value: which }
        ] }
      )
      return
  }

  var jobs = states
    ? printer.jobs.filter(function (job) { return ~states.indexOf(job.state) })
    : printer.jobs

  var requested = utils.requestedAttributes(req._body) || ['job-uri', 'job-id']

  var _groups = jobs
    .sort(function (a, b) {
      if (a.completedAt && !b.completedAt) return -1
      if (!a.completedAt && b.completedAt) return 1
      if (!a.completedAt && !b.completedAt) return b.id - a.id
      return b.completedAt - b.completedAt
    })
    .slice(0, limit)
    .map(function (job) {
      var attributes = job.attributes(requested)
      return groups.jobAttributesTag(attributes)
    })

  if (_groups[0]) {
    var group = groups.unsupportedAttributesTag(_groups[0].attributes, requested)
    if (group.attributes.length > 0) _groups.unshift(group)
  }

  res.send(_groups)
}

function cancelJob (printer, req, res) {
  var job = utils.getJobFromRequest(printer, req._body)
  if (!job) return res.send(C.CLIENT_ERROR_NOT_FOUND)

  switch (job.state) {
    case C.JOB_PENDING:
    case C.JOB_PENDING_HELD:
    case C.JOB_PROCESSING:
    case C.JOB_PROCESSING_STOPPED:
      job.cancel()
      res.send(C.SUCCESSFUL_OK)
      break
    default:
      res.send(C.CLIENT_ERROR_NOT_POSSIBLE)
  }
}

function getJobAttributes (printer, req, res) {
  var job = utils.getJobFromRequest(printer, req._body)
  if (!job) return res.send(C.CLIENT_ERROR_NOT_FOUND)

  var requested = utils.requestedAttributes(req._body) || ['all']
  var attributes = job.attributes(requested)
  var group1 = groups.unsupportedAttributesTag(attributes, requested)
  var group2 = groups.jobAttributesTag(attributes)
  res.send(group1.attributes.length > 0 ? [group1, group2] : [group2])
}