Converters between server and map models

src/app/cartography/converters/converter.ts

@@ -0,0 +1,3 @@
+export interface Converter<F, T> {
+    convert(obj: F): T;
+}

src/app/cartography/converters/map/drawing-to-map-drawing-converter.ts

@@ -0,0 +1,24 @@
+import { Injectable } from "@angular/core";
+
+import { Converter } from "./converter";
+import { Drawing } from "../models/drawing";
+import { MapDrawing } from "../models/map/map-drawing";
+
+
+@Injectable()
+export class DrawingToMapDrawingConverter implements Converter<Drawing, MapDrawing> {
+    constructor(
+    ) {}
+    
+    convert(drawing: Drawing) {
+        const mapDrawing = new MapDrawing();
+        mapDrawing.id = drawing.drawing_id;
+        mapDrawing.projectId = drawing.project_id;
+        mapDrawing.rotation = drawing.rotation;
+        mapDrawing.svg = drawing.svg;
+        mapDrawing.x = drawing.x;
+        mapDrawing.y = drawing.y;
+        mapDrawing.z = drawing.z;
+        return mapDrawing;
+    }
+}

src/app/cartography/converters/map/label-to-map-label-converter.ts

@@ -0,0 +1,19 @@
+import { Injectable } from "@angular/core";
+
+import { Converter } from "./converter";
+import { Label } from "../models/label";
+import { MapLabel } from "../models/map/map-label";
+
+
+@Injectable()
+export class LabelToMapLabelConverter implements Converter<Label, MapLabel> {
+    convert(label: Label) {
+        const mapLabel = new MapLabel();
+        mapLabel.rotation = label.rotation;
+        mapLabel.style = label.style;
+        mapLabel.text = label.text;
+        mapLabel.x = label.x;
+        mapLabel.y = label.y;
+        return mapLabel;
+    }
+}

src/app/cartography/converters/map/link-node-to-map-link-node-converter.ts

@@ -0,0 +1,23 @@
+import { Injectable } from "@angular/core";
+
+import { Converter } from "./converter";
+import { LinkNode } from "../../models/link-node";
+import { MapLinkNode } from "../models/map/map-link-node";
+import { LabelToMapLabelConverter } from "./label-to-map-label-converter";
+
+
+@Injectable()
+export class LinkNodeToMapLinkNodeConverter implements Converter<LinkNode, MapLinkNode> {
+    constructor(
+        private labelToMapLabel: LabelToMapLabelConverter
+    ) {}
+    
+    convert(linkNode: LinkNode) {
+        const mapLinkNode = new MapLinkNode();
+        mapLinkNode.nodeId = linkNode.node_id;
+        mapLinkNode.adapterNumber = linkNode.adapter_number;
+        mapLinkNode.portNumber = linkNode.port_number;
+        mapLinkNode.label = this.labelToMapLabel.convert(linkNode.label);
+        return mapLinkNode;
+    }
+}

src/app/cartography/converters/map/link-to-map-link-converter.ts

@@ -0,0 +1,26 @@
+import { Injectable } from "@angular/core";
+
+import { Converter } from "./converter";
+import { MapLink } from "../models/map/map-link";
+import { Link } from "../../models/link";
+import { LinkNodeToMapLinkNodeConverter } from "./link-node-to-map-link-node-converter";
+
+
+@Injectable()
+export class LinkToMapLinkConverter implements Converter<Link, MapLink> {
+    constructor(
+        private linkNodeToMapLinkNode: LinkNodeToMapLinkNodeConverter
+    ) {}
+    
+    convert(link: Link) {
+        const mapLink = new MapLink();
+        mapLink.id = link.link_id;
+        mapLink.captureFileName = link.capture_file_name;
+        mapLink.captureFilePath = link.capture_file_path;
+        mapLink.capturing = link.capturing;
+        mapLink.linkType = link.link_type;
+        mapLink.nodes = link.nodes.map((linkNode) => this.linkNodeToMapLinkNode.convert(linkNode));
+        mapLink.projectId = link.project_id;
+        return mapLink;
+    }
+}

