cloud_oadr-vtn/xml/event/created-event.js

'use strict';

const { parseXML, childAttr, required, number } = require('../parser');
const { create, fragment } = require('xmlbuilder2');

const oadrPayloadNs = 'http://www.w3.org/2000/09/xmldsig#';
const oadrNs = 'http://openadr.org/oadr-2.0b/2012/07';
const energyInteropNs = 'http://docs.oasis-open.org/ns/energyinterop/201110';
const energyInteropPayloadsNs =
  'http://docs.oasis-open.org/ns/energyinterop/201110/payloads';

function parseEiResponse(response) {
  return {
    code: required(childAttr(response, 'responseCode'), 'responseCode'),
    description: childAttr(response, 'responseDescription'),
    requestId: required(childAttr(response, 'requestID'), 'requestID'),
  };
}

function parseEventResponse(eventResponse) {
  return {
    responseCode: required(
      childAttr(eventResponse, 'responseCode'),
      'responseCode',
    ),
    responseDescription: childAttr(eventResponse, 'responseDescription'),
    responseRequestId: required(
      childAttr(eventResponse, 'requestID'),
      'requestID',
    ),
    optType: required(childAttr(eventResponse, 'optType'), 'optType'),
    eventId: required(
      childAttr(eventResponse['qualifiedEventID'][0]['$$'], 'eventID'),
      'qualifiedEventID.eventID',
    ),
    modificationNumber: required(
      number(
        childAttr(
          eventResponse['qualifiedEventID'][0]['$$'],
          'modificationNumber',
        ),
      ),
      'qualifiedEventID.modificationNumber',
    ),
  };
}

function parseEventResponses(eventResponses) {
  const unwrappedEventResponses = eventResponses['$$']['eventResponse'];
  return unwrappedEventResponses.map(x => parseEventResponse(x['$$']));
}

function parseEiCreatedEvent(eiCreatedEvent) {
  const { code, description, requestId } = parseEiResponse(
    eiCreatedEvent['eiResponse'][0]['$$'],
  );

  const result = {
    _type: 'oadrCreatedEvent',
    responseCode: code,
    responseDescription: description,
    responseRequestId: requestId,
  };

  const venId = childAttr(eiCreatedEvent, 'venID');
  if (venId != null) result.venId = venId;

  const eventResponses = childAttr(eiCreatedEvent, 'eventResponses');
  if (eventResponses != null)
    result.eventResponses = parseEventResponses(eventResponses);

  return result;
}

async function parse(input) {
  const json = await parseXML(input);
  const o =
    json['oadrPayload']['$$']['oadrSignedObject'][0]['$$'][
      'oadrCreatedEvent'
    ][0]['$$'];

  return parseEiCreatedEvent(o['eiCreatedEvent'][0]['$$']);
}

function serializeEiResponse(eiCreatedEvent) {
  const descriptionFrag =
    eiCreatedEvent.responseDescription != null
      ? fragment()
        .ele(energyInteropNs, 'ei:responseDescription')
        .txt(eiCreatedEvent.responseDescription)
      : fragment();

  return fragment()
    .ele(energyInteropNs, 'ei:eiResponse')
    .ele(energyInteropNs, 'ei:responseCode')
    .txt(eiCreatedEvent.responseCode)
    .up()
    .import(descriptionFrag)
    .ele(energyInteropPayloadsNs, 'pyld:requestID')
    .txt(eiCreatedEvent.responseRequestId)
    .up()
    .up();
}

function serializeEventResponse(eventResponse) {
  const descriptionFrag =
    eventResponse.responseDescription != null
      ? fragment()
        .ele(energyInteropNs, 'ei:responseDescription')
        .txt(eventResponse.responseDescription)
      : fragment();

  return fragment()
    .ele(energyInteropNs, 'ei:eventResponse')
    .ele(energyInteropNs, 'ei:responseCode')
    .txt(eventResponse.responseCode)
    .up()
    .import(descriptionFrag)
    .ele(energyInteropPayloadsNs, 'pyld:requestID')
    .txt(eventResponse.responseRequestId)
    .up()
    .ele(energyInteropNs, 'ei:optType')
    .txt(eventResponse.optType)
    .up()
    .ele(energyInteropNs, 'ei:qualifiedEventID')
    .ele(energyInteropNs, 'ei:eventID')
    .txt(eventResponse.eventId)
    .up()
    .ele(energyInteropNs, 'ei:modificationNumber')
    .txt(eventResponse.modificationNumber)
    .up()
    .up();
}

function serializeEventResponses(eventResponses) {
  const result = fragment();
  const responsesHolder = result.ele(energyInteropNs, 'ei:eventResponses');

  eventResponses.forEach(x =>
    responsesHolder.import(serializeEventResponse(x)),
  );
  return result;
}

function serializeEiCreatedEvent(eiCreatedEvent) {
  const result = fragment();
  const eiCreatedEventHolder = result.ele(oadrPayloadNs, 'pyld:eiCreatedEvent');
  eiCreatedEventHolder.import(serializeEiResponse(eiCreatedEvent));
  eiCreatedEventHolder.import(
    serializeEventResponses(eiCreatedEvent.eventResponses),
  );

  if (eiCreatedEvent.venId != null) {
    eiCreatedEventHolder
      .ele(energyInteropNs, 'ei:venID')
      .txt(eiCreatedEvent.venId);
  }

  return result;
}

function serialize(obj) {
  const doc = create({
    namespaceAlias: {
      ns: oadrPayloadNs,
      oadr2b: oadrNs,
      ei: energyInteropNs,
      pyld: energyInteropPayloadsNs,
    },
  })
    .ele('@oadr2b', 'oadr2b:oadrPayload')
    .ele('oadr2b:oadrSignedObject')
    .ele('oadr2b:oadrCreatedEvent')
    .import(serializeEiCreatedEvent(obj))
    .doc();
  return doc.end({ headless: true, prettyPrint: false });
}

async function canParse(input) {
  const json = await parseXML(input);
  const o = json['oadrPayload']['$$']['oadrSignedObject'][0]['$$'];
  return o['oadrCreatedEvent'] != null;
}

module.exports = {
  parse,
  serialize,
  canParse,
};