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

'use strict';

const _ = require('lodash');

const {
  parseXML,
  childAttr,
  required,
  boolean,
  dateTime,
  duration,
  number,
} = require('../parser');
const {
  createDoc,
  parseEiResponse,
  parseEventSignalIntervals,
  serializeEventSignalIntervals,
  parsePayloadFloat,
  serializePayloadFloat,
  serializeEiResponse,
  serializeDuration,
  serializeDateTime,
  energyInteropPayloadsNs,
  energyInteropNs,
  oadrNs,
  powerNs,
  emixNs,
  calendarNs,
  calendarStreamNs,
  siScaleNs,
  xsiNs,
} = require('../shared');
const { fragment } = require('xmlbuilder2');

const eiTargetMappings = [
  {
    xmlNs: 'power',
    xmlNsUri: powerNs,
    xmlElement: 'endDeviceAsset',
    xmlChildElement: 'mrid',
    json: 'end-device-asset',
  },
  {
    xmlNs: 'power',
    xmlNsUri: powerNs,
    xmlElement: 'aggregatedPnode',
    xmlChildElement: 'node',
    json: 'aggregated-pnode',
  },
  {
    xmlNs: 'power',
    xmlNsUri: powerNs,
    xmlElement: 'meterAsset',
    xmlChildElement: 'mrid',
    json: 'meter-asset',
  },
  {
    xmlNs: 'power',
    xmlNsUri: powerNs,
    xmlElement: 'pnode',
    xmlChildElement: 'node',
    json: 'pnode',
  },
  {
    xmlNs: 'power',
    xmlNsUri: powerNs,
    xmlElement: 'serviceDeliveryPoint',
    xmlChildElement: 'node',
    json: 'service-delivery-point',
  },
  {
    xmlNs: 'ei',
    xmlNsUri: energyInteropNs,
    xmlElement: 'groupID',
    json: 'group',
  },
  {
    xmlNs: 'ei',
    xmlNsUri: energyInteropNs,
    xmlElement: 'groupName',
    json: 'group-name',
  },
  {
    xmlNs: 'ei',
    xmlNsUri: energyInteropNs,
    xmlElement: 'resourceID',
    json: 'resource',
  },
  {
    xmlNs: 'ei',
    xmlNsUri: energyInteropNs,
    xmlElement: 'venID',
    json: 'ven',
  },
  {
    xmlNs: 'ei',
    xmlNsUri: energyInteropNs,
    xmlElement: 'partyID',
    json: 'party',
  },
];

const itemBaseMappings = [
  {
    xmlNs: 'power',
    xmlNsUri: powerNs,
    xmlElement: 'powerReal',
    additionalAttributes: [
      {
        xmlElement: 'powerAttributes',
        json: 'powerAttributes',
      },
    ],
    json: 'power-real',
  },
  {
    xmlNs: 'power',
    xmlNsUri: powerNs,
    xmlElement: 'powerReactive',
    additionalAttributes: [
      {
        xmlElement: 'powerAttributes',
        json: 'powerAttributes',
      },
    ],
    json: 'power-reactive',
  },
  {
    xmlNs: 'power',
    xmlNsUri: powerNs,
    xmlElement: 'powerApparent',
    additionalAttributes: [
      {
        xmlElement: 'powerAttributes',
        json: 'powerAttributes',
      },
    ],
    json: 'power-apparent',
  },
  {
    xmlNs: 'power',
    xmlNsUri: powerNs,
    xmlElement: 'voltage',
    json: 'voltage',
  },
  {
    xmlNs: 'power',
    xmlNsUri: powerNs,
    xmlElement: 'energyApparent',
    json: 'energy-apparent',
  },
  {
    xmlNs: 'power',
    xmlNsUri: powerNs,
    xmlElement: 'energyReactive',
    json: 'energy-reactive',
  },
  {
    xmlNs: 'power',
    xmlNsUri: powerNs,
    xmlElement: 'energyReal',
    json: 'energy-real',
  },
  {
    xmlNs: 'oadr',
    xmlNsUri: oadrNs,
    xmlElement: 'currencyPerKWh',
    json: 'currency-per-kwh',
  },
  {
    xmlNs: 'oadr',
    xmlNsUri: oadrNs,
    xmlElement: 'currencyPerKW',
    json: 'currency-per-kw',
  },
  {
    xmlNs: 'oadr',
    xmlNsUri: oadrNs,
    xmlElement: 'currencyPerThm',
    json: 'currency-per-thm',
  },
  {
    xmlNs: 'oadr',
    xmlNsUri: oadrNs,
    xmlElement: 'currency',
    json: 'currency',
  },
  {
    xmlNs: 'oadr',
    xmlNsUri: oadrNs,
    xmlElement: 'current',
    json: 'current',
  },
  {
    xmlNs: 'oadr',
    xmlNsUri: oadrNs,
    xmlElement: 'frequency',
    json: 'frequency',
  },
  {
    xmlNs: 'oadr',
    xmlNsUri: oadrNs,
    xmlElement: 'Therm',
    json: 'therm',
  },
  {
    xmlNs: 'oadr',
    xmlNsUri: oadrNs,
    xmlElement: 'temperature',
    json: 'temperature',
  },
  {
    xmlNs: 'oadr',
    xmlNsUri: oadrNs,
    xmlElement: 'pulseCount',
    json: 'pulse-count',
  },
  {
    xmlNs: 'oadr',
    xmlNsUri: oadrNs,
    xmlElement: 'customUnit',
    json: 'custom-unit',
  },
];

