@enervance/insight-cim-model 0.0.1

package/src/model/assetinfo/OverheadWireInfo.ts

@@ -0,0 +1,8 @@
+import { WireInfo } from './WireInfo';
+
+export class OverheadWireInfo extends WireInfo {
+
+    constructor(mrid?: string, name?: string, shortName?: string, description?: string){
+        super(mrid, name, shortName, description);
+    }
+}

package/src/model/assetinfo/PowerTransformer2WInfo.ts

@@ -0,0 +1,13 @@
+import { PowerTransformerInfo } from './PowerTransformerInfo';
+
+
+export class PowerTransformer2WInfo extends PowerTransformerInfo {
+
+    ukr: number;
+    pkr: number;
+
+    constructor(mrid?: string, name?: string, shortName?: string, description?: string){
+        super(mrid, name, shortName, description);
+    }
+
+}

package/src/model/assetinfo/PowerTransformer3WInfo.ts

@@ -0,0 +1,18 @@
+import { PowerTransformerInfo } from './PowerTransformerInfo';
+
+export class PowerTransformer3WInfo extends PowerTransformerInfo {
+
+    ukr12: number;
+    pkr12: number;
+
+    ukr13: number;
+    pkr13: number;
+
+    ukr23: number;
+    pkr23: number;
+
+    constructor(mrid?: string, name?: string, shortName?: string, description?: string){
+        super(mrid, name, shortName, description);
+    }
+
+}

package/src/model/assetinfo/PowerTransformerInfo.ts

@@ -0,0 +1,14 @@
+import { AssetInfo } from './AssetInfo';
+import { TransformerEndInfo } from './TransformerEndInfo';
+
+export class PowerTransformerInfo extends AssetInfo {
+
+    pLeer: number;
+    iLeer: number;
+
+    transformerEndInfo: TransformerEndInfo[] = [];
+
+    constructor(mrid?: string, name?: string, shortName?: string, description?: string){
+        super(mrid, name, shortName, description);
+    }
+}

package/src/model/assetinfo/TapChangerInfo.ts

@@ -0,0 +1,60 @@
+import {AssetInfo} from './AssetInfo';
+import {CurrentFlow} from '../domain/CurrentFlow';
+import {Voltage} from "../domain/Voltage";
+import {ApparentPower} from "../domain/ApparentPower";
+import {AngleDegrees} from "../domain/AngleDegrees";
+
+export class TapChangerInfo extends AssetInfo {
+
+    /** Highest possible tap step position, advance from neutral. */
+    highStep: number;
+
+    /** Lowest possible tap step position, retard from neutral. */
+    lowStep: number;
+
+    /** The neutral tap step position for the winding. */
+    neutralStep: number;
+
+    /** Rated Voltage */
+    ratedVoltage: Voltage;
+
+    /** Tap step increment, in per cent of rated voltage, per step position. */
+    stepVoltageIncrement: number;
+
+    /**
+     * Basic Insulation Level (BIL) expressed as the impulse crest voltage of a nominal wave, typically 1.2 X 50 microsecond.
+     * This is a measure of the ability of the insulation to withstand very high voltage surges.
+     */
+    bil: Voltage;
+
+    /** Built-in current transformer primary rating. */
+    ctRating: CurrentFlow;
+
+    /** Built-in current transducer ratio. */
+    ctRatio: number;
+
+    /** Frequency at which the ratings apply. */
+    //frequency: Frequency;
+
+    /** Whether this tap changer has under load tap changing capabilities. */
+    isTcul: boolean;
+
+    /** Voltage at which the winding operates at the neutral tap setting. */
+    neutralU: Voltage;
+
+    /** Built-in voltage transducer ratio. */
+    ptRatio: number;
+
+    /** Rated apparent power. */
+    ratedApparendPower: ApparentPower;
+
+    /** Rated current. */
+    ratedCurrent: CurrentFlow;
+
+    /** Phase shift per step position. */
+    stepPhaseIncrement: AngleDegrees;
+
+    constructor(mrid?: string, name?: string, shortName?: string, description?: string) {
+        super(mrid, name, shortName, description);
+    }
+}

