TypeScript cubitt-common.Guid类代码示例

router.get("/projects/:projectid/:version").handler(function (routingContext: RoutingContext): any {
	let response: HttpServerResponse = routingContext.response();
	response.putHeader("content-type", "application/json");
	let projectId: Common.Guid = Common.Guid.parse(routingContext.request().getParam("projectid"));
	if (projectId === null) {
		response.setStatusCode(404).end();
		return;
	}

	let version: number | string;
	if (routingContext.request().getParam("version") === "latest"){
		version = "latest";
	} else {
		version = parseInt(routingContext.request().getParam("version"));
	}

	eb.send("projects.query." + projectId, version, function(res, res_err) {
		if (res_err) {
			console.log("Query message delivery failure! : " + res_err);
			response.setStatusCode(500).end();
		} else {
			response.setStatusCode(200).end(res.body());
		}
	});
});

		it("should correctly process a single command in a transaction", (done) => {
			try {
				subject.BeginTransaction();
				//Valid command
				let com: Commands.Command = new Commands.AddModelCommand(
					Common.Guid.newGuid(),
					Common.Guid.newGuid(),
					Common.Guid.newGuid(),
					Common.Guid.newGuid(),
					"TEST_MODEL",
					{}
				);
				subject.ApplyCommand(com);
				subject.CommitTransaction();
			} catch(e) {
				subject.Rollback();
			}
			done();
		});

router.post("/projects/:projectid").handler(function (routingContext: RoutingContext): any {
	let transaction: any = routingContext.getBodyAsJson();
	let response: HttpServerResponse = routingContext.response();
	response.putHeader("content-type", "application/json");
	let projectId: Common.Guid = Common.Guid.parse(routingContext.request().getParam("projectid"));
	if (projectId === null) {
		response.setStatusCode(404).end();
		return;
	}
	// Check if we have such an Actor with that ID
	// Check if we already have such an project actor
	sd.getClusterWideMap("actors", function (res, res_err) {
		if (res_err !== null) {
			console.log("Failed to obtain actor map: " + res_err);
			response.setStatusCode(500).end();
			return;
		}
		let actors = res;

		actors.get(projectId.toString(), function (res, res_err) {
			if (res_err !== null) {
				console.log("Could not get data from cluster wide map " + res_err);
				response.setStatusCode(500).end();
				return;
			}
			if (res === null) {
				console.log("No actor with id " + projectId + " is known");
				response.setStatusCode(404).end();
				return;
			}
			// Validate postbody
			if (transaction.commands === undefined || transaction.commands === null) {
				response.setStatusCode(400).end(JSON.stringify({ status: 400, data: null, error: "Missing required commands" }));
				return;
			}
			if ((transaction.commands instanceof Array) === false || transaction.commands.length === 0) {
				response.setStatusCode(400).end(JSON.stringify({ status: 400, data: null, error: "commands should be a non-empty Array" }));
				return;
			}
			eb.send("projects.commands." + projectId.toString(), JSON.stringify(routingContext.getBodyAsJson()), function (reply: Message, reply_err: any): any {
				if (reply_err === null) {
					// Write to the response and end it
					let body: any = JSON.parse(reply.body());
					response.setStatusCode(body.status).end(reply.body());
				} else {
					response.setStatusCode(500).end();
				}
			});
		});
	});
});

  public deserialize(jsonObject : Object) : Draw2D {
      var draw2d = new Draw2D();
      var models = jsonObject['models'];

      for (var modelKey in models) {
          var model = models[modelKey];
          var id = Common.Guid.parse(model["id"]);
          var properties = this.propertiesFromJSON(model["properties"]);
          draw2d.addModel(id,properties["type"],properties);
      }

      var nodes = jsonObject['nodes'];
      for (var nodeKey in nodes) {
          var node = nodes[nodeKey];
          var id = Common.Guid.parse(node["id"]);
          var properties = this.propertiesFromJSON(node["properties"]);
          var modelId = Common.Guid.parse(node["neighbours"]["models"]["parent"][0]);
          draw2d.addNode(id,properties["type"],modelId,properties)
      }

      var connectors = jsonObject['connectors'];
      for (var connectorKey in connectors) {
          var connector = connectors[connectorKey];
          var id = Common.Guid.parse(connector["id"]);
          var properties = this.propertiesFromJSON(connector["properties"]);
          var nodeId = Common.Guid.parse(connector["neighbours"]["nodes"]["parent"]["0"]);
          draw2d.addConnector(id,properties['type'], properties, nodeId);
      }

      var edges = jsonObject['edges'];
      for (var edgeKey in edges) {
          var edge = edges[edgeKey];
          var id = Common.Guid.parse(edge["id"]);
          var properties = this.propertiesFromJSON(edge["properties"]);
          var modelId = Common.Guid.parse(edge["neighbours"]["models"]["parent"][0]);
          var startConnector = Common.Guid.parse(edge["neighbours"]["connectors"]["parent"][0]);
          var endConnector = Common.Guid.parse(edge["neighbours"]["connectors"]["parent"][1]);
          draw2d.addEdge(id,properties["type"],modelId,startConnector, endConnector, properties);
      }
      return draw2d;
  }