function parseItemBase(x) {
  for (const itemBaseMapping of itemBaseMappings) {
    const { json, xmlElement, additionalAttributes } = itemBaseMapping;
    const itemBaseList = x[xmlElement];
    if (itemBaseList) {
      const itemBase = itemBaseList[0]['$$'];
      const result = {
        type: json,
        description: required(
          childAttr(itemBase, 'itemDescription'),
          'itemDescription',
        ),
        units: required(childAttr(itemBase, 'itemUnits'), 'itemUnits'),
        siScaleCode: required(
          childAttr(itemBase, 'siScaleCode'),
          'siScaleCode',
        ),
      };
      for (const additionalMapping of additionalAttributes || []) {
        const unNamespacedAdditionalAttribute = additionalMapping.xmlElement;
        const attributesList = itemBase[unNamespacedAdditionalAttribute];
        if (attributesList) {
          const xmlAttributes = attributesList[0]['$$'];
          const attributes = {};
          Object.keys(xmlAttributes).forEach(key => {
            attributes[key] = required(childAttr(xmlAttributes, key), key);
          });
          result[additionalMapping.json] = attributes;
        }
      }
      return result;
    }
  }
}

function serializeItemBase(x) {
  for (const itemBaseMapping of itemBaseMappings) {
    const {
      xmlNs,
      xmlNsUri,
      json,
      xmlElement,
      additionalAttributes,
    } = itemBaseMapping;
    if (x.type === json) {
      const result = fragment();
      const innerResult = result.ele(xmlNsUri, `${xmlNs}:${xmlElement}`);
      innerResult.ele(xmlNsUri, xmlNs + ':itemDescription').txt(x.description);
      innerResult.ele(xmlNsUri, xmlNs + ':itemUnits').txt(x.units);
      innerResult.ele(siScaleNs, 'scale:siScaleCode').txt(x.siScaleCode);
      if (additionalAttributes) {
        additionalAttributes.forEach(additionalAttribute => {
          const additionalResult = innerResult.ele(
            xmlNsUri,
            `${xmlNs}:${additionalAttribute.xmlElement}`,
          );
          const additionalJson = x[additionalAttribute.json];
          Object.keys(additionalJson).forEach(key => {
            additionalResult
              .ele(xmlNsUri, `${xmlNs}:${key}`)
              .txt(additionalJson[key]);
          });
        });
      }
      return result;
    }
  }
}