package/src/model/assetinfo/TransformerEndInfo.ts

@@ -0,0 +1,38 @@
+import { AssetInfo } from './AssetInfo';
+import { WindingConnection } from '../wires/WindingConnection';
+import { ApparentPower } from '../domain/ApparentPower';
+import { Voltage } from '../..';
+import { PowerTransformerInfo } from './PowerTransformerInfo';
+import { TapChangerInfo } from "./TapChangerInfo";
+
+
+export class TransformerEndInfo extends AssetInfo {
+
+  connectionKind: WindingConnection;
+  endNumber: number;
+
+  ratedS: ApparentPower;
+  ratedU: Voltage;
+  shortTermS: ApparentPower;
+  tapActiv: boolean;
+
+  /* no longer attributes of the TransformerEndInfo. Now usage of TapChangerInfo
+  tapMin: number;
+  tapMid: number;
+  tapMax: number; */
+  tapChangerInfo: TapChangerInfo;
+
+  uMax: number;
+  uMin: number;
+
+  r: number;
+  x: number;
+  b: number;
+  g: number;
+
+  powerTransformerInfo: PowerTransformerInfo;
+
+  constructor(mrid?: string, name?: string, shortName?: string, description?: string) {
+    super(mrid, name, shortName, description);
+  }
+}

package/src/model/assetinfo/WireInfo.ts

@@ -0,0 +1,22 @@
+import { AssetInfo } from './AssetInfo';
+import { CurrentFlow } from '../domain/CurrentFlow';
+import { ResistancePerLength } from '../domain/ResistancePerLength';
+import { ReactancePerLength } from '../domain/ReactancePerLength';
+import { CapacitancePerLength } from '../domain/CapacitancePerLength';
+
+export class WireInfo extends AssetInfo {
+
+    r1: number;//ResistancePerLength;
+    x1: number;//ReactancePerLength;
+    c1: CapacitancePerLength;
+
+    r0: ResistancePerLength;
+    x0: ReactancePerLength;
+    c0: CapacitancePerLength;
+
+    ratedCurrent: number;//CurrentFlow;
+
+    constructor(mrid?: string, name?: string, shortName?: string, description?: string){
+        super(mrid, name, shortName, description);
+    }
+}

package/src/model/assets/AggregateScore.ts

@@ -0,0 +1,9 @@
+import { IdentifiedObject } from '../..';
+import { AnalyticScore } from './AnalyticScore';
+
+
+export class AggregateScore extends AnalyticScore {
+    constructor(mrid?: string, name?: string, shortName?: string, description?: string){
+        super(mrid, name, shortName, description);
+    }
+}

package/src/model/assets/AnalyticScore.ts

@@ -0,0 +1,41 @@
+import { IConnectivityNode, IdentifiedObject, Model } from '../..';
+import { Asset } from './Asset';
+import { getNumberValue, getValue } from '../../util/utils';
+
+
+export class AnalyticScore extends IdentifiedObject {
+    value: number;
+    asset: Asset;
+    assetUUID: string;
+
+    constructor(mrid?: string, name?: string, shortName?: string, description?: string){
+        super(mrid, name, shortName, description);
+    }
+
+
+
+    protected resolveAttributesFusekiJSON(value: any){
+        super.resolveAttributesFusekiJSON(value);
+        this.value = +getNumberValue(value, 'value');
+        this.assetUUID = getValue(value, 'assetUUID')
+    }
+
+    public resolveParsedAssociations(cimModel: Model){
+        super.resolveParsedAssociations(cimModel);
+        // Asset
+        this.asset = cimModel.getObject(this.assetUUID) as Asset;
+        if(this.asset) this.asset.addAnalyticScore(this);
+        else console.log(this.constructor.name + ' ' + this.mrid + ' hat keine Asset-Instanz ' + this.assetUUID);
+    }
+
+    setAsset(asset: Asset): string {
+        this.asset = asset;
+        asset.addAnalyticScore(this);
+        return this.getAssociationSparqlTriple(this.baseIRI, this.mrid, 'cim', 'AnalyticScore', 'Asset', asset.mrid);
+    }
+
+    setValue(value: number): string {
+        this.value = value;
+        return this.getPropertySparqlTriple(this.baseIRI, this.mrid, 'cim', 'AnalyticScore', 'value', String(this.value));
+    }
+}

