org.eclipse.mdm.nucleus/org.eclipse.mdm.application/src/main/webapp/src/app/details/services/context.service.ts

/********************************************************************************
 * Copyright (c) 2015-2018 Contributors to the Eclipse Foundation
 *
 * See the NOTICE file(s) distributed with this work for additional
 * information regarding copyright ownership.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 ********************************************************************************/


import {Injectable} from '@angular/core';
import {Http} from '@angular/http';

import {catchError, map} from 'rxjs/operators';

import { Sensor } from '../model/types/sensor';
import { Components } from '../model/types/components';
import {PropertyService} from '@core/property.service';
import {HttpErrorHandler} from '@core/http-error-handler';
import {Node, Attribute} from '@navigator/node';

@Injectable()
export class ContextService {

  private _contextUrl: string;

  private test: {};
  private errorMessage: string;

  constructor(private http: Http,
              private httpErrorHandler: HttpErrorHandler,
              private _prop: PropertyService) {
    this._contextUrl = _prop.getUrl('mdm/environments');
  }

  putContext(node: Node, context: any) {
    let url = this._contextUrl + '/' + node.sourceName;
    url = url + '/' + node.type.toLowerCase() + 's/' + node.id + '/contexts';
    let body = {
      'data': [ context ]
    };
    return this.http.put(url, body).pipe(
      map((res) => {
        let data = res.json().data;
        return this.mergeContextRoots([data[0].ordered, data[0].measured]);
      }),
      catchError(this.httpErrorHandler.handleError));
  }

  getContext(node: Node) {
    let url = this._contextUrl + '/' + node.sourceName;
    url = url + '/' + node.type.toLowerCase() + 's/' + node.id + '/contexts';
    return this.http.get(url).pipe(
      map((res) => {
        let data = res.json().data;
        let context = this.mergeContextRoots([data[0].ordered, data[0].measured]);
        return context;
      }),
      catchError(this.httpErrorHandler.handleError));
  }

  getSensors(node: Node) {
    let url = this._contextUrl + '/' + node.sourceName + '/' + node.type.toLowerCase() + 's/' + node.id + '/contexts/testequipment/sensors';
    return this.http.get(url).pipe(
        map((res) => { return <{}> this.merge(res.json().data); }),
        catchError(this.httpErrorHandler.handleError));
  }

  private merge(sensor: Sensor) {
    let sensorm = sensor[0].sensor_measured;
    let sensoro = sensor[0].sensor_ordered;
    let merge = [];
    sensoro.forEach((node) => {
      let pos = sensorm.map(function(e) { return e.name; }).indexOf(node.name);
      if (pos === -1) {
        merge.push(this.empty_m(node));
      } else {
        merge.push(this.mergeNode(node, sensorm[pos]));
        sensorm.splice(pos, 1);
      }
    });
    sensorm.forEach((node) => {
      merge.push(this.empty_o(node));
    });
    return merge;
  }

  private mergeNode(oNode, mNode) {
    oNode.attributes.forEach((attr, i) => {
      attr.dataType = [attr.dataType, mNode.attributes[i].dataType];
      attr.name = [attr.name, mNode.attributes[i].name];
      attr.unit = [attr.unit, mNode.attributes[i].unit];
      attr.value = [attr.value, mNode.attributes[i].value];
    });
    return oNode;
  }

  private empty_o(node) {
    node.attributes.forEach((attr) => {
      attr.dataType = ['', attr.dataType];
      attr.name = ['', attr.name];
      attr.unit = ['', attr.unit];
      attr.value = ['', attr.value];
    });
    return node;
  }

  private empty_m(node) {
    node.attributes.forEach((attr) => {
      attr.dataType = [attr.dataType, ''];
      attr.name = [attr.name, ''];
      attr.unit = [attr.unit, ''];
      attr.value = [attr.value, ''];
    });
    return node;
  }

  /** Merges several ContextRoots by merging their ContextComponents */
  private mergeContextRoots(contexts) {
    let result: Components = new Components();

    for (let i = 0; i < contexts.length; ++i) {
      for (let contextType in contexts[i]) {
        if (contexts[i].hasOwnProperty(contextType)) {
          result[contextType] = this.mergeComponents(contexts[i][contextType], i, result[contextType]);
        }
      }
    }
    return result;
  }

  /** Merges several ContextComponents by merging their ContextAttributes */
  private mergeComponents(contextComponents: any, contextIndex: number, resultComponents: Node[]) {
    if (!Array.isArray(contextComponents)) {
      return resultComponents;
    }

    let result = resultComponents || [];

    for (let contextComponent of contextComponents) {
      if (!(contextComponent instanceof Object)) { continue; }

      let resultComponent = result.find(cc => cc.name === contextComponent['name']);

      if (!resultComponent) {
        resultComponent = JSON.parse(JSON.stringify(contextComponent));
        resultComponent['attributes'] = [];
        result.push(resultComponent);
      }

      resultComponent['attributes'] = this.mergeAttributes(contextComponent['attributes'], contextIndex, resultComponent['attributes']);
    }
    return result;
  }

  /** Merges a array of ContextAttributes to a MergedContextAttribute
   * and adds it to the given resultAttributes array. Merging the ContextAttributes
   * copies the values of all properties (which should be identical), except the
   * value property. The value property in MergedContextAttribute is an array
   * with all values of the value property from all ContextAttributes.
   */
  private mergeAttributes(attributes: Attribute[], contextIndex: number, resultAttributes: Attribute[]) {
    if (!Array.isArray(attributes)) {
      return resultAttributes;
    }

    let result = resultAttributes || [];

    for (let attribute of attributes) {
      if (!(attribute instanceof Object)) { continue; }

      let resultAttribute = result.find(a => a.name === attribute['name']);

      if (!resultAttribute) {
        resultAttribute = JSON.parse(JSON.stringify(attribute));
        resultAttribute['value'] = [];
        result.push(resultAttribute);
      }
      resultAttribute['value'][contextIndex] = attribute['value'];
    }

    return resultAttributes;
  }
}

// /** Represents a ContextAttribute */
// export class ContextAttribute {
//   name: string;
//   value: string;
//   unit: string;
//   dataType: string;
// }

// /** Represents multiple ContextAttributes with their value properties merged to an array */
// export class MergedContextAttribute {
//   name: string;
//   value: string[];
//   unit: string;
//   dataType: string;
// }

// /** Represents merged ContextComponents */
// export class MergedContextComponent {
//   name: string;
//   id: string;
//   type: string;
//   sourcType: string;
//   sourceName: string;
//   attributes: MergedContextAttribute[];
// }