function parseEventDescriptor(eventDescriptor) {
  const result = {
    eventId: required(childAttr(eventDescriptor, 'eventID'), 'eventID'),
    modificationNumber: required(
      number(childAttr(eventDescriptor, 'modificationNumber')),
      'modificationNumber',
    ),
    marketContext: childAttr(
      eventDescriptor.eiMarketContext[0]['$$'],
      'marketContext',
    ),
    createdDateTime: required(
      childAttr(eventDescriptor, 'createdDateTime'),
      'createdDateTime',
    ),
    eventStatus: required(
      childAttr(eventDescriptor, 'eventStatus'),
      'eventStatus',
    ),
  };

  const testEvent = boolean(childAttr(eventDescriptor, 'testEvent'));
  if (testEvent != null) {
    result.testEvent = testEvent;
  }

  const modificationDateTime = childAttr(
    eventDescriptor,
    'modificationDateTime',
  );
  if (modificationDateTime != null)
    result.modificationDateTime = modificationDateTime;

  const modificationReason = childAttr(eventDescriptor, 'modificationReason');
  if (modificationReason != null)
    result.modificationReason = modificationReason;

  const priority = number(childAttr(eventDescriptor, 'priority'));
  if (priority != null) result.priority = priority;

  const vtnComment = childAttr(eventDescriptor, 'vtnComment');
  if (vtnComment != null) result.vtnComment = vtnComment;

  return result;
}

function serializeEventDescriptor(eventDescriptor) {
  const result = fragment();

  const eventDescriptorResult = result.ele(
    energyInteropNs,
    'ei:eventDescriptor',
  );

  eventDescriptorResult
    .ele(energyInteropNs, 'ei:eventID')
    .txt(eventDescriptor.eventId)
    .up()
    .ele(energyInteropNs, 'ei:modificationNumber')
    .txt(eventDescriptor.modificationNumber)
    .up()
    .ele(energyInteropNs, 'ei:eiMarketContext')
    .ele(emixNs, 'emix:marketContext')
    .txt(eventDescriptor.marketContext)
    .up()
    .up()
    .ele(energyInteropNs, 'ei:createdDateTime')
    .txt(eventDescriptor.createdDateTime)
    .up()
    .ele(energyInteropNs, 'ei:eventStatus')
    .txt(eventDescriptor.eventStatus);

  if (eventDescriptor.testEvent != null) {
    eventDescriptorResult
      .ele(energyInteropNs, 'ei:testEvent')
      .txt(eventDescriptor.testEvent);
  }

  if (eventDescriptor.modificationDateTime != null) {
    eventDescriptorResult
      .ele(energyInteropNs, 'ei:modificationDateTime')
      .txt(eventDescriptor.modificationDateTime);
  }

  if (eventDescriptor.modificationReason != null) {
    eventDescriptorResult
      .ele(energyInteropNs, 'ei:modificationReason')
      .txt(eventDescriptor.modificationReason);
  }

  if (eventDescriptor.priority != null) {
    eventDescriptorResult
      .ele(energyInteropNs, 'ei:priority')
      .txt(eventDescriptor.priority);
  }

  if (eventDescriptor.vtnComment != null) {
    eventDescriptorResult
      .ele(energyInteropNs, 'ei:vtnComment')
      .txt(eventDescriptor.vtnComment);
  }

  return result;
}

function parseToleranceTolerateStartAfter(tolerance) {
  if (tolerance) {
    const tolerate = childAttr(tolerance['$$'], 'tolerate');
    if (tolerate) {
      return duration(tolerate, 'startafter');
    }
  }
}

function parseEiTarget(eiTarget) {
  const result = [];
  for (const eiTargetMapping of eiTargetMappings) {
    const unNamespacedAttribute = eiTargetMapping.xmlElement;
    if (eiTarget[unNamespacedAttribute]) {
      const eiTargetValue = eiTarget[unNamespacedAttribute];
      let newValues;
      if (eiTargetMapping.xmlChildElement) {
        const unNamespacedChildAttribute = eiTargetMapping.xmlChildElement;
        newValues = eiTargetValue[0]['$$'][unNamespacedChildAttribute];
      } else {
        newValues = eiTargetValue;
      }
      const newTargets = newValues.map(value => {
        return {
          type: eiTargetMapping.json,
          value,
        };
      });
      result.push(...newTargets);
    }
  }
  return result;
}