import http = require('http');
import request = require('request');
import path = require('path');
import {Graph as D2DGraph} from "./Graph";
import {CommandGenerator} from "./CommandGenerator";
import {Draw2D} from "./Draw2D";
import {D2DAbstractElement} from "./D2DAbstractElement"
import {D2DModelElement} from "./D2DModelElement"

let app = express();
let router = express.Router();
let host = "http://185.3.208.201";
let appPort = 12345;
let backendPort = 8080;
let graph = null;
let sessionId: Common.Guid = Common.Guid.parse("cd46e14a-97ca-40e3-81be-ae1c18e7e114");
let cg = null; // CommandGenerator
let d2dGraph;

router.use(bodyParser.json());
router.use(bodyParser.urlencoded({ extended: true }));
routes();
router.use(express.static(__dirname + '/client'));
app.use('/', router);
app.listen(appPort, function () {
  console.log('Running at '+ host +':' + appPort);
});

function routes(){
  router.get( '/', function( req, res ) {
    console.log("sessionId for this session: " + sessionId.toString());

  /**
   * Convert a JSON Draw2D graph object to a Graph
   */
    public serialize(jsGraph: string): Graph {
        let graph = new Graph();
        let json = JSON.parse(jsGraph);

        for(let m in json){
            let model = json[m];
            let modelId = (model.id ? Common.Guid.parse(model.id) : Common.Guid.newGuid());

            this.addModel(modelId, model.type, {});
            let ports : string[] = []; // ports from Draw2D aka connectors for this object

            for(let key in model.elements) {
                let elem = model.elements[key];
                let elemId = elem.id;
                let elemProperties: Object[] = [];
                let connectorsToAdd: {id: Common.Guid, type: string; elemId: Common.Guid, props: Object[]}[] = [];

                switch(elem.type){
                    case "csa.Edge":
                        var startNodeId: Common.Guid = null;
                        var startConnectorId: Common.Guid = null;
                        var endNodeId: Common.Guid = null;
                        var endConnectorId: Common.Guid = null;
                        for(let prop in elem) {
                            let value = elem[prop];
                            if(prop == "source" && elem.hasOwnProperty("source")){
                                startNodeId = Common.Guid.parse(elem.source.node);
                                startConnectorId = Common.Guid.parse(ports[elem.source.port]);
                            }else if(prop == "target" && elem.hasOwnProperty("target")){
                                endNodeId = Common.Guid.parse(elem.target.node);
                                endConnectorId = Common.Guid.parse(elem.target.port.substring(6, elem.target.port.length));
                            }else{
                                elemProperties[prop] = value;
                            }
                        }
                        this.addEdge(elemId, elem.type, modelId, startNodeId, startConnectorId, endNodeId, endConnectorId, elemProperties);
                        break;
                    default:
                        for(let prop in elem) {
                            let value = elem[prop];
                            if(prop == "ports" && elem.hasOwnProperty(prop)){
                                for(let port in value){
                                    // Add connector for each port
                                    let portObject = value[port];
                                    let portProperties: Object[] = [];
                                    for(let portProps in portObject){
                                        portProperties[portProps] = portObject[portProps];
                                    }
                                    let connector = {id: portObject.id, type: portObject.type, elemId: elemId, props: portProperties};
                                    connectorsToAdd.push(connector);
                                    ports[portProperties["name"]] = portObject.id;
                                }
                            }else{
                                elemProperties[prop] = value;
                            }
                        }
                        this.addNode(elemId, elem.type, modelId, elemProperties);
                        let self = this;
                        connectorsToAdd.forEach(function(currentValue, index, arr){ self.addConnector(currentValue.id, currentValue.type, currentValue.elemId, currentValue.props); });
                        break;
                }
            }
        }
        return this;
    }