src/app/cartography/converters/map/map-drawing-to-drawing-converter.ts

@@ -0,0 +1,24 @@
+import { Injectable } from "@angular/core";
+
+import { Converter } from "./converter";
+import { Drawing } from "../models/drawing";
+import { MapDrawing } from "../models/map/map-drawing";
+
+
+@Injectable()
+export class MapDrawingToDrawingConverter implements Converter<MapDrawing, Drawing> {
+    constructor(
+    ) {}
+    
+    convert(mapDrawing: MapDrawing) {
+        const drawing = new Drawing();
+        drawing.drawing_id = mapDrawing.id;
+        drawing.project_id = mapDrawing.projectId;
+        drawing.rotation = mapDrawing.rotation;
+        drawing.svg = mapDrawing.svg;
+        drawing.x = mapDrawing.x;
+        drawing.y = mapDrawing.y;
+        drawing.z = mapDrawing.z;
+        return drawing;
+    }
+}

src/app/cartography/converters/map/map-label-to-label-converter.ts

@@ -0,0 +1,19 @@
+import { Injectable } from "@angular/core";
+
+import { Converter } from "./converter";
+import { Label } from "../models/label";
+import { MapLabel } from "../models/map/map-label";
+
+
+@Injectable()
+export class MapLabelToLabelConverter implements Converter<MapLabel, Label> {
+    convert(mapLabel: MapLabel) {
+        const label = new Label();
+        label.rotation = mapLabel.rotation;
+        label.style = mapLabel.style;
+        label.text = mapLabel.text;
+        label.x = mapLabel.x;
+        label.y = mapLabel.y;
+        return label;
+    }
+}

src/app/cartography/converters/map/map-link-node-to-link-node-converter.ts

@@ -0,0 +1,23 @@
+import { Injectable } from "@angular/core";
+
+import { Converter } from "./converter";
+import { LinkNode } from "../../models/link-node";
+import { MapLinkNode } from "../models/map/map-link-node";
+import { MapLabelToLabelConverter } from "./map-label-to-label-converter";
+
+
+@Injectable()
+export class MapLinkNodeToLinkNodeConverter implements Converter<MapLinkNode, LinkNode> {
+    constructor(
+        private mapLabelToLabel: MapLabelToLabelConverter
+    ) {}
+    
+    convert(mapLinkNode: MapLinkNode) {
+        const linkNode = new LinkNode();
+        linkNode.node_id = mapLinkNode.nodeId;
+        linkNode.adapter_number = mapLinkNode.adapterNumber;
+        linkNode.port_number = mapLinkNode.portNumber;
+        linkNode.label = this.mapLabelToLabel.convert(mapLinkNode.label);
+        return linkNode;
+    }
+}

src/app/cartography/converters/map/map-link-to-link-converter.ts

@@ -0,0 +1,26 @@
+import { Injectable } from "@angular/core";
+
+import { Converter } from "./converter";
+import { MapLink } from "../models/map/map-link";
+import { Link } from "../../models/link";
+import { MapLinkNodeToLinkNodeConverter } from "./map-link-node-to-link-node-converter";
+
+
+@Injectable()
+export class MapLinkToLinkConverter implements Converter<MapLink, Link> {
+    constructor(
+        private mapLinkNodeToMapLinkNode: MapLinkNodeToLinkNodeConverter
+    ) {}
+
+    convert(mapLink: MapLink) {
+        const link = new Link();
+        link.link_id = mapLink.id;
+        link.capture_file_name = mapLink.captureFileName;
+        link.capture_file_path = mapLink.captureFilePath;
+        link.capturing = mapLink.capturing;
+        link.link_type = mapLink.linkType;
+        link.nodes = mapLink.nodes.map((mapLinkNode) => this.mapLinkNodeToMapLinkNode.convert(mapLinkNode));
+        link.project_id = mapLink.projectId;
+        return link;
+    }
+}