package/src/model/assets/Asset.ts

@@ -0,0 +1,164 @@
+import { AssetHealthEvent, ConnectivityNode, IdentifiedObject, Model, PowerSystemResource } from '../..';
+import { AssetContainer } from './AssetContainer';
+import { AssetDeployment } from './AssetDeployment';
+import { FacilityKind } from './FacilityKind';
+import { ActivityRecord } from '../common/ActivityRecord';
+import { AssetOrganisationRole } from './AssetOrganisationRole';
+import { AnalyticScore } from './AnalyticScore';
+import { HealthScore } from './HealthScore';
+
+import { toBoolean } from '../../util/datatype-converter';
+import { getValue, parseCsvLineIntoArray } from '../../util/utils';
+import { LifecycleDate } from './LifecycleDate';
+import { EVImportanceScore } from '../extensions/enervance/assets/EVImportanceScore';
+
+export class Asset extends IdentifiedObject {
+
+  type: string;
+  assetContainer: AssetContainer;
+
+  powerSystemResources: Map<string, PowerSystemResource> = new Map();
+  powerSystemResourcesUUIDs: string[];
+
+  organisationRoles: Map<string, AssetOrganisationRole> = new Map();
+
+  assetDeployment: AssetDeployment;
+
+  facilityKind: FacilityKind;
+  likelihoodOfFailure: number;
+
+  activityRecords: Map<string, ActivityRecord> = new Map();
+  // activityRecordsUUIDs: string[] = [];
+
+  analyticScores: Map<string, AnalyticScore> = new Map();
+  analyticScoresUUIDs: string[] = [];
+
+  lifecycleDate: LifecycleDate;
+
+
+  constructor(mrid?: string, name?: string, shortName?: string, description?: string) {
+    super(mrid, name, shortName, description);
+
+    this.prop2namespacePrefix.set('psrType', 'cim'); // zur Generierung der Insert-Statements
+    this.prop2Class.set('psrType', 'PowerSystemResource');
+    this.prop2Datatype.set('psrType', 'PSRType');
+    this.property2type.set('psrType', 'association');
+
+    this.prop2namespacePrefix.set('type', 'cim'); // zur Generierung der Insert-Statements
+    this.prop2Class.set('type', 'Asset');
+    this.prop2Datatype.set('type', 'string');
+    this.property2type.set('type', 'property');
+  }
+
+  addPowerSystemResource(psr: PowerSystemResource) {
+    this.powerSystemResources.set(psr.mrid, psr);
+  }
+
+  addAnalyticScore(analyticScore: AnalyticScore) {
+    this.analyticScores.set(analyticScore.mrid, analyticScore);
+  }
+
+  getHealthScore(): HealthScore | undefined {
+    for (const score of this.analyticScores.values()) {
+      if (score instanceof HealthScore) {
+        return score;
+      }
+    }
+    return;
+  }
+
+  getImportanceScore(): EVImportanceScore | undefined {
+    for (const score of this.analyticScores.values()) {
+      if (score instanceof EVImportanceScore) {
+        return score;
+      }
+    }
+    return;
+  }
+
+  // JSON
+  protected resolveAttributesFusekiJSON(value: any) {
+    super.resolveAttributesFusekiJSON(value);
+    this.lifecycleDate = new LifecycleDate();
+    this.lifecycleDate.resolveClassFusekiJSON(value);
+    this.powerSystemResourcesUUIDs = parseCsvLineIntoArray(getValue(value, 'powerSystemResourceUUIDs'), ',');
+    this.type = getValue(value, 'type');
+  }
+
+  public resolveParsedAssociations(cimModel: Model) {
+    super.resolveParsedAssociations(cimModel);
+    /** assets parsen */
+    for (const psrUUID of this.powerSystemResourcesUUIDs) {
+      const psr = cimModel.getObject(psrUUID);
+      if (psr) {
+        if (psr instanceof PowerSystemResource) {
+          this.powerSystemResources.set(psr.mrid, psr);
+          psr.addAsset(this);
+        }
+      }
+    }
+    this.powerSystemResourcesUUIDs = [];
+  }
+
+  addActivityRecord(activityRecord: ActivityRecord): string {
+    if (!this.activityRecords.has(activityRecord.mrid)) {
+      this.activityRecords.set(activityRecord.mrid, activityRecord);
+      // return this.createSPARQLStatement('cim', 'Asset', 'ActivityRecords', activityRecord.mrid, false);
+    }
+    return '';
+  }
+
+  removeActivityRecord(delRecord: ActivityRecord): string {
+    if (this.activityRecords.has(delRecord.mrid)) {
+      this.activityRecords.delete(delRecord.mrid);
+      // return this.createSPARQLStatement('cim', 'Asset', 'ActivityRecords', delRecord.mrid, false);
+      // return `<${this.baseIRI}${this.mrid}> cim:Asset.ActivityRecords <${this.baseIRI}${delRecord.mrid}> . `;
+    }
+    return '';
+  }
+
+  addAssetOrganisationRole(assetOrganisationRole: AssetOrganisationRole): string {
+    if (!this.organisationRoles.has(assetOrganisationRole.mrid)) {
+      this.organisationRoles.set(assetOrganisationRole.mrid, assetOrganisationRole);
+      // return this.createSPARQLStatement('cim', 'Asset', 'ActivityRecords', activityRecord.mrid, false);
+    }
+    return '';
+  }
+
+  removeAssetOrganisationRole(delOrganisationRole: AssetOrganisationRole): string {
+    if (this.organisationRoles.has(delOrganisationRole.mrid)) {
+      this.organisationRoles.delete(delOrganisationRole.mrid);
+      // return this.createSPARQLStatement('cim', 'Asset', 'OrganisationRoles', delOrganisationRole.mrid, false);
+      // return `<${this.baseIRI}${this.mrid}> cim:Asset.ActivityRecords <${this.baseIRI}${delRecord.mrid}> . `;
+    }
+    return '';
+  }
+
+
+  public toJSONAttributes() {
+    super.toJSONAttributes();
+  }
+
+  public toJSONAssociations() {
+    super.toJSONAssociations();
+
+    /*        const activityrecordUUIDs = []
+            for (const activityrecord of this.activityRecords.values()) {
+                if (activityrecord instanceof AssetHealthEvent) {
+                    activityrecordUUIDs.push(activityrecord.mrid);
+                }
+            }*/
+    const psrUUIDs = []
+    for (const psr of this.powerSystemResources.values()) {
+      psrUUIDs.push(psr.mrid);
+    }
+
+    //this.json['healtheventUUIDs'] = activityrecordUUIDs;
+    this.json['psrUUIDs'] = psrUUIDs;
+  }
+
+  setType(type: string): string {
+    this.type = type;
+    return this.getPropertySparqlTriple(this.baseIRI, this.mrid, 'cim', 'Asset', 'type', this.type);
+  }
+}