function serializeEiTarget(eiTarget) {
  const result = fragment();
  const targetElement = result.ele(energyInteropNs, 'ei:eiTarget');
  const groupedByType = _.groupBy(eiTarget, item => item.type);

  for (const eiTargetMapping of eiTargetMappings) {
    const { xmlNs, xmlNsUri, xmlElement, xmlChildElement } = eiTargetMapping;

    const byType = groupedByType[eiTargetMapping.json];
    if (byType) {
      byType.forEach(target => {
        if (xmlChildElement) {
          targetElement
            .ele(xmlNsUri, `${xmlNs}:${xmlElement}`)
            .ele(xmlNsUri, `${xmlNs}:${xmlChildElement}`)
            .txt(target.value);
        } else {
          targetElement
            .ele(xmlNsUri, `${xmlNs}:${xmlElement}`)
            .txt(target.value);
        }
      });
    }
  }

  return result;
}

function parseEventSignal(eventSignal) {
  const result = {
    signalName: required(childAttr(eventSignal, 'signalName'), 'signalName'),
    signalType: required(childAttr(eventSignal, 'signalType'), 'signalType'),
    signalId: required(childAttr(eventSignal, 'signalID'), 'signalID'),
  };

  const intervals = eventSignal['intervals'][0]['$$'];
  if (intervals) {
    result.intervals = parseEventSignalIntervals(intervals['interval']);
  }

  const eiTarget = childAttr(eventSignal, 'eiTarget');
  if (eiTarget != null) {
    result.targets = parseEiTarget(eiTarget['$$']);
  }

  const currentValue = childAttr(eventSignal, 'currentValue');
  if (currentValue != null)
    result.currentValue = parsePayloadFloat(currentValue['$$']);

  const itemBase = parseItemBase(eventSignal);
  if (itemBase != null) result.itemBase = itemBase;

  return result;
}

function serializeEventSignal(eventSignal) {
  const result = fragment();
  const eiEventSignal = result.ele(energyInteropNs, 'ei:eiEventSignal');

  const intervals = eiEventSignal.ele(calendarStreamNs, 'strm:intervals');

  serializeEventSignalIntervals(eventSignal.intervals).forEach(interval =>
    intervals.import(interval),
  );

  eiEventSignal.ele(energyInteropNs, 'ei:signalID').txt(eventSignal.signalId);
  eiEventSignal
    .ele(energyInteropNs, 'ei:signalName')
    .txt(eventSignal.signalName);
  eiEventSignal
    .ele(energyInteropNs, 'ei:signalType')
    .txt(eventSignal.signalType);

  if (eventSignal.targets) {
    eiEventSignal.import(serializeEiTarget(eventSignal.targets));
  }

  if (eventSignal.currentValue != null) {
    eiEventSignal
      .ele(energyInteropNs, 'ei:currentValue')
      .import(serializePayloadFloat(eventSignal.currentValue));
  }

  if (eventSignal.itemBase != null) {
    eiEventSignal.import(serializeItemBase(eventSignal.itemBase));
  }

  return result;
}

function parseEventBaseline(eventSignal) {
  const result = {
    startDate: required(
      dateTime(childAttr(eventSignal, 'dtstart'), 'date-time'),
      'dtstart',
    ),
    duration: required(
      duration(childAttr(eventSignal, 'duration'), 'duration'),
      'duration',
    ),
    baselineId: required(childAttr(eventSignal, 'baselineID'), 'baselineID'),
    baselineName: required(
      childAttr(eventSignal, 'baselineName'),
      'baselineName',
    ),
  };

  const intervals = eventSignal['intervals'][0]['$$'];
  if (intervals) {
    result.intervals = parseEventSignalIntervals(intervals['interval']);
  }

  const itemBase = parseItemBase(eventSignal);
  if (itemBase != null) result.itemBase = itemBase;

  return result;
}