src/app/cartography/converters/map/map-node-to-node-converter.1.ts

@@ -0,0 +1,42 @@
+import { Injectable } from "@angular/core";
+
+import { Converter } from "./converter";
+import { MapNode } from "../models/map/map-node";
+import { Node } from "../models/node";
+import { MapLabelToLabelConverter } from "./map-label-to-label-converter";
+import { MapPortToPortConverter } from "./map-port-to-port-converter";
+
+
+@Injectable()
+export class MapNodeToNodeConverter implements Converter<MapNode, Node> {
+    constructor(
+        private mapLabelToLabel: MapLabelToLabelConverter,
+        private mapPortToPort: MapPortToPortConverter
+    ) {}
+    
+    convert(mapNode: MapNode) {
+        const node = new Node();
+        node.node_id = mapNode.id;
+        node.command_line = mapNode.commandLine;
+        node.compute_id = mapNode.computeId;
+        node.console = mapNode.console;
+        node.console_host = mapNode.consoleHost;
+        node.first_port_name = mapNode.firstPortName;
+        node.height = mapNode.height;
+        node.label = this.mapLabelToLabel.convert(mapNode.label);
+        node.name = mapNode.name;
+        node.node_directory = mapNode.nodeDirectory;
+        node.node_type = mapNode.nodeType;
+        node.port_name_format = mapNode.portNameFormat;
+        node.port_segment_size = mapNode.portSegmentSize;
+        node.ports = mapNode.ports.map((mapPort) => this.mapPortToPort.convert(mapPort));
+        node.project_id = mapNode.projectId;
+        node.status = mapNode.status;
+        node.symbol = mapNode.symbol;
+        node.width = mapNode.width;
+        node.x = mapNode.x;
+        node.y = mapNode.y;
+        node.z = mapNode.z;
+        return node;
+    }
+}

src/app/cartography/converters/map/map-port-to-port-converter.ts

@@ -0,0 +1,19 @@
+import { Injectable } from "@angular/core";
+
+import { Converter } from "./converter";
+import { MapPort } from "../models/map/map-port";
+import { Port } from "../../models/port";
+
+
+@Injectable()
+export class MapPortToPortConverter implements Converter<MapPort, Port> {
+    convert(mapPort: MapPort) {
+        const port = new Port();
+        port.adapter_number = mapPort.adapterNumber;
+        port.link_type = mapPort.linkType;
+        port.name = mapPort.name;
+        port.port_number = mapPort.portNumber;
+        port.short_name = mapPort.shortName;
+        return port;
+    }
+}

src/app/cartography/converters/map/node-to-map-node-converter.ts

@@ -0,0 +1,42 @@
+import { Injectable } from "@angular/core";
+
+import { Converter } from "./converter";
+import { MapNode } from "../models/map/map-node";
+import { Node } from "../models/node";
+import { LabelToMapLabelConverter } from "./label-to-map-label-converter";
+import { PortToMapPortConverter } from "./port-to-map-port-converter";
+
+
+@Injectable()
+export class NodeToMapNodeConverter implements Converter<Node, MapNode> {
+    constructor(
+        private labelToMapLabel: LabelToMapLabelConverter,
+        private portToMapPort: PortToMapPortConverter
+    ) {}
+    
+    convert(node: Node) {
+        const mapNode = new MapNode();
+        mapNode.id = node.node_id;
+        mapNode.commandLine = node.command_line;
+        mapNode.computeId = node.compute_id;
+        mapNode.console = node.console;
+        mapNode.consoleHost = node.console_host;
+        mapNode.firstPortName = node.first_port_name;
+        mapNode.height = node.height;
+        mapNode.label = this.labelToMapLabel.convert(node.label);
+        mapNode.name = node.name;
+        mapNode.nodeDirectory = node.node_directory;
+        mapNode.nodeType = node.node_type;
+        mapNode.portNameFormat = node.port_name_format;
+        mapNode.portSegmentSize = node.port_segment_size;
+        mapNode.ports = node.ports.map((port) => this.portToMapPort.convert(port));
+        mapNode.projectId = node.project_id;
+        mapNode.status = node.status;
+        mapNode.symbol = node.symbol;
+        mapNode.width = node.width;
+        mapNode.x = node.x;
+        mapNode.y = node.y;
+        mapNode.z = node.z;
+        return mapNode;        
+    }
+}