package/src/model/assets/AssetContainer.ts

@@ -0,0 +1,11 @@
+import { Asset } from './Asset';
+
+export class AssetContainer extends Asset {
+
+    assets: Map<string, Asset>;
+
+    protected constructor(mrid?: string, name?: string, shortName?: string, description?: string){
+        super(mrid, name, shortName, description);
+        this.assets = new Map();
+    }
+}

package/src/model/assets/AssetDeployment.ts

@@ -0,0 +1,122 @@
+import { BaseVoltage, IdentifiedObject, Model, NS_PREFIX_CIM, NS_PREFIX_RDF } from '../..';
+import { Asset } from './Asset';
+import { DeploymentDate } from './DeploymentDate';
+import { DeploymentStateKind } from './DeploymentStateKind';
+import { TransformerApplicationKind } from './TransformerApplicationKind';
+import { toBoolean } from '../../util/datatype-converter';
+import { getValue } from '../../util/utils';
+
+
+export class AssetDeployment extends IdentifiedObject {
+
+    deploymentDate: DeploymentDate;
+    deploymentState: DeploymentStateKind;
+    transformerApplication: TransformerApplicationKind;
+
+    asset: Asset;
+    assetUUID: string;
+
+    baseVoltage: BaseVoltage;
+    baseVoltageUUID: string;
+
+    protected constructor(mrid?: string, name?: string, shortName?: string, description?: string){
+        super(mrid, name, shortName, description);
+    }
+
+    public static sparqlQuery: string = `
+        PREFIX cim:         <http://iec.ch/TC57/2013/CIM-schema-cim16#> 
+        PREFIX enervance:   <http://enervance.com/CIM/Extensions#> 
+        PREFIX entsoe:      <http://entsoe.eu/CIM/SchemaExtension/3/1#> 
+        PREFIX rdf:         <http://www.w3.org/1999/02/22-rdf-syntax-ns#> 
+        PREFIX apf:         <http://jena.hpl.hp.com/ARQ/property#>
+        PREFIX afn:         <http://jena.apache.org/ARQ/function#>
+        
+        SELECT  (STRAFTER(str(?adUUID), '#_') AS ?uuid)  
+        (CONCAT(STRBEFORE(str(?adUUID), '#_'), '#_') AS ?baseIRI) 
+        (STRAFTER(str(?aUUID), '#_') AS ?assetUUID)
+        (STRAFTER(STRAFTER(str(?deplState), '#'), '.') AS ?deploymentState) 
+        ?installedDate ?inServiceDate 
+        WHERE { 
+            GRAPH <http://default/>{
+                ?adUUID rdf:type cim:AssetDeployment .
+                OPTIONAL {?adUUID cim:AssetDeployment.deploymentDate [ cim:DeploymentDate.installedDate ?installedDate ] .}
+                OPTIONAL {?adUUID cim:AssetDeployment.deploymentDate [ cim:DeploymentDate.inServiceDate ?inServiceDate] .}
+                OPTIONAL {?adUUID cim:AssetDeployment.deploymentState ?deplState }
+                OPTIONAL {?adUUID cim:AssetDeployment.Asset ?aUUID . }
+            }
+        }
+    `;
+    public static getQuerySPARQL(graphURI : string) : string{
+        if(graphURI.length > 0){
+            return AssetDeployment.sparqlQuery.replace('<http://default/>', graphURI);
+        }
+        return AssetDeployment.sparqlQuery;
+    }
+
+    public static resolveClassFusekiJSON(data: any, cimModel: Model){
+        data.results.bindings.forEach((value: any) => {
+            const newClass = new AssetDeployment();
+            newClass.resolveAttributesFusekiJSON(value);
+            cimModel.addAssetDeployment(newClass);
+        });
+    }
+
+    protected resolveAttributesFusekiJSON(value: any){
+        super.resolveAttributesFusekiJSON(value);
+        this.assetUUID = getValue(value, 'assetUUID');
+        deploymentState: DeploymentStateKind[getValue(value, 'deploymentState')];
+/*        // Compound ?inServiceDate
+           not needed
+        this.deploymentDate = new DeploymentDate();
+        this.deploymentDate.resolveClassFusekiJSON(value);*/
+    }
+
+    public resolveParsedAssociations(cimModel: Model) {
+        super.resolveParsedAssociations(cimModel);
+        //connectivityNode
+        this.asset = cimModel.getObject(this.assetUUID) as Asset;
+        if(this.asset) this.asset.assetDeployment = this;
+        else console.log(this.constructor.name + ' ' + this.mrid + ' hat keine Assetinstanz ' + this.assetUUID);
+    }
+
+    /** die Methode gibt basierend auf der aktuellen Ausprägung des übergebenen Property
+     * ein SPARQL-INSERT Statement zurück.
+     * 2 Szearien:
+     *      Löschen der aktuellen Ausprägung -> wird im DELETE DATA Block platziert.
+     *      Einfügen der aktuellen Ausprägung -> wird im INSERT DATA Block platziert. */
+    public getUpdateSPARQL(className: string, propName: string): string  {
+        if(this.constructor.name === className) {
+            const propValue = String(this[propName]); // aktuelle Ausprägung auslesen
+
+            const propNS = this.prop2namespacePrefix.get(String(propName));
+            const propClassName = this.prop2Class.get(String(propName));
+            if(propNS) {
+                return `<${this.baseIRI}${this.mrid}> ${propNS}:${propClassName}.${propName} \'${propValue}\' . `;
+            }
+        }
+        return;
+    }
+
+    public getInsertNewSPARQL(baseIRI: string, graphURI: string): string {
+
+        const insertStatement = `
+            ${NS_PREFIX_RDF}
+            ${NS_PREFIX_CIM}
+             INSERT DATA
+             {
+                GRAPH ${graphURI}
+                {
+                   <${baseIRI}${this.mrid}>
+                    a   cim:AssetDeployment ;
+                        cim:AssetDeployment.deploymentDate 
+                        [
+                            a   cim:DeploymentDate ;
+                            cim:DeploymentDate.inServiceDate '' ;
+                            cim:DeploymentDate.installedDate '' 
+                        ] .
+                }
+             }
+        `;
+        return insertStatement;
+    }
+}