function serializeEventBaseline(eventBaseline) {
  const result = fragment();
  const eiEventBaseline = result.ele(energyInteropNs, 'ei:eiEventBaseline');
  eiEventBaseline
    .ele(energyInteropNs, 'ei:baselineID')
    .txt(eventBaseline.baselineId);
  eiEventBaseline
    .ele(energyInteropNs, 'ei:baselineName')
    .txt(eventBaseline.baselineName);

  if (eventBaseline.duration) {
    eiEventBaseline
      .ele(calendarNs, 'cal:duration')
      .import(serializeDuration(eventBaseline.duration));
  }

  if (eventBaseline.startDate) {
    eiEventBaseline
      .ele(calendarNs, 'cal:dtstart')
      .import(serializeDateTime(eventBaseline.startDate));
  }

  const intervals = eiEventBaseline.ele(calendarStreamNs, 'strm:intervals');
  serializeEventSignalIntervals(eventBaseline.intervals).forEach(interval =>
    intervals.import(interval),
  );

  if (eventBaseline.itemBase != null) {
    eiEventBaseline.import(serializeItemBase(eventBaseline.itemBase));
  }

  return result;
}

function parseEiEventSignals(eiEventSignals) {
  const wrappedEventSignals = eiEventSignals.eiEventSignal;
  const wrappedBaselines = eiEventSignals.eiEventBaseline;

  const result = {};

  if (wrappedEventSignals) {
    result.event = wrappedEventSignals.map(x => parseEventSignal(x['$$']));
  }

  if (wrappedBaselines) {
    result.baseline = wrappedBaselines.map(x => parseEventBaseline(x['$$']))[0];
  }

  return result;
}

function serializeEiEventSignals(eiEventSignals) {
  const eventSignals = eiEventSignals.event.map(x => serializeEventSignal(x));
  if (eiEventSignals.baseline) {
    return [...eventSignals, serializeEventBaseline(eiEventSignals.baseline)];
  }
  return eventSignals;
}

function parseEiActivePeriod(activePeriod) {
  const properties = activePeriod['properties'][0]['$$'];
  const result = {
    startDate: required(
      dateTime(childAttr(properties, 'dtstart'), 'date-time'),
      'dtstart',
    ),
    duration: required(
      duration(childAttr(properties, 'duration'), 'duration'),
      'duration',
    ),
  };

  const toleranceTolerateStartAfter = parseToleranceTolerateStartAfter(
    childAttr(properties, 'tolerance'),
  );
  if (toleranceTolerateStartAfter != null) {
    result.toleranceTolerateStartAfter = toleranceTolerateStartAfter;
  }

  const notificationDuration = duration(
    childAttr(properties, 'x-eiNotification'),
    'duration',
  );
  if (notificationDuration != null) {
    result.notificationDuration = notificationDuration;
  }

  const rampUpDuration = duration(
    childAttr(properties, 'x-eiRampUp'),
    'duration',
  );
  if (rampUpDuration != null) {
    result.rampUpDuration = rampUpDuration;
  }

  const recoveryDuration = duration(
    childAttr(properties, 'x-eiRecovery'),
    'duration',
  );
  if (recoveryDuration != null) {
    result.recoveryDuration = recoveryDuration;
  }

  return result;
}

function serializeToleranceTolerateStartAfter(duration) {
  const result = fragment();
  result
    .ele(calendarNs, 'cal:tolerance')
    .ele(calendarNs, 'cal:tolerate')
    .ele(calendarNs, 'cal:startafter')
    .txt(duration);
  return result;
}

function serializeActivePeriod(activePeriod) {
  const result = fragment();

  const activePeriodResult = result.ele(energyInteropNs, 'ei:eiActivePeriod');
  const properties = activePeriodResult.ele(calendarNs, 'cal:properties');
  const components = activePeriodResult.ele(calendarNs, 'cal:components');
  components.att(xsiNs, 'xsi:nil', 'true');

  properties
    .ele(calendarNs, 'cal:dtstart')
    .import(serializeDateTime(activePeriod.startDate))
    .up()
    .ele(calendarNs, 'cal:duration')
    .import(serializeDuration(activePeriod.duration))
    .up();

  if (activePeriod.toleranceTolerateStartAfter) {
    properties.import(
      serializeToleranceTolerateStartAfter(
        activePeriod.toleranceTolerateStartAfter,
      ),
    );
  }

  if (activePeriod.notificationDuration) {
    properties
      .ele(energyInteropNs, 'ei:x-eiNotification')
      .import(serializeDuration(activePeriod.notificationDuration));
  }

  if (activePeriod.rampUpDuration) {
    properties
      .ele(energyInteropNs, 'ei:x-eiRampUp')
      .import(serializeDuration(activePeriod.rampUpDuration));
  }

  if (activePeriod.recoveryDuration) {
    properties
      .ele(energyInteropNs, 'ei:x-eiRecovery')
      .import(serializeDuration(activePeriod.recoveryDuration));
  }

  return result;
}