src/app/cartography/converters/map/port-to-map-port-converter.ts

@@ -0,0 +1,19 @@
+import { Injectable } from "@angular/core";
+
+import { Converter } from "./converter";
+import { MapPort } from "../models/map/map-port";
+import { Port } from "../../models/port";
+
+
+@Injectable()
+export class PortToMapPortConverter implements Converter<Port, MapPort> {
+    convert(port: Port) {
+        const mapPort = new MapPort();
+        mapPort.adapterNumber = port.adapter_number;
+        mapPort.linkType = port.link_type;
+        mapPort.name = port.name;
+        mapPort.portNumber = port.port_number;
+        mapPort.shortName = port.short_name;
+        return mapPort;
+    }
+}

src/app/cartography/models/graph-link.ts

@@ -1,8 +0,0 @@
-export class GraphLink {
-  distance: number; // this is not from server
-  length: number; // this is not from server
-  source: Node; // this is not from server
-  target: Node; // this is not from server
-  x: number; // this is not from server
-  y: number; // this is not from server
-}

src/app/cartography/models/map/map-drawing.ts

@@ -0,0 +1,9 @@
+export class MapDrawing {
+    id: string;
+    projectId: string;
+    rotation: number;
+    svg: string;
+    x: number;
+    y: number;
+    z: number;
+}

src/app/cartography/models/map/map-label.ts

@@ -0,0 +1,8 @@
+export class MapLabel {
+    rotation: number;
+    style: string;
+    text: string;
+    x: number;
+    y: number;
+    isSelected: boolean;
+}

src/app/cartography/models/map/map-link-node.ts

@@ -0,0 +1,8 @@
+import { MapLabel } from "./map-label";
+
+export class MapLinkNode {
+    nodeId: string;
+    adapterNumber: number;
+    portNumber: number;
+    label: MapLabel;
+}

src/app/cartography/models/map/map-link.ts

@@ -0,0 +1,20 @@
+import { MapLinkNode } from "./map-link-node";
+
+export class MapLink {
+    id: string;
+    captureFileName: string;
+    captureFilePath: string;
+    capturing: boolean;
+    linkType: string;
+    nodes: MapLinkNode[];
+    projectId: string;
+
+    distance: number; // this is not from server
+    length: number; // this is not from server
+    source: Node; // this is not from server
+    target: Node; // this is not from server
+
+    isSelected = false; // this is not from server
+    x: number; // this is not from server
+    y: number; // this is not from server
+}

src/app/cartography/models/map/map-node.ts

@@ -0,0 +1,28 @@
+import { MapLabel } from "./map-label";
+import { MapPort } from "./map-port";
+
+export class MapNode {
+    id: string;
+    commandLine: string;
+    computeId: string;
+    console: number;
+    consoleHost: string;
+    consoleType: string;
+    firstPortName: string;
+    height: number;
+    label: MapLabel;
+    name: string;
+    nodeDirectory: string;
+    nodeType: string;
+    portNameFormat: string;
+    portSegmentSize: number;
+    ports: MapPort[];
+    projectId: string;
+    status: string;
+    symbol: string;
+    width: number;
+    x: number;
+    y: number;
+    z: number;
+    isSelected = false;
+}

src/app/cartography/models/map/map-port.ts

@@ -0,0 +1,7 @@
+export class MapPort {
+    adapterNumber: number;
+    linkType: string;
+    name: string;
+    portNumber: number;
+    shortName: string;
+}

src/app/cartography/models/point.ts

@@ -3,4 +3,4 @@ export class Point {
     public x?: number,
     public y?: number
   ) {}
-};
+}