package/src/model/assets/AssetHealthEvent.ts

@@ -0,0 +1,73 @@
+import { ActivityRecord } from '../common/ActivityRecord';
+import { Model } from '../..';
+import { toBoolean } from '../../util/datatype-converter';
+import { getValue } from '../../util/utils';
+
+export class AssetHealthEvent extends ActivityRecord {
+    
+    protected constructor(mrid?: string, name?: string, shortName?: string, description?: string){
+        super(mrid, name, shortName, description);
+    }
+
+
+
+    public static sparqlQuery : string = `
+        PREFIX cim:         <http://iec.ch/TC57/2013/CIM-schema-cim16#> 
+        PREFIX enervance:   <http://enervance.com/CIM/Extensions#> 
+        PREFIX entsoe:      <http://entsoe.eu/CIM/SchemaExtension/3/1#> 
+        PREFIX rdf:         <http://www.w3.org/1999/02/22-rdf-syntax-ns#> 
+        PREFIX amp:         <http://amprion.net/2018/cim_extensions#> 
+        PREFIX apf:         <http://jena.hpl.hp.com/ARQ/property#>
+        PREFIX afn:         <http://jena.apache.org/ARQ/function#>
+        
+        SELECT  (STRAFTER(str(?asUUID), '#_') AS ?uuid)
+        (CONCAT(STRBEFORE(str(?asUUID), '#_'), '#_') AS ?baseIRI) 
+        ?name ?description ?severity ?type
+        (group_concat(STRAFTER(str(?aUUIDs), '#_');separator=',') as ?assetUUIDs)
+        
+        WHERE { 
+          GRAPH<http://default/> {
+            ?asUUID rdf:type cim:AssetHealthEvent .
+            OPTIONAL { ?asUUID cim:IdentifiedObject.name ?name .}
+            OPTIONAL { ?asUUID cim:IdentifiedObject.description ?description .}
+            OPTIONAL { ?asUUID cim:ActivityRecord.severity ?severity .}
+            OPTIONAL { ?asUUID cim:ActivityRecord.type ?type .}
+            OPTIONAL { ?asUUID cim:ActivityRecord.Assets ?aUUIDs .}
+          }
+        }
+        GROUP BY ?asUUID ?baseIRI ?name ?description ?severity ?type 
+    `;
+
+    /** SPARQL/JSON */
+    public static getQuerySPARQL(graphURI : string) : string{
+        if(graphURI.length > 0){
+            return AssetHealthEvent.sparqlQuery.replace('<http://default/>', graphURI);
+        }
+        return AssetHealthEvent.sparqlQuery;
+    }
+
+    public static resolveClassFusekiJSON(data: any, cimModel: Model){
+        data.results.bindings.forEach((value: any) => {
+            const newClass = new AssetHealthEvent();
+            newClass.resolveAttributesFusekiJSON(value);
+            cimModel.addAssetHealthEvent(newClass);
+        });
+    }
+    protected resolveAttributesFusekiJSON(value: any){
+        super.resolveAttributesFusekiJSON(value);
+    }
+
+    public toJSON(){
+        super.toJSON();
+        this.toJSONAttributes();
+        this.toJSONAssociations();
+        return this.json;
+    }
+
+    public toJSONAttributes(){
+        super.toJSONAttributes();
+    }
+    public toJSONAssociations(){
+        super.toJSONAssociations();
+    }
+}