function parseEiEvent(eiEvent) {
  return {
    eventDescriptor: parseEventDescriptor(eiEvent.eventDescriptor[0]['$$']),
    activePeriod: parseEiActivePeriod(eiEvent.eiActivePeriod[0]['$$']),
    signals: parseEiEventSignals(eiEvent.eiEventSignals[0]['$$']),
    targets: parseEiTarget(eiEvent.eiTarget[0]['$$']),
  };
}

function serializeEiEvent(eiEvent) {
  const result = fragment();

  const eiEventResult = result.ele(energyInteropNs, 'ei:eiEvent');

  eiEventResult.import(serializeEventDescriptor(eiEvent.eventDescriptor));
  eiEventResult.import(serializeActivePeriod(eiEvent.activePeriod));

  const eiEventSignals = eiEventResult.ele(
    energyInteropNs,
    'ei:eiEventSignals',
  );

  serializeEiEventSignals(eiEvent.signals).forEach(signal =>
    eiEventSignals.import(signal),
  );

  if (eiEvent.targets) {
    eiEventResult.import(serializeEiTarget(eiEvent.targets));
  }

  return result;
}

function parseEvents(eventList) {
  const events = [];
  for (const wrappedEvent of eventList) {
    const event = wrappedEvent['$$'];
    const parsedEiEvent = parseEiEvent(event.eiEvent[0]['$$']);
    parsedEiEvent.responseRequired = childAttr(event, 'oadrResponseRequired');
    events.push(parsedEiEvent);
  }
  return events;
}

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

  const result = {
    _type: 'oadrDistributeEvent',
  };

  if (o['eiResponse']) {
    const { code, description, requestId } = parseEiResponse(
      o['eiResponse'][0]['$$'],
    );
    result.responseCode = code;
    result.responseRequestId = requestId;
    if (description != null) result.responseDescription = description;
    if (code < 200 || code >= 300) {
      return result;
    }
  }

  const payloadRequestId = childAttr(o, 'requestID');
  if (payloadRequestId != null) result.requestId = payloadRequestId;

  result.vtnId = required(childAttr(o, 'vtnID'), 'vtnID');

  const events = parseEvents(o['oadrEvent'] || []);

  result.events = events;

  return result;
}

function validate(obj) {
  if (obj.responseCode == null) {
    throw new Error('Missing responseCode');
  }
  if (obj.responseRequestId == null) {
    throw new Error('Missing responseRequestId');
  }
}

function serializeOadrEvent(event) {
  const result = fragment();
  const oadrEvent = result.ele(oadrNs, 'oadr2b:oadrEvent');
  oadrEvent.import(serializeEiEvent(event));
  oadrEvent
    .ele(oadrNs, 'oadr2b:oadrResponseRequired')
    .txt(event.responseRequired);
  return result;
}

function serializeEvents(events) {
  const result = fragment();
  events.forEach(event => {
    result.import(serializeOadrEvent(event));
  });

  return result;
}

function serialize(obj) {
  validate(obj);

  const vtnId =
    obj.vtnId != null
      ? fragment()
          .ele(energyInteropNs, 'ei:vtnID')
          .txt(obj.vtnId)
      : fragment();

  const requestId =
    obj.requestId != null
      ? fragment()
          .ele(energyInteropPayloadsNs, 'pyld:requestID')
          .txt(obj.requestId)
      : fragment();

  const doc = createDoc()
    .ele('@oadr2b', 'oadr2b:oadrPayload')
    .ele('oadr2b:oadrSignedObject')
    .ele('oadr2b:oadrDistributeEvent')
    .att('@ei', 'ei:schemaVersion', '2.0b')
    .import(serializeEiResponse(obj))
    .import(vtnId)
    .import(requestId)
    .import(serializeEvents(obj.events))
    .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['oadrDistributeEvent'] != null;
}

function canSerialize(message) {
  return message._type === 'oadrDistributeEvent';
}

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