package/src/model/assets/AssetOrganisationRole.ts

@@ -0,0 +1,51 @@
+import { OrganisationRole } from '../common/OrganisationRole';
+import { Asset } from './Asset';
+import { getValue, parseCsvLineIntoArray } from '../../util/utils';
+import { Model } from '../..';
+
+export class AssetOrganisationRole extends OrganisationRole {
+
+  assets: Map<string, Asset> = new Map(); // für Parser
+  assetUUIDs: string[] = [];
+
+  protected constructor(mrid?: string, name?: string, shortName?: string, description?: string) {
+    super(mrid, name, shortName, description);
+  }
+
+  protected resolveAttributesFusekiJSON(value: any) {
+    super.resolveAttributesFusekiJSON(value);
+    this.assetUUIDs = parseCsvLineIntoArray(getValue(value, 'assetUUIDs'), ',');
+  }
+
+  public resolveParsedAssociations(cimModel: Model) {
+    super.resolveParsedAssociations(cimModel);
+    /** assets parsen */
+    for (const assetUUID of this.assetUUIDs) {
+      const asset = cimModel.getObject(assetUUID) as Asset;
+      if (asset) {
+        this.assets.set(asset.mrid, asset);
+        asset.addAssetOrganisationRole(this);
+      }
+    }
+    this.assetUUIDs = [];
+  }
+
+  addAsset(asset: Asset): string {
+    if (!this.assets.has(asset.mrid)) {
+      this.assets.set(asset.mrid, asset);
+      return this.getAssociationSparqlTriple(this.baseIRI, this.mrid, 'cim', 'AssetOrganisationRole', 'Assets', asset.mrid);
+      // return this.createSPARQLStatement('cim', 'AssetOrganisationRole', 'Assets', asset.mrid, false);
+      // return `<${this.baseIRI}${this.mrid}> cim:ActivityRecord.Assets <${this.baseIRI}${assets.mrid}> . `;
+    }
+    return '';
+  }
+
+  removeAsset(delAsset: Asset): string {
+    if (this.assets.has(delAsset.mrid)) {
+      this.assets.delete(delAsset.mrid);
+      return this.getAssociationSparqlTriple(this.baseIRI, this.mrid, 'cim', 'AssetOrganisationRole', 'Assets', delAsset.mrid);
+      // return this.createSPARQLStatement('cim', 'AssetOrganisationRole', 'Assets', delAsset.mrid, false);
+    }
+    return '';
+  }
+}