wwu

Packages/dimseservice/package.js

@@ -15,6 +15,7 @@ Package.onUse(function(api) {
     api.addFiles('server/Data.js', 'server');
     api.addFiles('server/Message.js', 'server');
     api.addFiles('server/PDU.js', 'server');
+    api.addFiles('server/CSocket.js', 'server');
     api.addFiles('server/Connection.js', 'server');
     api.addFiles('server/DIMSE.js', 'server');
 

Packages/dimseservice/server/CSocket.js

@@ -0,0 +1,587 @@
+var EventEmitter = Npm.require('events').EventEmitter;
+
+function time() {
+    return Math.floor(Date.now() / 1000);
+}
+
+function getRandomInt(min, max) {
+  return Math.floor(Math.random() * (max - min)) + min;
+}
+
+var Envelope = function(command, dataset) {
+    EventEmitter.call(this);
+    this.command = command;
+    this.dataset = dataset;
+}
+util.inherits(Envelope, EventEmitter);
+
+CSocket = function(socket, options) {
+    EventEmitter.call(this);
+    this.socket = socket;
+    this.negotiatedContexts = {};
+    this.receiving = null;
+    this.receiveLength = null;
+    this.minRecv = null;    
+    this.lastReceived = null;
+    this.presentationContexts = [];
+    this.associated = false;
+    this.pendingPDVs = null;
+    this.connected = false;
+    this.started = null;    
+    this.intervalId = null;
+    this.lastCommand = null;
+    this.lastSent = null;    
+    this.messages = {};
+    this.messageIdCounter = 0;
+    this.callingAe = null;
+    this.calledAe = null;
+    this.id = getRandomInt(1000, 9999);
+    this.options = options;
+
+    var o = this;
+    this.socket.on("connect", function(){
+        o.ready();
+    });
+    this.socket.on("data", function(data) {
+        o.received(data);
+    });
+    this.socket.on("error", function(he) {
+        console.log("Error: ", he);
+    });
+    this.socket.on("close", function() {
+        if (o.intervalId) {
+            clearInterval(o.intervalId);
+        }
+        o.connected = false;
+        console.log("Connection closed");
+        o.emit('close');        
+    })
+
+    this.on("released", function() {
+        this.released();
+    });
+    this.on('aborted', function() {
+        this.released();
+    })
+    this.on('message', function(pdvs) {
+        this.receivedMessage(pdvs);
+    });    
+};
+util.inherits(CSocket, EventEmitter);
+
+CSocket.prototype.setCallingAE = function(ae) {
+    this.callingAe = ae;
+};
+
+CSocket.prototype.setCalledAe = function(ae) {
+    this.calledAe = ae;
+};
+
+CSocket.prototype.associate = function() {
+    var associateRQ = new AssociateRQ();
+    associateRQ.setCalledAETitle(this.calledAe);
+    associateRQ.setCallingAETitle(this.callingAe);
+    associateRQ.setApplicationContextItem(new ApplicationContextItem());
+
+    var contextItems = []
+    this.presentationContexts.forEach(function(context) {
+      var contextItem = new PresentationContextItem(),
+          syntaxes = [];
+      context.transferSyntaxes.forEach(function(transferSyntax) {
+          var transfer = new TransferSyntaxItem();
+          transfer.setTransferSyntaxName(transferSyntax);
+          syntaxes.push(transfer);
+      });
+      contextItem.setTransferSyntaxesItems(syntaxes);
+      contextItem.setPresentationContextID(context.id);
+
+      var abstractItem = new AbstractSyntaxItem();
+      abstractItem.setAbstractSyntaxName(context.abstractSyntax);
+      contextItem.setAbstractSyntaxItem(abstractItem);
+      contextItems.push(contextItem);
+    });
+    associateRQ.setPresentationContextItems(contextItems);
+
+    var maxLengthItem = new MaximumLengthItem(),
+      classUIDItem = new ImplementationClassUIDItem(),
+      versionItem = new ImplementationVersionNameItem();
+
+    classUIDItem.setImplementationClassUID(C.IMPLEM_UID);
+    versionItem.setImplementationVersionName(C.IMPLEM_VERSION);
+    var packageSize = this.options.maxPackageSize ? this.options.maxPackageSize : C.DEFAULT_MAX_PACKAGE_SIZE;
+    maxLengthItem.setMaximumLengthReceived(packageSize);
+
+    var userInfo = new UserInformationItem();
+    userInfo.setUserDataItems([maxLengthItem, classUIDItem, versionItem]);
+
+    associateRQ.setUserInformationItem(userInfo);
+
+    this.send(associateRQ);
+};
+
+CSocket.prototype.getContext = function(id) {
+    for (var k in this.presentationContexts) {
+        var ctx = this.presentationContexts[k];
+        if (id == ctx.id) return ctx;
+    }
+    return null;
+}
+
+CSocket.prototype.getSyntax = function(contextId) {
+    if (!this.negotiatedContexts[contextId]) return null;
+
+    return this.negotiatedContexts[contextId].transferSyntax;
+}
+
+CSocket.prototype.getContextByUID = function(uid) {
+    for (var k in this.negotiatedContexts) {
+        var ctx = this.negotiatedContexts[k];
+        if (ctx.abstractSyntax == uid) {
+            return ctx;
+        }
+    }
+    return null;
+}
+
+CSocket.prototype.getContextId = function(contextId) {
+    if (!this.negotiatedContexts[contextId]) return null;
+
+    return this.negotiatedContexts[contextId].id;
+}
+
+CSocket.prototype.setPresentationContexts = function(uids) {
+    var contexts = [],
+        id = 0;
+    uids.forEach(function(uid) {
+        contexts.push({
+            id: ++id,
+            abstractSyntax: uid,
+            transferSyntaxes: [C.IMPLICIT_LITTLE_ENDIAN, C.EXPLICIT_LITTLE_ENDIAN, C.EXPLICIT_BIG_ENDIAN]
+        });
+    });
+    this.presentationContexts = contexts;
+};
+
+CSocket.prototype.newMessageId = function() {
+    return (++this.messageIdCounter) % 65536;
+}
+
+CSocket.prototype.resetReceive = function() {
+    this.receiving = this.receiveLength = null;
+};
+
+CSocket.prototype.send = function(pdu, afterCbk) {
+    //console.log('SEND PDU-TYPE: ', pdu.type);
+    var toSend = pdu.buffer();
+    //console.log('send buffer', toSend.toString('hex'));
+    this.socket.write(toSend, afterCbk ? afterCbk : function() {
+        //console.log('Data written');
+    });
+};
+
+CSocket.prototype.release = function() {
+    var releaseRQ = new ReleaseRQ();
+    this.send(releaseRQ);
+};
+
+CSocket.prototype.released = function() {
+    this.socket.end();
+};
+
+CSocket.prototype.ready = function() {
+    console.log("Connection established");
+    this.connected = true;
+    this.started = time();
+
+    var o = this;
+    if (this.options.idle) {
+        this.intervalId = setInterval(function() {
+            o.checkIdle();
+        }, 3000);
+    }
+};
+
+CSocket.prototype.checkIdle = function() {
+    var current = time(),
+        idl = this.options.idle;
+
+    if (!this.lastReceived && (current - this.started >= idl)) {
+        this.idleClose();
+    } else if (this.lastReceived && (current - this.lastReceived >= idl)) {
+        this.idleClose();
+    } else {
+        //console.log('keep idling')
+    }
+};
+
+CSocket.prototype.idleClose = function() {
+    console.log('Exceed idle time, closing connection');
+    this.release();
+};
+
+CSocket.prototype.received = function(data) {
+    var i = 0;
+    do {
+        data = this.process(data);
+    } while (data !== null);
+    this.lastReceived = time();
+};
+
+CSocket.prototype.process = function(data) {
+    //console.log("Data received");
+    if (this.receiving === null) {
+        if (this.minRecv) {
+            data = Buffer.concat([this.minRecv, data], this.minRecv.length + data.length);
+            this.minRecv = null;
+        }
+
+        if (data.length < 6) {
+            this.minRecv = data;
+            return null;
+        }
+
+        var stream = new ReadStream(data);
+        var type = stream.read(C.TYPE_UINT8);
+        stream.increment(1);
+        var len = stream.read(C.TYPE_UINT32),
+            cmp = data.length - 6;
+        if (len > cmp) {
+            this.receiving = data;
+            this.receiveLength = len;
+        } else {
+            var process = data,
+                remaining = null;
+            if (len < cmp) {
+                process = data.slice(0, len + 6);
+                remaining = data.slice(len + 6, cmp + 6);
+            }
+            this.resetReceive();
+            this.interpret(new ReadStream(process), this);
+            if (remaining) {
+                return remaining;
+            }
+        }
+    } else {
+        var newData = Buffer.concat([this.receiving, data], this.receiving.length + data.length),
+            pduLength = newData.length - 6;
+
+        if (pduLength < this.receiveLength) {
+            this.receiving = newData;
+        } else {
+            var remaining = null;
+            if (pduLength > this.receiveLength) {
+                remaining = newData.slice(this.receiveLength + 6, pduLength + 6);
+                newData = newData.slice(0, this.receiveLength + 6);
+            }
+            this.resetReceive();
+            this.interpret(new ReadStream(newData));
+            if (remaining) {
+                return remaining;
+            }
+        }
+    }
+    return null;
+};
+
+CSocket.prototype.interpret = function(stream) {
+    var pdatas = [],
+        size = stream.size(),
+        o = this;
+    while (stream.offset < size) {
+        var pdu = PDU.createByStream(stream);
+        //console.log("Received PDU-TYPE " + PDU.typeToString(pdu.type));
+        if (pdu.is(C.ITEM_TYPE_PDU_ASSOCIATE_AC)) {
+            pdu.presentationContextItems.forEach(function(ctx) {
+                var requested = o.getContext(ctx.presentationContextID);
+                if (!requested) {
+                    throw "Accepted presentation context not found";
+                }
+                o.negotiatedContexts[ctx.presentationContextID] = {
+                    id: ctx.presentationContextID,
+                    transferSyntax: ctx.transferSyntaxesItems[0].transferSyntaxName,
+                    abstractSyntax: requested.abstractSyntax
+                };
+            });
+
+            //console.log('Accepted');
+            this.associated = true;
+            this.emit('associated', pdu);
+        } else if (pdu.is(C.ITEM_TYPE_PDU_ASSOCIATE_RQ)) {
+            var accepd = new AssociateAC();
+
+            pdu.presentationContextItems.forEach(function(ctx) {
+
+            });
+        } else if (pdu.is(C.ITEM_TYPE_PDU_RELEASE_RP)) {
+            //console.log('Released');
+            this.associated = false;
+            this.emit('released');
+        } else if (pdu.is(C.ITEM_TYPE_PDU_AABORT)) {
+            //console.log('Aborted');
+            this.emit('aborted');
+        } else if (pdu.is(C.ITEM_TYPE_PDU_PDATA)) {
+            pdatas.push(pdu);
+        }
+    }
+
+    if (pdatas) {
+        var pdvs = this.pendingPDVs ? this.pendingPDVs : [];
+        pdatas.forEach(function(pdata) {
+            pdvs = pdvs.concat(pdata.presentationDataValueItems);
+        });
+        this.pendingPDVs = null;
+        var i = 0,
+            count = pdvs.length;
+        while (i < count) {
+            if (!pdvs[i].isLast) {
+                var j = i + 1;
+                while (j < count) {
+                    pdvs[i].messageStream.concat(pdvs[j].messageStream);
+                    if (pdvs[j++].isLast) {
+                        pdvs[i].isLast = true;
+                        break;
+                    }
+                }
+                if (pdvs[i].isLast) {
+                    this.emit('message', pdvs[i]);
+                } else {
+                    this.pendingPDVs = [pdvs[i]];
+                }
+                i = j;
+            } else {
+                this.emit('message', pdvs[i++]);
+            }
+        }
+    }
+};
+
+CSocket.prototype.receivedMessage = function(pdv) {
+    var syntax = this.getSyntax(pdv.contextId),
+        msg = DicomMessage.read(pdv.messageStream, pdv.type, syntax, this.options.vr);
+
+    if (msg.isCommand()) {
+        this.lastCommand = msg;
+
+        if (msg.isResponse()) {
+            if (msg.is(C.COMMAND_C_GET_RSP) || msg.is(C.COMMAND_C_MOVE_RSP)) {
+                //console.log('remaining', msg.getNumOfRemainingSubOperations(), msg.getNumOfCompletedSubOperations());
+            }
+            if (msg.failure()) {
+                //console.log("message failed with status ", msg.getStatus().toString(16));
+            }
+            if (msg.isFinal()) {
+                var replyId = msg.respondedTo();
+                if (this.messages[replyId].listener) {
+                    this.messages[replyId].listener.emit('end', msg);
+
+                    if (!msg.haveData())
+                        delete this.messages[replyId];
+                }
+
+                if (msg.is(C.COMMAND_C_GET_RSP)) {
+                    if (!msg.getNumOfRemainingSubOperations()) {
+                        if (this.lastGets && this.lastGets.length > 0) this.lastGets.shift();
+                    }
+                }
+            }
+        } else {
+            /*if (msg.is(0x01)) {
+        console.log('ae title ', msg.getValue(0x00001031))
+      }*/
+        }
+
+    } else {
+        if (!this.lastCommand) {
+            throw "Only dataset?";
+        } else if (!this.lastCommand.haveData()) {
+            throw "Last command didn't indicate presence of data";
+        }
+
+        if (this.lastCommand.isResponse()) {
+            var replyId = this.lastCommand.respondedTo();
+            if (this.messages[replyId].listener) {
+                var flag = this.lastCommand.failure() ? true : false;
+
+                this.messages[replyId].listener.emit("result", msg, flag);
+
+                if (this.lastCommand.failure()) {
+                    delete this.messages[replyId];
+                }
+            }
+        } else {
+            if (this.lastCommand.is(C.COMMAND_C_STORE_RQ)) {
+                var moveMessageId = this.lastCommand.getMoveMessageId(),
+                    useId = moveMessageId;
+                if (!moveMessageId) {
+                    //!! Going to deprecate now
+                    //kinda hacky but we know this c-store is came from a c-get
+                    if (this.lastGets.length > 0) {
+                        useId = this.lastGets[0];
+                    } else {
+                        throw "Where does this c-store came from?";
+                    }
+                } else console.log('move ', moveMessageId);
+                //this.storeResponse(useId, msg);
+            }
+        }
+    }
+};
+
+CSocket.prototype.wrapToPData = function(message, context) {
+    var useContext = message.contextUID ? message.contextUID : context;
+    var ctx = this.getContextByUID(useContext);
+
+    var pdata = new PDataTF(),
+        pdv = new PresentationDataValueItem(ctx.id);
+    pdv.setMessage(message);
+    pdata.setPresentationDataValueItems([pdv]);   
+    return pdata;
+}
+
+CSocket.prototype.sendMessage = function(context, command, dataset) {
+    var nContext = this.getContextByUID(context),
+        syntax = nContext.transferSyntax,
+        cid = nContext.id,
+        messageId = this.newMessageId(),
+        msgData = {};
+
+    msgData.listener = new Envelope(command);
+
+    var o = this;
+    msgData.listener.on('cancel', function(){
+        var cancelMessage = null;
+        if (this.command.is(C.COMMAND_C_FIND_RQ) || this.command.is(C.COMMAND_C_MOVE_RQ)) {
+            cancelMessage = new CCancelRQ();
+
+            cancelMessage.setReplyMessageId(this.command.messageId);
+            cancelMessage.setSyntax(C.IMPLICIT_LITTLE_ENDIAN);
+
+            o.send(o.wrapToPData(cancelMessage, this.command.contextUID));           
+        }
+    });
+
+    command.setSyntax(C.IMPLICIT_LITTLE_ENDIAN);
+    command.setContextId(context);
+    command.setMessageId(messageId);
+    if (dataset)
+        command.setDataSetPresent(C.DATA_SET_PRESENT);
+
+    this.lastSent = command;
+    if (command.is(C.COMMAND_C_GET_RQ)) {
+        this.lastGets.push(messageId);
+    }
+    var pdata = this.wrapToPData(command);
+
+    msgData.command = command;
+    this.messages[messageId] = msgData;
+
+    this.send(pdata);
+    if (dataset) {
+        dataset.setSyntax(syntax);
+        var dsData = new PDataTF(),
+            dPdv = new PresentationDataValueItem(cid);
+
+        dPdv.setMessage(dataset);
+        dsData.setPresentationDataValueItems([dPdv]);
+        this.send(dsData);
+    }
+    return msgData.listener;
+};
+
+CSocket.prototype.verify = function() {
+    this.setPresentationContexts([C.SOP_VERIFICATION]);
+    this.startAssociationRequest(function() {
+        //associated, we can release now
+        this.release();
+    });
+};
+
+CSocket.prototype.wrapMessage = function(data) {
+    if (data) {
+        var datasetMessage = new DataSetMessage();
+        datasetMessage.setElements(data);
+        return datasetMessage;
+    } else return data;
+};
+
+CSocket.prototype.find = function(params, options) {
+    return this.sendMessage(options.context, new CFindRQ(), this.wrapMessage(params));
+};
+
+CSocket.prototype.move = function(destination, params, options) {
+    var moveMessage = new CMoveRQ();
+    moveMessage.setDestination(destination);
+
+    return this.sendMessage(options.context, moveMessage, this.wrapMessage(params));
+};
+
+CSocket.prototype.moveInstances = function(destination, params, options) {
+    var sendParams = Object.assign({
+        0x00080052: C.QUERY_RETRIEVE_LEVEL_IMAGE,
+    }, params);
+    options = Object.assign({
+        context : C.SOP_STUDY_ROOT_MOVE
+    }, options);     
+
+    return this.move(destination, sendParams, options);
+};
+
+CSocket.prototype.findPatients = function(params, options) {
+    var sendParams = Object.assign({
+        0x00080052: C.QUERY_RETRIEVE_LEVEL_PATIENT,
+        0x00100010: "",
+        0x00100020: "",
+        0x00100030: "",
+        0x00100040: "",
+    }, params);
+    options = Object.assign({
+        context : C.SOP_PATIENT_ROOT_FIND
+    }, options);
+
+    return this.find(sendParams, options);
+};
+
+CSocket.prototype.findStudies = function(params, options) {
+    var sendParams = Object.assign({
+        0x00080052: C.QUERY_RETRIEVE_LEVEL_STUDY,
+        0x00080020: "",
+        0x00100010: "",
+        0x00080061: "",
+        0x0020000D: ""
+    }, params);
+    options = Object.assign({
+        context : C.SOP_STUDY_ROOT_FIND
+    }, options);   
+
+    return this.find(sendParams, options);
+};
+
+CSocket.prototype.findSeries = function(params, options) {
+    var sendParams = Object.assign({
+        0x00080052: C.QUERY_RETRIEVE_LEVEL_SERIES,
+        0x00080020: "",
+        0x0020000E: "",
+        0x0008103E: "",
+        0x0020000D: ""
+    }, params);
+    options = Object.assign({
+        context : C.SOP_STUDY_ROOT_FIND
+    }, options);     
+
+    return this.find(sendParams, options);
+};
+
+CSocket.prototype.findInstances = function(params, options) {
+    var sendParams = Object.assign({
+        0x00080052: C.QUERY_RETRIEVE_LEVEL_IMAGE,
+        0x00080020: "",
+        0x0020000E: "",
+        0x0008103E: "",
+        0x0020000D: ""
+    }, params);
+    options = Object.assign({
+        context : C.SOP_STUDY_ROOT_FIND
+    }, options);     
+
+    return this.find(sendParams, options);
+};

Packages/dimseservice/server/Connection.js

@@ -1,462 +1,70 @@
-var EventEmitter = Npm.require('events').EventEmitter;
+var EventEmitter = Npm.require('events').EventEmitter, net = Npm.require('net'), Socket = net.Socket;
-
-function time() {
-    return Math.floor(Date.now() / 1000);
-}
 
 var DEFAULT_MAX_PACKAGE_SIZE = 32768;
-var DEFAULT_SOURCE_AE = 'OHIFDCM';
 
-var Envelope = function(conn, command, dataset) {
+Connection = function(options) {
     EventEmitter.call(this);
-    this.command = command;
-    this.dataset = dataset;
-    this.conn = conn;
-};
-
-util.inherits(Envelope, EventEmitter);
-
-Envelope.prototype.send = function() {
-    return this;
-};
-
-Connection = function(socket, options) {
-    EventEmitter.call(this);
-    this.socket = socket;
     this.options = Object.assign({
-        hostAE: '',
+        maxPackageSize: C.DEFAULT_MAX_PACKAGE_SIZE,
-        sourceAE: 'OHIFDCM',
+        idle: false,
-        maxPackageSize: 32768,
-        idle: 60,
         reconnect: true,
         vr: {
             split: true
         }
     }, options);
 
-    this.connected = false;
+    this.peers = {};
-    this.started = null;
+    this.peerSockets = {};
-    this.lastReceived = null;
+    this.defaultPeer = null;
-    this.associated = false;
+    this.defaultServer = null;
-    this.receiving = null;
+}
-    this.receiveLength = null;
-    this.minRecv = null;
-    this.pendingPDVs = null;
-    this.server = null;
-    //this.retrieveModel = RETRIEVE_MODEL_STUDY_ROOT;
-    this.presentationContexts = [];
-    this.transferSyntaxes = [];
-    this.negotiatedContexts = {};
-    this.messages = {};
-    this.messageIdCounter = 0;
-    this.services = [];
-    this.lastCommand = null;
-    this.lastSent = null;
-    this.lastGets = [];
-    this.findContext = C.SOP_STUDY_ROOT_FIND;
-
-    //register hooks
-    var o = this;
-    this.socket.on('data', function(data) {
-        o.received(data);
-    });
-    this.socket.on('close', function(he) {
-        o.closed(he);
-        o.emit('close', he);
-    });
-    this.socket.on('error', function(he) {
-        o.error(he);
-    });
-    this.socket.on('end', function() {
-        if (o.intervalId) {
-            clearInterval(o.intervalId);
-        }
-
-        if (o.server) {
-            console.log('Closing server');
-            o.server.close();
-        }
-
-        console.log('ended');
-    });
-    this.on('released', function() {
-        this.released();
-    });
-    this.on('aborted', function() {
-        this.released();
-    });
-    this.on('message', function(pdvs) {
-        this.receivedMessage(pdvs);
-    });
-    this.on('init', this.ready);
-
-    //this.pause();
-    if (this.options.listenHost && this.options.listenPort) {
-        this.server = net.createServer();
-        this.server.listen(this.options.listenPort, this.options.listenHost);
-        this.server.on('listening', function() {
-            console.log('listening on %j', this.address());
-        });
-        this.server.on('connection', function(socket) {
-
-        });
-    }
-
-    this.emit('init');
-};
 
 util.inherits(Connection, EventEmitter);
 
-Connection.prototype.checkIdle = function() {
+Connection.prototype.addPeer = function(options) {
-    var current = time(),
+  if (!options.aeTitle || !options.host || !options.port) {
-        idl = this.options.idle;
+    return false;
-    if (!this.lastReceived && (current - this.started >= idl)) {
-        this.idleClose();
-    } else if (this.lastReceived && (current - this.lastReceived >= idl)) {
-        this.idleClose();
-    } else {
-        //console.log('keep idling')
   }
-};
+  this.peers[options.aeTitle] = {
-
+    host : options.host, port : options.port
-Connection.prototype.released = function() {
-    this.socket.end();
-};
-
-Connection.prototype.idleClose = function() {
-    console.log('Exceed idle time, closing connection');
-    this.release();
-};
-
-Connection.prototype.getSoureceAE = function() {
-    return this.options.sourceAE;
-};
-
-Connection.prototype.ready = function() {
-    console.log('Connection established');
-    this.connected = true;
-    this.started = time();
-
-    var o = this;
-    this.intervalId = setInterval(function() {
-        o.checkIdle();
-    }, 3000);
-
-    //this.emit("init");
-    //this.startAssociationRequest();
-};
-
-Connection.prototype.resetReceive = function() {
-    this.receiving = this.receiveLength = null;
-};
-
-Connection.prototype.received = function(data) {
-    var i = 0;
-    do {
-        data = this.process(data);
-    } while (data !== null);
-    this.lastReceived = time();
-};
-
-Connection.prototype.process = function(data) {
-    //console.log("Data received");
-    if (this.receiving === null) {
-        if (this.minRecv) {
-            data = Buffer.concat([ this.minRecv, data ], this.minRecv.length + data.length);
-            this.minRecv = null;
-        }
-
-        if (data.length < 6) {
-            this.minRecv = data;
-            return null;
-        }
-
-        var stream = new ReadStream(data);
-        var type = stream.read(C.TYPE_UINT8);
-        stream.increment(1);
-        var len = stream.read(C.TYPE_UINT32),
-            cmp = data.length - 6;
-        if (len > cmp) {
-            this.receiving = data;
-            this.receiveLength = len;
-        } else {
-            var process = data,
-                remaining = null;
-            if (len < cmp) {
-                process = data.slice(0, len + 6);
-                remaining = data.slice(len + 6, cmp + 6);
-            }
-
-            this.resetReceive();
-            this.interpret(new ReadStream(process));
-            if (remaining) {
-                return remaining;
-            }
-        }
-    } else {
-        var newData = Buffer.concat([ this.receiving, data ], this.receiving.length + data.length),
-            pduLength = newData.length - 6;
-
-        if (pduLength < this.receiveLength) {
-            this.receiving = newData;
-        } else {
-            var remaining = null;
-            if (pduLength > this.receiveLength) {
-                remaining = newData.slice(this.receiveLength + 6, pduLength + 6);
-                newData = newData.slice(0, this.receiveLength + 6);
-            }
-
-            this.resetReceive();
-            this.interpret(new ReadStream(newData));
-            if (remaining) {
-                return remaining;
-            }
-        }
-    }
-
-    return null;
-};
-
-Connection.prototype.interpret = function(stream) {
-    var pdatas = [],
-        size = stream.size(),
-        o = this;
-    while (stream.offset < size) {
-        var pdu = pduByStream(stream);
-        //console.log("Received PDU-TYPE " + pdu.type);
-        if (pdu.is(C.ITEM_TYPE_PDU_ASSOCIATE_AC)) {
-            pdu.presentationContextItems.forEach(function(ctx) {
-                var requested = o.getContext(ctx.presentationContextID);
-                if (!requested) {
-                    throw 'Accepted presentation context not found';
-                }
-
-                o.negotiatedContexts[ctx.presentationContextID] = {
-                    id: ctx.presentationContextID,
-                    transferSyntax: ctx.transferSyntaxesItems[0].transferSyntaxName,
-                    abstractSyntax: requested.abstractSyntax
   };
-
+  if (options.default) {
-                var notfound = false;
+    if (options.server) {
-                o.services.forEach(function(service) {
+      this.defaultServer = options.aeTitle;
-                    if (service.contextUID == requested.abstractSyntax) {
-                        service.contextID = ctx.presentationContextID;
-                    }
-                });
-            });
-
-            //console.log('Accepted');
-            this.associated = true;
-            this.emit('associated', pdu);
-        } else if (pdu.is(C.ITEM_TYPE_PDU_RELEASE_RP)) {
-            //console.log('Released');
-            this.associated = false;
-            this.emit('released');
-        } else if (pdu.is(C.ITEM_TYPE_PDU_AABORT)) {
-            //console.log('Aborted');
-            this.emit('aborted');
-        } else if (pdu.is(C.ITEM_TYPE_PDU_PDATA)) {
-            pdatas.push(pdu);
-        }
-    }
-
-    if (pdatas) {
-        var pdvs = this.pendingPDVs ? this.pendingPDVs : [];
-        pdatas.forEach(function(pdata) {
-            pdvs = pdvs.concat(pdata.presentationDataValueItems);
-        });
-        this.pendingPDVs = null;
-        var i = 0,
-            count = pdvs.length;
-        while (i < count) {
-            if (!pdvs[i].isLast) {
-                var j = i + 1;
-                while (j < count) {
-                    pdvs[i].messageStream.concat(pdvs[j].messageStream);
-                    if (pdvs[j++].isLast) {
-                        pdvs[i].isLast = true;
-                        break;
-                    }
-                }
-
-                if (pdvs[i].isLast) {
-                    this.emit('message', pdvs[i]);
     } else {
-                    this.pendingPDVs = [ pdvs[i] ];
+      this.defaultPeer = options.aeTitle;
-                }
-
-                i = j;
-            } else {
-                this.emit('message', pdvs[i++]);
     }
   }
-    }
+  if (options.server) {
-
+    //start listening
-    //this.release();
+    var server = net.createServer();
-};
+    server.listen(options.port, options.host, function(){
-
+        console.log("listening on %j", this.address());
-Connection.prototype.newMessageId = function() {
-    return (++this.messageIdCounter) % 255;
-};
-
-Connection.prototype.closed = function(had_error) {
-    this.connected = false;
-    console.log('Connection closed', had_error);
-    //this.destroy();
-};
-
-Connection.prototype.error = function(err) {
-    console.log('Error: ', err);
-};
-
-Connection.prototype.send = function(pdu, afterCbk) {
-    //console.log('SEND PDU-TYPE: ', pdu.type);
-    var toSend = pdu.buffer();
-    //console.log('send buffer', toSend.toString('hex'));
-    this.socket.write(toSend, afterCbk ? afterCbk : function() {
-        //console.log('Data written');
     });
-};
+    server.on('error', function(err){
+        console.log("server error %j", err);
+    });
+    var o = this;
+    server.on('connection', function(nativeSocket) {
+        //incoming connections
+        var socket = new CSocket(nativeSocket, o.options);
+        o.addSocket(options.aeTitle, socket);
 
-Connection.prototype.getSyntax = function(contextId) {
+        //close server on close socket
-    if (!this.negotiatedContexts[contextId]) return null;
+        socket.on('close', function(){
-
+          server.close();
-    return this.negotiatedContexts[contextId].transferSyntax;
-};
-
-Connection.prototype.getContextByUID = function(uid) {
-    for (var k in this.negotiatedContexts) {
-        var ctx = this.negotiatedContexts[k];
-        if (ctx.abstractSyntax == uid) {
-            return ctx;
-        }
-    }
-
-    return null;
-};
-
-Connection.prototype.getContextId = function(contextId) {
-    if (!this.negotiatedContexts[contextId]) return null;
-
-    return this.negotiatedContexts[contextId].id;
-};
-
-Connection.prototype.getContext = function(id) {
-    for (var k in this.presentationContexts) {
-        var ctx = this.presentationContexts[k];
-        if (id == ctx.id) return ctx;
-    }
-
-    return null;
-};
-
-Connection.prototype.setPresentationContexts = function(uids) {
-    var contexts = [],
-        id = 0;
-    uids.forEach(function(uid) {
-        contexts.push({
-            id: ++id,
-            abstractSyntax: uid,
-            transferSyntaxes: [ C.IMPLICIT_LITTLE_ENDIAN, C.EXPLICIT_LITTLE_ENDIAN, C.EXPLICIT_BIG_ENDIAN ]
         });
     });
-    this.presentationContexts = contexts;
-};
-
-Connection.prototype.verify = function() {
-    this.setPresentationContexts([ C.SOP_VERIFICATION ]);
-    this.startAssociationRequest(function() {
-        //associated, we can release now
-        this.release();
-    });
-};
-
-Connection.prototype.release = function() {
-    var releaseRQ = new ReleaseRQ();
-    this.send(releaseRQ);
-};
-
-Connection.prototype.addService = function(service) {
-    service.setConnection(this);
-    this.services.push(service);
-};
-
-Connection.prototype.receivedMessage = function(pdv) {
-    var syntax = this.getSyntax(pdv.contextId),
-        msg = readMessage(pdv.messageStream, pdv.type, syntax, this.options.vr);
-
-    if (msg.isCommand()) {
-        this.lastCommand = msg;
-
-        if (msg.isResponse()) {
-            if (msg.is(C.COMMAND_C_GET_RSP) || msg.is(C.COMMAND_C_MOVE_RSP)) {
-                //console.log('remaining', msg.getNumOfRemainingSubOperations(), msg.getNumOfCompletedSubOperations());
-            }
-
-            if (msg.failure()) {
-                //console.log("message failed with status ", msg.getStatus().toString(16));
-            }
-
-            if (msg.isFinal()) {
-                var replyId = msg.respondedTo();
-                if (this.messages[replyId].listener) {
-                    this.messages[replyId].listener.emit('end', msg);
-                    /*if (this.messages[replyId].listener[1]) {
-            this.messages[replyId].listener[1].call(this, msg);
-          }*/
-                    if (!msg.haveData())
-                        delete this.messages[replyId];
-                }
-
-                if (msg.is(C.COMMAND_C_GET_RSP)) {
-                    if (!msg.getNumOfRemainingSubOperations()) {
-                        if (this.lastGets && this.lastGets.length > 0) this.lastGets.shift();
-                    }
-                }
-            }
-        } else {
-            /*if (msg.is(0x01)) {
-        console.log('ae title ', msg.getValue(0x00001031))
-      }*/
-        }
-
-    } else {
-        if (!this.lastCommand) {
-            throw 'Only dataset?';
-        } else if (!this.lastCommand.haveData()) {
-            throw "Last command didn't indicate presence of data";
-        }
-
-        if (this.lastCommand.isResponse()) {
-            var replyId = this.lastCommand.respondedTo();
-            if (this.messages[replyId].listener) {
-                var flag = this.lastCommand.failure() ? true : false;
-
-                this.messages[replyId].listener.emit('result', msg, flag);
-
-                if (this.lastCommand.failure()) {
-                    delete this.messages[replyId];
-                }
-            }
-        } else {
-            if (this.lastCommand.is(C.COMMAND_C_STORE_RQ)) {
-                var moveMessageId = this.lastCommand.getMoveMessageId(),
-                    useId = moveMessageId;
-                if (!moveMessageId) {
-                    //!! Going to deprecate now
-                    //kinda hacky but we know this c-store is came from a c-get
-                    if (this.lastGets.length > 0) {
-                        useId = this.lastGets[0];
-                    } else {
-                        throw 'Where does this c-store came from?';
-                    }
-                } else console.log('move ', moveMessageId);
-                //this.storeResponse(useId, msg);
-            }
-        }
   }
 };
 
+Connection.prototype.selectPeer = function(aeTitle) {
+    if (!aeTitle || !this.peers[aeTitle]) {
+      throw "No such peer";
+    }
+    return this.peers[aeTitle];
+}
+
 Connection.prototype.storeResponse = function(messageId, msg) {
     var rq = this.messages[messageId];
 
@@ -470,183 +78,62 @@ Connection.prototype.storeResponse = function(messageId, msg) {
             replyMessage.setReplyMessageId(this.lastCommand.messageId);
             this.sendMessage(replyMessage, null, null, storeSr);
         } else {
-            throw 'Missing store status';
+            throw "Missing store status";
         }
     }
 };
 
-Connection.prototype.sendMessage = function(context, command, dataset, listener) {
+Connection.prototype.allClosed = function() {
-    var nContext = this.getContextByUID(context),
+    var allClosed = true;
-        syntax = nContext.transferSyntax,
+    for (var i in o.peerSockets) {
-        cid = nContext.id,
+      if (Object.keys(o.peerSockets[ae]).length > 0) {
-        messageId = this.newMessageId(),
+        allClosed = false;
-        msgData = {};
+        break;
-
-    /*if (listener) {
-    if (typeof listener != 'object') {
-      listener = [listener, null];
       }
-    msgData.listener = listener;
-  }*/
-    msgData.listener = new Envelope();
-
-    var pdata = new PDataTF(),
-        pdv = new PresentationDataValueItem(cid);
-
-    command.setSyntax(C.IMPLICIT_LITTLE_ENDIAN);
-    command.setContextId(context);
-    command.setMessageId(messageId);
-    if (dataset)
-        command.setDataSetPresent(C.DATA_SET_PRESENT);
-
-    this.lastSent = command;
-    if (command.is(C.COMMAND_C_GET_RQ)) {
-        this.lastGets.push(messageId);
     }
+    return allClosed;
+};
 
-    pdv.setMessage(command);
+Connection.prototype.addSocket = function(ae, socket) {
-    pdata.setPresentationDataValueItems([ pdv ]);
+    if (!this.peerSockets[ae]) {
-
+      this.peerSockets[ae] = {};
-    msgData.command = command;
-    this.messages[messageId] = msgData;
-
-    /*var stream = new ReadStream(pdata.buffer()), np = pduByStream(stream), pdv = np.presentationDataValueItems[0];
-  var msg = readMessage(pdv.messageStream, pdv.type, C.IMPLICIT_LITTLE_ENDIAN);
-  console.log(msg.isCommand());
-  return;*/
-
-    this.send(pdata);
-    if (dataset) {
-        dataset.setSyntax(syntax);
-        var dsData = new PDataTF(),
-            dPdv = new PresentationDataValueItem(cid);
-
-        dPdv.setMessage(dataset);
-        dsData.setPresentationDataValueItems([ dPdv ]);
-        this.send(dsData);
     }
+    this.peerSockets[ae][socket.id] = socket;
 
-    return msgData.listener;
+    var o = this;
+    socket.on("close", function() {
+      if (o.peerSockets[ae][this.id]) {
+        delete o.peerSockets[ae][this.id];
+      } 
+    });
 };
 
 Connection.prototype.associate = function(options, callback) {
-    if (callback) {
+    var hostAE = options.hostAE ? options.hostAE : this.defaultPeer,
-        this.once('associated', callback);
+        sourceAE = options.sourceAE ? options.sourceAE : this.defaultServer;
-    }
+        peerInfo = this.selectPeer(hostAE), nativeSocket = new Socket();
     
-    if (this.associated) {
+    var socket = new CSocket(nativeSocket, this.options), o = this;
-        this.emit('associated');
+    if (callback) {
-        return;
+        socket.once('associated', callback);
     }
+    socket.setCalledAe(hostAE);
+    socket.setCallingAE(sourceAE);
+
+    nativeSocket.connect({
+      host : peerInfo.host, port : peerInfo.port
+    }, function(){
+      //connected
+      o.addSocket(hostAE, socket);
 
       if (options.contexts) {
-        this.setPresentationContexts(options.contexts);
+          socket.setPresentationContexts(options.contexts);
       } else {
-        throw 'No services attached';
+          throw "Contexts must be specified";
       }
 
-    var associateRQ = new AssociateRQ();
+      socket.associate();
-    associateRQ.setCalledAETitle(options.hostAE);
-    var sourceAE = options.sourceAE ? options.sourceAE : DEFAULT_SOURCE_AE;
-    associateRQ.setCallingAETitle(sourceAE);
-    associateRQ.setApplicationContextItem(new ApplicationContextItem());
-
-    var contextItems = [];
-    this.presentationContexts.forEach(function(context) {
-        var contextItem = new PresentationContextItem(),
-            syntaxes = [];
-        context.transferSyntaxes.forEach(function(transferSyntax) {
-            var transfer = new TransferSyntaxItem();
-            transfer.setTransferSyntaxName(transferSyntax);
-            syntaxes.push(transfer);
     });
-        contextItem.setTransferSyntaxesItems(syntaxes);
-        contextItem.setPresentationContextID(context.id);
 
-        var abstractItem = new AbstractSyntaxItem();
+    return socket;
-        abstractItem.setAbstractSyntaxName(context.abstractSyntax);
-        contextItem.setAbstractSyntaxItem(abstractItem);
-        contextItems.push(contextItem);
-    });
-    associateRQ.setPresentationContextItems(contextItems);
-
-    var maxLengthItem = new MaximumLengthItem(),
-        classUIDItem = new ImplementationClassUIDItem(),
-        versionItem = new ImplementationVersionNameItem();
-
-    classUIDItem.setImplementationClassUID(C.IMPLEM_UID);
-    versionItem.setImplementationVersionName(C.IMPLEM_VERSION);
-    var packageSize = options.maxPackageSize ? options.maxPackageSize : DEFAULT_MAX_PACKAGE_SIZE;
-    maxLengthItem.setMaximumLengthReceived(packageSize);
-
-    var userInfo = new UserInformationItem();
-    userInfo.setUserDataItems([ maxLengthItem, classUIDItem, versionItem ]);
-
-    associateRQ.setUserInformationItem(userInfo);
-
-    this.send(associateRQ);
-};
-
-Connection.prototype.wrapMessage = function(data) {
-    if (data) {
-        var datasetMessage = new DataSetMessage();
-        datasetMessage.setElements(data);
-        return datasetMessage;
-    } else return data;
-};
-
-Connection.prototype.setFindContext = function(ctx) {
-    this.findContext = ctx;
-};
-
-Connection.prototype.find = function(params, callback) {
-    return this.sendMessage(this.findContext, new CFindRQ(), this.wrapMessage(params), callback);
-};
-
-Connection.prototype.findPatients = function(params, callback) {
-    var sendParams = Object.assign({
-        0x00080052: C.QUERY_RETRIEVE_LEVEL_PATIENT,
-        0x00100010: '',
-        0x00100020: '',
-        0x00100030: '',
-        0x00100040: '',
-    }, params);
-
-    return this.find(sendParams, callback);
-};
-
-Connection.prototype.findStudies = function(params, callback) {
-    var sendParams = Object.assign({
-        0x00080052: C.QUERY_RETRIEVE_LEVEL_STUDY,
-        0x00080020: '',
-        0x00100010: '',
-        0x00080061: '',
-        0x0020000D: ''
-    }, params);
-
-    return this.find(sendParams, callback);
-};
-
-Connection.prototype.findSeries = function(params, callback) {
-    var sendParams = Object.assign({
-        0x00080052: C.QUERY_RETRIEVE_LEVEL_SERIES,
-        0x00080020: '',
-        0x0020000E: '',
-        0x0008103E: '',
-        0x0020000D: ''
-    }, params);
-
-    return this.find(sendParams, callback);
-};
-
-Connection.prototype.findInstances = function(params, callback) {
-    var sendParams = Object.assign({
-        0x00080052: C.QUERY_RETRIEVE_LEVEL_IMAGE,
-        0x00080020: '',
-        0x0020000E: '',
-        0x0008103E: '',
-        0x0020000D: ''
-    }, params);
-
-    return this.find(sendParams, callback);
 };

Packages/dimseservice/server/DIMSE.js

@@ -1,61 +1,43 @@
-var net = Npm.require('net'),
+var Future = Npm.require('fibers/future');
-    Future = Npm.require('fibers/future');
 
 DIMSE = {};
 
-DIMSE.associate = function(contexts, callback) {
+var conn = new Connection({
-    var host = Meteor.settings.dimse.host,
-        port = Meteor.settings.dimse.port,
-        ae = Meteor.settings.dimse.hostAE;
-
-    console.log("Associating via DIMSE");
-    console.log(Meteor.settings.dimse);
-
-    var client = net.connect({
-        host: host,
-        port: port
-    });
-
-    client.on('connect', function() {
-        //'connect' listener
-        console.log('==Connected');
-
-        var conn = new Connection(client, {
     vr: {
         split: false
     }
-        });
+});
 
+Meteor.startup(function(){
+    var peers = Meteor.settings.dimse;
+    peers.forEach(function(peer){
+        conn.addPeer(peer);
+    });
+});
+
+DIMSE.associate = function(contexts, callback) {
     conn.associate({
-            contexts: contexts,
+        contexts: contexts
-            hostAE: ae
     }, function(pdu) {
         // associated
         console.log('==Associated');
-
+        callback.call(this, pdu);
-            callback.call(conn, pdu);
-        });
-    });
-
-    client.on('error', function(error) {
-        throw error;
     });
 };
 
 DIMSE.retrievePatients = function(params) {
     //var start = new Date();
     var future = new Future;
-    DIMSE.associate([ C.SOP_PATIENT_ROOT_FIND ], function(pdu) {
+    DIMSE.associate([C.SOP_PATIENT_ROOT_FIND], function(pdu) {
         var defaultParams = {
-            0x00100010: '',
+            0x00100010: "",
-            0x00100020: '',
+            0x00100020: "",
-            0x00100030: '',
+            0x00100030: "",
-            0x00100040: '',
+            0x00100040: "",
-            0x00101010: '',
+            0x00101010: "",
-            0x00101040: ''
+            0x00101040: ""
         };
 
-        this.setFindContext(C.SOP_PATIENT_ROOT_FIND);
         var result = this.findPatients(Object.assign(defaultParams, params)),
             o = this;
 
@@ -76,30 +58,32 @@ DIMSE.retrievePatients = function(params) {
     return future.wait();
 };
 
-DIMSE.retrieveStudies = function(params) {
+DIMSE.retrieveStudies = function(params, options) {
     //var start = new Date();
-    var future = new Future;
+    var future = new Future, options = Object.assign({limit : 100}, options);
-    DIMSE.associate([ C.SOP_STUDY_ROOT_FIND ], function(pdu) {
+    DIMSE.associate([C.SOP_STUDY_ROOT_FIND], function(pdu) {
         var defaultParams = {
-            0x0020000D: '',
+            0x0020000D: "",
-            0x00080060: '',
+            0x00080060: "",
-            0x00080005: '',
+            0x00080005: "",
-            0x00080020: '',
+            0x00080020: "",
-            0x00080030: '',
+            0x00080030: "",
-            0x00080090: '',
+            0x00080090: "",
-            0x00100010: '',
+            0x00100010: "",
-            0x00100020: '',
+            0x00100020: "",
-            0x00200010: '',
+            0x00200010: "",
-            0x00100030: ''
+            0x00100030: ""
         };
 
-        this.setFindContext(C.SOP_STUDY_ROOT_FIND);
         var result = this.findStudies(Object.assign(defaultParams, params)),
             o = this;
 
         var studies = [];
         result.on('result', function(msg) {
             studies.push(msg);
+            if (options.limit && options.limit == studies.length) {
+                result.emit('cancel');
+            }
         });
 
         result.on('end', function() {
@@ -116,22 +100,21 @@ DIMSE.retrieveStudies = function(params) {
 
 DIMSE.retrieveSeries = function(studyInstanceUID, params) {
     var future = new Future;
-    DIMSE.associate([ C.SOP_STUDY_ROOT_FIND ], function(pdu) {
+    DIMSE.associate([C.SOP_STUDY_ROOT_FIND], function(pdu) {
         var defaultParams = {
-            0x0020000D: studyInstanceUID ? studyInstanceUID : '',
+            0x0020000D: studyInstanceUID ? studyInstanceUID : "",
-            0x00080005: '',
+            0x00080005: "",
-            0x00080020: '',
+            0x00080020: "",
-            0x00080030: '',
+            0x00080030: "",
-            0x00080090: '',
+            0x00080090: "",
-            0x00100010: '',
+            0x00100010: "",
-            0x00100020: '',
+            0x00100020: "",
-            0x00200010: '',
+            0x00200010: "",
-            0x0008103E: '',
+            0x0008103E: "",
-            0x0020000E: '',
+            0x0020000E: "",
-            0x00200011: ''
+            0x00200011: ""
         };
 
-        this.setFindContext(C.SOP_STUDY_ROOT_FIND);
         var result = this.findSeries(Object.assign(defaultParams, params)),
             o = this;
 
@@ -151,37 +134,34 @@ DIMSE.retrieveSeries = function(studyInstanceUID, params) {
     return future.wait();
 };
 
-DIMSE.retrieveInstances = function(studyInstanceUID, seriesInstanceUID, params) {
+DIMSE.retrieveInstances = function(studyInstanceUID, seriesInstanceUID, params, options) {
     var future = new Future;
-    DIMSE.associate([ C.SOP_STUDY_ROOT_FIND ], function(pdu) {
+    DIMSE.associate([C.SOP_STUDY_ROOT_FIND], function(pdu) {
         var defaultParams = {
-            0x0020000D: studyInstanceUID ? studyInstanceUID : '',
+            0x0020000D: studyInstanceUID ? studyInstanceUID : "",
-            0x0020000E: (studyInstanceUID && seriesInstanceUID) ? seriesInstanceUID : '',
+            0x0020000E: (studyInstanceUID && seriesInstanceUID) ? seriesInstanceUID : "",
-            0x00080005: '',
+            0x00080005: "",
-            0x00080020: '',
+            0x00080020: "",
-            0x00080030: '',
+            0x00080030: "",
-            0x00080090: '',
+            0x00080090: "",
-            0x00100010: '',
+            0x00100010: "",
-            0x00100020: '',
+            0x00100020: "",
-            0x00200010: '',
+            0x00200010: "",
-            0x0008103E: '',
+            0x0008103E: "",
-            0x00200011: '',
+            0x00200011: "",
-            0x00080016: '',
+            0x00080016: "",
-            0x00080018: '', // sopInstanceUid. This is missing from the results?
+            0x00080018: "",
-            0x00200013: '',
+            0x00200013: "",
-            0x00280010: '',
+            0x00280010: "",
-            0x00280011: '',
+            0x00280011: "",
-            0x00280100: '',
+            0x00280100: "",
-            0x00280103: ''
+            0x00280103: ""
         };
-
+        var result = this.findInstances(Object.assign(defaultParams, params), options),
-        this.setFindContext(C.SOP_STUDY_ROOT_FIND);
-        var result = this.findInstances(Object.assign(defaultParams, params)),
             o = this;
 
         var instances = [];
         result.on('result', function(msg) {
-            console.log(msg);
             instances.push(msg);
         });
 
@@ -195,3 +175,14 @@ DIMSE.retrieveInstances = function(studyInstanceUID, seriesInstanceUID, params)
     });
     return future.wait();
 };
+
+DIMSE.moveInstances = function(studyInstanceUID, seriesInstanceUID, sopInstanceUID, sopClassUID, params) {
+    DIMSE.associate([C.SOP_STUDY_ROOT_MOVE, sopClassUID], function() {
+        var defaultParams = {
+            0x0020000D: studyInstanceUID ? studyInstanceUID : "",
+            0x0020000E: seriesInstanceUID ? seriesInstanceUID : "",
+            0x00080018: sopInstanceUID ? sopInstanceUID : ""
+        }
+        this.moveInstances("OHIFDCM", Object.assign(defaultParams, params));
+    });
+}

Packages/dimseservice/server/Field.js

@@ -5,32 +5,30 @@ Field = function(type, value) {
 
 Field.prototype.length = function() {
   return calcLength(this.type, this.value);
-};
+}
 
 Field.prototype.write = function(stream) {
   stream.write(this.type, this.value);
-};
+}
 
 Field.prototype.isNumeric = function() {
   return false;
-};
+}
 
 StringField = function(str) {
-    Field.call(this, C.TYPE_ASCII, typeof str == 'string' ? str : '');
+  Field.call(this, C.TYPE_ASCII, typeof str == 'string' ? str : "");
-};
+}
-
 util.inherits(StringField, Field);
 
 FilledField = function(value, length) {
   Field.call(this, C.TYPE_COMPOSITE, value);
   this.fillLength = length;
-};
+}
-
 util.inherits(FilledField, Field);
 
 FilledField.prototype.length = function() {
   return this.fillLength;
-};
+}
 
 FilledField.prototype.write = function(stream) {
   var len = this.value.length;
@@ -38,104 +36,93 @@ FilledField.prototype.write = function(stream) {
     if (len > 0)
       stream.write(C.TYPE_ASCII, this.value);
     var zeroLength = this.fillLength - len;
-        stream.write(C.TYPE_HEX, '20'.repeat(zeroLength));
+    stream.write(C.TYPE_HEX, "20".repeat(zeroLength));
   } else if (len == this.fillLength) {
     stream.write(C.TYPE_ASCII, this.value);
   } else {
-        throw 'Length mismatch';
+    throw "Length mismatch";
   }    
-};
+}
 
 HexField = function(hex) {
   Field.call(this, C.TYPE_HEX, hex);
-};
+}
-
 util.inherits(HexField, Field);
 
 ReservedField = function(length) {
   length = length || 1;
-    Field.call(this, C.TYPE_HEX, '00'.repeat(length));
+  Field.call(this, C.TYPE_HEX, "00".repeat(length));
-};
+}
-
 util.inherits(ReservedField, Field);
 
 UInt8Field = function(value) {
   Field.call(this, C.TYPE_UINT8, value);
-};
+}
-
 util.inherits(UInt8Field, Field);
 
 UInt8Field.prototype.isNumeric = function() {
   return true;
-}; 
+} 
 
 UInt16Field = function(value) {
   Field.call(this, C.TYPE_UINT16, value);
-};
+}
-
 util.inherits(UInt16Field, Field);
 
 UInt16Field.prototype.isNumeric = function() {
   return true;
-}; 
+} 
 
 UInt32Field = function(value) {
   Field.call(this, C.TYPE_UINT32, value);
-};
+}
-
 util.inherits(UInt32Field, Field);
 
 UInt32Field.prototype.isNumeric = function() {
   return true;
-}; 
+} 
 
 Int8Field = function(value) {
   Field.call(this, C.TYPE_INT8, value);
-};
+}
-
 util.inherits(Int8Field, Field);
 
 Int8Field.prototype.isNumeric = function() {
   return true;
-}; 
+} 
 
 Int16Field = function(value) {
   Field.call(this, C.TYPE_INT16, value);
-};
+}
-
 util.inherits(Int16Field, Field);
 
 Int16Field.prototype.isNumeric = function() {
   return true;
-}; 
+} 
 
 Int32Field = function(value) {
   Field.call(this, C.TYPE_INT32, value);
-};
+}
-
 util.inherits(Int32Field, Field);
 
 Int32Field.prototype.isNumeric = function() {
   return true;
-}; 
+} 
 
 FloatField = function(value) {
   Field.call(this, C.TYPE_FLOAT, value);
-};
+}
-
 util.inherits(FloatField, Field);
 
 FloatField.prototype.isNumeric = function() {
   return true;
-}; 
+} 
 
 DoubleField = function(value) {
   Field.call(this, C.TYPE_DOUBLE, value);
-};
+}
-
 util.inherits(DoubleField, Field);
 
 DoubleField.prototype.isNumeric = function() {
   return true;
-};
+} 
- 

Packages/dimseservice/server/Message.js

@@ -7,7 +7,7 @@ DicomMessage = function(syntax) {
 
 DicomMessage.prototype.isCommand = function() {
   return this.type == C.DATA_TYPE_COMMAND;
-};
+}
 
 DicomMessage.prototype.setSyntax = function(syntax) {
   this.syntax = syntax;
@@ -15,15 +15,15 @@ DicomMessage.prototype.setSyntax = function(syntax) {
   for (var tag in this.elementPairs) {
     this.elementPairs[tag].setSyntax(this.syntax);
   }  
-};
+}
 
 DicomMessage.prototype.setMessageId = function(id) {
   this.messageId = id;
-};
+}
 
 DicomMessage.prototype.setReplyMessageId = function(id) {
   this.replyMessageId = id;
-};
+}
 
 DicomMessage.prototype.command = function(cmds) {
   cmds.unshift(this.newElement(0x00000800, this.dataSetPresent ? C.DATA_SET_PRESENT : C.DATE_SET_ABSENCE));
@@ -39,12 +39,13 @@ DicomMessage.prototype.command = function(cmds) {
 
   cmds.unshift(this.newElement(0x00000000, length));
   return cmds;
-};
+}
 
 DicomMessage.prototype.response = function(cmds) {
   cmds.unshift(this.newElement(0x00000800, this.dataSetPresent ? C.DATA_SET_PRESENT : C.DATE_SET_ABSENCE));
   cmds.unshift(this.newElement(0x00000120, this.replyMessageId));
   cmds.unshift(this.newElement(0x00000100, this.commandType));
+  if (this.contextUID)
     cmds.unshift(this.newElement(0x00000002, this.contextUID));
 
   var length = 0;
@@ -54,149 +55,145 @@ DicomMessage.prototype.response = function(cmds) {
 
   cmds.unshift(this.newElement(0x00000000, length));
   return cmds;
-};  
+}  
 
 DicomMessage.prototype.setElements = function(pairs) {
   var p = {};
   for (var tag in pairs) {
     p[tag] = this.newElement(tag, pairs[tag]);
   }
-
   this.elementPairs = p;
-};  
+}  
 
 DicomMessage.prototype.newElement = function(tag, value) {
   return elementByType(tag, value, this.syntax);
-};
+}
 
 DicomMessage.prototype.setElement = function(key, value) {
   this.elementPairs[key] = elementByType(key, value);
-};
+}
 
 DicomMessage.prototype.setElementPairs = function(pairs) {
   this.elementPairs = pairs;
-};
+}
 
 DicomMessage.prototype.setContextId = function(context) {
   this.contextUID = context;
-};
+}
 
 DicomMessage.prototype.setPriority = function(pri) {
   this.priority = pri;
-};
+}
 
 DicomMessage.prototype.setType = function(type) {
   this.type = type;
-};
+}
 
 DicomMessage.prototype.setDataSetPresent = function(present) {
   this.dataSetPresent = present == 0x0101 ? false : true;
-};
+}
 
 DicomMessage.prototype.haveData = function() {
   return this.dataSetPresent;
-};  
+}  
 
 DicomMessage.prototype.tags = function() {
   return Object.keys(this.elementPairs);
-};
+}
 
 DicomMessage.prototype.key = function(tag) {
   return elementKeywordByTag(tag);
-};
+}
 
 DicomMessage.prototype.getValue = function(tag) {
   return this.elementPairs[tag] ? this.elementPairs[tag].getValue() : null;
-};
+}
 
 DicomMessage.prototype.affectedSOPClassUID = function() {
   return this.getValue(0x00000002);
-};  
+}  
 
 DicomMessage.prototype.getMessageId = function() {
   return this.getValue(0x00000110);
-};
+}
 
 DicomMessage.prototype.getFields = function() {
   var eles = [];
   for (var tag in this.elementPairs) {
     eles.push(this.elementPairs[tag]);
   }
-
   return eles;
-};  
+}  
 
 DicomMessage.prototype.length = function(elems) {
   var len = 0;
-    elems.forEach(function(elem) {
+  elems.forEach(function(elem){
     len += elem.length(elem.getFields());
   });
   return len;
-};
+}
 
 DicomMessage.prototype.isResponse = function() {
   return false;
-};
+}
 
 DicomMessage.prototype.is = function(type) {
   return this.commandType == type;
-};  
+}  
 
 DicomMessage.prototype.write = function(stream) {
   var fields = this.getFields(), o = this;
-    fields.forEach(function(field) {
+  fields.forEach(function(field){
     field.setSyntax(o.syntax);
     field.write(stream);
   });
-};
+}
 
 DicomMessage.prototype.printElements = function(pairs, indent) {
-    var typeName = '';
+  var typeName = "";
   for (var tag in pairs) {
     var value = pairs[tag].getValue();
-        typeName += (' '.repeat(indent)) + this.key(tag) + ' : ';
+    typeName += (" ".repeat(indent)) + this.key(tag) + " : ";
     if (value instanceof Array) {
       var o = this;
       value.forEach(function(p) {
-                if (typeof p == 'object') {
+        if (typeof p == "object") {
-                    typeName += '[\n' + o.printElements(p, indent + 2) + (' '.repeat(indent)) + ']';
+          typeName += "[\n" + o.printElements(p, indent + 2) + (" ".repeat(indent)) + "]";
         } else {
-                    typeName += '[' + p + ']';
+          typeName += "[" + p + "]";
         }
       });
-            if (typeName[typeName.length - 1] != '\n') {
+      if (typeName[typeName.length-1] != "\n") {
-                typeName += '\n';
+        typeName += "\n";
       }
     } else {
-            typeName += value + '\n';
+      typeName += value + "\n";
     }
   }
-
   return typeName;
-};
+}
 
 DicomMessage.prototype.toString = function() {
-    var typeName = '';
+  var typeName = "";
   if (!this.isCommand()) {
-        typeName = 'DateSet Message';
+    typeName = "DateSet Message";
   } else {
     switch (this.commandType) {
-            case C.COMMAND_C_GET_RSP : typeName = 'C-GET-RSP'; break;
+      case C.COMMAND_C_GET_RSP   : typeName = "C-GET-RSP"; break;
-            case C.COMMAND_C_MOVE_RSP : typeName = 'C-MOVE-RSP'; break;
+      case C.COMMAND_C_MOVE_RSP  : typeName = "C-MOVE-RSP"; break;
-            case C.COMMAND_C_GET_RQ : typeName = 'C-GET-RQ'; break;
+      case C.COMMAND_C_GET_RQ    : typeName = "C-GET-RQ"; break;
-            case C.COMMAND_C_STORE_RQ : typeName = 'C-STORE-RQ'; break;
+      case C.COMMAND_C_STORE_RQ  : typeName = "C-STORE-RQ"; break;
-            case C.COMMAND_C_FIND_RSP : typeName = 'C-FIND-RSP'; break;
+      case C.COMMAND_C_FIND_RSP  : typeName = "C-FIND-RSP"; break;
-            case C.COMMAND_C_MOVE_RQ : typeName = 'C-MOVE-RQ'; break;
+      case C.COMMAND_C_MOVE_RQ   : typeName = "C-MOVE-RQ"; break;
-            case C.COMMAND_C_FIND_RQ : typeName = 'C-FIND-RQ'; break;
+      case C.COMMAND_C_FIND_RQ   : typeName = "C-FIND-RQ"; break;
-            case C.COMMAND_C_STORE_RSP : typeName = 'C-STORE-RSP'; break;
+      case C.COMMAND_C_STORE_RSP : typeName = "C-STORE-RSP"; break;
     }      
   }
-
+  typeName += " [\n";
-    typeName += ' [\n';
   typeName += this.printElements(this.elementPairs, 0);
-    typeName += ']';
+  typeName += "]";
   return typeName;
-};
+}
 
 DicomMessage.prototype.walkObject = function(pairs) {
   var obj = {}, o = this;
@@ -210,18 +207,17 @@ DicomMessage.prototype.walkObject = function(pairs) {
         } else u.push(a);
       });
     }
-
     obj[tag] = u;
   }
 
   return obj;
-};
+}
 
 DicomMessage.prototype.toObject = function() {
   return this.walkObject(this.elementPairs);
-};
+}
 
-readMessage = function(stream, type, syntax, options) {
+DicomMessage.read = function(stream, type, syntax, options) {
   var elements = [], pairs = {}, useSyntax = type == C.DATA_TYPE_COMMAND ? C.IMPLICIT_LITTLE_ENDIAN : syntax;
   stream.reset();
   while (!stream.end()) {
@@ -229,7 +225,6 @@ readMessage = function(stream, type, syntax, options) {
     if (options) {
       elem.setOptions(options);
     }
-
     elem.setSyntax(useSyntax);
     elem.readBytes(stream);//return;
     pairs[elem.tag.value] = elem;
@@ -245,7 +240,7 @@ readMessage = function(stream, type, syntax, options) {
       case 0x8010 : message = new CGetRSP(useSyntax); break;
       case 0x0001 : message = new CStoreRQ(useSyntax); break;
       case 0x0020 : message = new CFindRQ(useSyntax); break;
-            default : throw 'Unrecognized command type ' + cmdType.toString(16); break;
+      default : throw "Unrecognized command type " + cmdType.toString(16); break;
     }
 
     message.setElementPairs(pairs);
@@ -260,128 +255,121 @@ readMessage = function(stream, type, syntax, options) {
     message = new DataSetMessage(useSyntax);
     message.setElementPairs(pairs);
   } else {
-        throw 'Unrecognized message type';
+    throw "Unrecognized message type";
   }
-
   return message;
-};
+}
 
-DataSetMessage = function(syntax) {
+DataSetMessage = function(syntax){
   DicomMessage.call(this, syntax);
   this.type = C.DATA_TYPE_DATA;
 };
-
 util.inherits(DataSetMessage, DicomMessage);
 
 DataSetMessage.prototype.is = function(type) {
   return false;
-};
+}
 
 CommandMessage = function(syntax) {
   DicomMessage.call(this, syntax);
   this.type = C.DATA_TYPE_COMMAND;
   this.priority = C.PRIORITY_MEDIUM;
   this.dataSetPresent = true;     
-};
+}
-
 util.inherits(CommandMessage, DicomMessage);
 
 CommandMessage.prototype.getFields = function() {
   return this.command(CommandMessage.super_.prototype.getFields.call(this));
-};  
+}  
 
 CommandResponse = function(syntax) {
   DicomMessage.call(this, syntax);
   this.type = C.DATA_TYPE_COMMAND;
   this.dataSetPresent = true;
 };
-
 util.inherits(CommandResponse, DicomMessage);
 
 CommandResponse.prototype.isResponse = function() {
   return true;
-};
+}
 
 CommandResponse.prototype.respondedTo = function() {
   return this.getValue(0x00000120);
-};
+}
 
 CommandResponse.prototype.isFinal = function() {
   return this.success() || this.failure() || this.cancel();
-};
+}
 
 CommandResponse.prototype.warning = function() {
   var status = this.getStatus();
   return (status == 0x0001) || (status >> 12 == 0xb);
-};
+}
 
 CommandResponse.prototype.success = function() {
   return this.getStatus() == 0x0000;
-};
+}
 
 CommandResponse.prototype.failure = function() {
   var status = this.getStatus();
-    return (status >> 12 == 0xa) || (status >> 12 == 0xc) || (status >> 8 == 0x1);
+  return (status >> 12 == 0xa) || (status >> 12 == 0xc) || (status >> 8 == 0x1)
-};
+}
 
 CommandResponse.prototype.cancel = function() {
   return this.getStatus() == C.STATUS_CANCEL;
-};
+}
 
 CommandResponse.prototype.pending = function() {
   var status = this.getStatus();
   return (status == 0xff00) || (status == 0xff01);
-};
+}
 
 CommandResponse.prototype.getStatus = function() {
   return this.getValue(0x00000900);
-};
+}
 
 CommandResponse.prototype.setStatus = function(status) {
   this.setElement(0x00000900, status);
-};
+}
 
 // following four methods only available to C-GET-RSP and C-MOVE-RSP
 CommandResponse.prototype.getNumOfRemainingSubOperations = function() {
   return this.getValue(0x00001020);
-};
+}
 
 CommandResponse.prototype.getNumOfCompletedSubOperations = function() {
   return this.getValue(0x00001021);
-};
+}
 
 CommandResponse.prototype.getNumOfFailedSubOperations = function() {
   return this.getValue(0x00001022);
-};
+}
 
 CommandResponse.prototype.getNumOfWarningSubOperations = function() {
   return this.getValue(0x00001023);
-};
+}
 //end
 
 CommandResponse.prototype.getFields = function() {
   return this.response(CommandResponse.super_.prototype.getFields.call(this));
-};
+}
 
 CFindRSP = function(syntax) {
   CommandResponse.call(this, syntax);
   this.commandType = 0x8020;
 };
-
 util.inherits(CFindRSP, CommandResponse);
 
 CGetRSP = function(syntax) {
   CommandResponse.call(this, syntax);
   this.commandType = 0x8010;
 };
-
 util.inherits(CGetRSP, CommandResponse);
 
 CMoveRSP = function(syntax) {
   CommandResponse.call(this, syntax);
   this.commandType = 0x8021;
 };
-
 util.inherits(CMoveRSP, CommandResponse);
 
 CFindRQ = function(syntax) {
@@ -389,27 +377,39 @@ CFindRQ = function(syntax) {
   this.commandType = 0x20;
   this.contextUID = C.SOP_STUDY_ROOT_FIND;
 };
-
 util.inherits(CFindRQ, CommandMessage);
 
+CCancelRQ = function(syntax) {
+  CommandResponse.call(this, syntax);
+  this.commandType = 0x0fff;
+  this.contextUID = null;
+  this.dataSetPresent = false;
+};
+util.inherits(CCancelRQ, CommandResponse);
+
+CCancelMoveRQ = function(syntax) {
+  CommandResponse.call(this, syntax);
+  this.commandType = 0x0fff;
+  this.contextUID = null;
+  this.dataSetPresent = false;
+};
+util.inherits(CCancelMoveRQ, CommandResponse);
+
 CMoveRQ = function(syntax, destination) {
   CommandMessage.call(this, syntax);
   this.commandType = 0x21;
   this.contextUID = C.SOP_STUDY_ROOT_MOVE;
-    this.setDestination(destination || '');  
+  this.setDestination(destination || "");  
 };
-
 util.inherits(CMoveRQ, CommandMessage);
 
 CMoveRQ.prototype.setStore = function(cstr) {
   this.store = cstr;
-};  
+}  
 
 CMoveRQ.prototype.setDestination = function(dest) {
-    this.setElements({
+  this.setElement(0x00000600, dest);    
-        0x00000600: dest
+}
-    });    
-};
 
 CGetRQ = function(syntax) {
   CommandMessage.call(this, syntax);
@@ -417,32 +417,30 @@ CGetRQ = function(syntax) {
   this.contextUID = C.SOP_STUDY_ROOT_GET;
   this.store = null;
 };
-
 util.inherits(CGetRQ, CommandMessage);
 
 CGetRQ.prototype.setStore = function(cstr) {
   this.store = cstr;
-};
+}
 
 CStoreRQ = function(syntax) {
   CommandMessage.call(this, syntax);
   this.commandType = 0x01;
   this.contextUID = C.SOP_STUDY_ROOT_GET;  
 };
-
 util.inherits(CStoreRQ, CommandMessage);
 
 CStoreRQ.prototype.getOriginAETitle = function() {
   return this.getValue(0x00001030);
-};
+}
 
 CStoreRQ.prototype.getMoveMessageId = function() {
   return this.getValue(0x00001031);
-};
+}
 
 CStoreRQ.prototype.getSOPInstanceUID = function() {
   return this.getValue(0x00001000);
-};
+}
 
 CStoreRSP = function(syntax) {
   CommandResponse.call(this, syntax);
@@ -450,14 +448,12 @@ CStoreRSP = function(syntax) {
   this.contextUID = C.SOP_STUDY_ROOT_GET;
   this.dataSetPresent = false;
 };
-
 util.inherits(CStoreRSP, CommandResponse);
 
 CStoreRSP.prototype.setAffectedSOPInstanceUID = function(uid) {
   this.setElement(0x00001000, uid);
-};  
+}  
 
 CStoreRSP.prototype.getAffectedSOPInstanceUID = function(uid) {
   return this.getValue(0x00001000);
-};
+} 
- 

Packages/dimseservice/server/PDU.js

@@ -1,7 +1,7 @@
 PDU = function() {
   this.fields = [];
   this.lengthBytes = 4;  
-};
+}
 
 PDU.prototype.length = function(fields) {
   var len = 0;
@@ -9,11 +9,11 @@ PDU.prototype.length = function(fields) {
     len += !f.getFields ? f.length() : f.length(f.getFields());
   });
   return len;
-};
+}
 
 PDU.prototype.is = function(type) {
   return this.type == type;
-};
+}
 
 PDU.prototype.getFields = function(fields) {
   var len = this.lengthField(fields);
@@ -24,7 +24,7 @@ PDU.prototype.getFields = function(fields) {
   }
     
   return fields;
-};
+}
 
 PDU.prototype.lengthField = function(fields) {
   if (this.lengthBytes == 4) {
@@ -32,19 +32,19 @@ PDU.prototype.lengthField = function(fields) {
   } else if (this.lengthBytes == 2) {
     return new UInt16Field(this.length(fields));
   } else {
-        throw 'Invalid length bytes';
+    throw "Invalid length bytes";
   }
-};  
+}  
 
 PDU.prototype.read = function(stream) {
   stream.read(C.TYPE_HEX, 1);
   var length = stream.read(C.TYPE_UINT32);
   this.readBytes(stream, length);
-};
+}
 
 PDU.prototype.load = function(stream) {
-    return pduByStream(stream);
+  return PDU.createByStream(stream);
-};
+}
 
 PDU.prototype.loadPDV = function(stream, length) {
   if (stream.end()) return false;
@@ -59,32 +59,32 @@ PDU.prototype.loadPDV = function(stream, length) {
   }
 
   return pdvs;
-};
+}
 
 PDU.prototype.loadDicomMessage = function(stream, isCommand, isLast) {
-    var message = readMessage(stream, isCommand, isLast);
+  var message = DicomMessage.read(stream, isCommand, isLast);
   return message;
-};
+}
 
 PDU.prototype.stream = function() {
   var stream = new WriteStream(), 
       fields = this.getFields();
 
   // writing to buffer
-    fields.forEach(function(field) {
+  fields.forEach(function(field){
     field.write(stream);
   });
 
   return stream;
-};
+}
 
 PDU.prototype.buffer = function() {
   return this.stream().buffer();
-};
+}
 
 var interpretCommand = function(stream, isLast) {
   parseDicomMessage(stream);
-};
+}
 
 mergePDVs = function(pdvs) {
   var merges = [], count = pdvs.length, i = 0;
@@ -94,18 +94,40 @@ mergePDVs = function(pdvs) {
       while (!pdvs[j++].isLast && j < count) {
         pdvs[i].messageStream.concat(pdvs[j].messageStream);
       }
-
       merges.push(pdvs[i]);
       i = j;
     } else {
       merges.push(pdvs[i++]);
     }
   }
-
   return merges;
-};
+}
 
-pduByStream = function(stream) {
+PDU.typeToString = function(type) {
+  var pdu = null, typeNum = parseInt(type, 16);
+  //console.log("RECEIVED PDU-TYPE ", typeNum);
+  switch (typeNum) {
+    case 0x01 : pdu = 'ASSOCIATE-RQ'; break;
+    case 0x02 : pdu = 'ASSOCIATE-AC'; break;
+    case 0x04 : pdu = 'P-DATA-TF'; break;
+    case 0x06 : pdu = 'RELEASE-RP'; break;
+    case 0x07 : pdu = 'ASSOCIATE-ABORT'; break;
+    case 0x10 : pdu = 'APPLICATION-CONTEXT-ITEM'; break;
+    case 0x20 : pdu = 'PRESENTATION-CONTEXT-ITEM'; break;
+    case 0x21 : pdu = 'PRESENTATION-CONTEXT-ITEM-AC'; break;
+    case 0x30 : pdu = 'ABSTRACT-SYNTAX-ITEM'; break;
+    case 0x40 : pdu = 'TRANSFER-SYNTAX-ITEM'; break;
+    case 0x50 : pdu = 'USER-INFORMATION-ITEM'; break;
+    case 0x51 : pdu = 'MAXIMUM-LENGTH-ITEM'; break;
+    case 0x52 : pdu = 'IMPLEMENTATION-CLASS-UID-ITEM'; break;
+    case 0x55 : pdu = 'IMPLEMENTATION-VERSION-NAME-ITEM'; break;
+    default : break;
+  }
+
+  return pdu;
+}
+
+PDU.createByStream = function(stream) {
   if (stream.end()) return null;
 
   var pduType = stream.read(C.TYPE_HEX, 1), typeNum = parseInt(pduType, 16), pdu = null;
@@ -125,13 +147,13 @@ pduByStream = function(stream) {
     case 0x51 : pdu = new MaximumLengthItem(); break;
     case 0x52 : pdu = new ImplementationClassUIDItem(); break;
     case 0x55 : pdu = new ImplementationVersionNameItem(); break;
-        default : throw 'Unrecoginized pdu type ' + pduType; break;
+    default : throw "Unrecoginized pdu type " + pduType; break;
   }
   if (pdu)
     pdu.read(stream);
 
   return pdu;
-};
+}
 
 var nextItemIs = function(stream, pduType) {
   if (stream.end()) return false;
@@ -139,48 +161,47 @@ var nextItemIs = function(stream, pduType) {
   var nextType = stream.read(C.TYPE_HEX, 1);
   stream.increment(-1);
   return pduType == nextType;
-};
+}
 
 AssociateRQ = function() {
   PDU.call(this);
   this.type = C.ITEM_TYPE_PDU_ASSOCIATE_RQ;
   this.protocolVersion = 1;  
-};
+}
 
 util.inherits(AssociateRQ, PDU);
 
 AssociateRQ.prototype.setProtocolVersion = function(version) {
   this.protocolVersion = version;
-};
+}
 
 AssociateRQ.prototype.setCalledAETitle = function(title) {
   this.calledAETitle = title;
-};
+}
 
 AssociateRQ.prototype.setCallingAETitle = function(title) {
   this.callingAETitle = title;
-};
+}
 
 AssociateRQ.prototype.setApplicationContextItem = function(item) {
   this.applicationContextItem = item;
-};
+}
 
 AssociateRQ.prototype.setPresentationContextItems = function(items) {
   this.presentationContextItems = items;
-};
+}
 
 AssociateRQ.prototype.setUserInformationItem = function(item) {
   this.userInformationItem = item;
-};
+}
 
 AssociateRQ.prototype.allAccepted = function() {
   for (var i in this.presentationContextItems) {
     var item = this.presentationContextItems[i];
     if (!item.accepted()) return false;
   }
-
   return true;
-};
+}
 
 AssociateRQ.prototype.getFields = function() {
   var f = [
@@ -188,12 +209,12 @@ AssociateRQ.prototype.getFields = function() {
     new FilledField(this.calledAETitle, 16), new FilledField(this.callingAETitle, 16),
     new ReservedField(32), this.applicationContextItem
   ];
-    this.presentationContextItems.forEach(function(context) {
+  this.presentationContextItems.forEach(function(context){
     f.push(context);
   });
   f.push(this.userInformationItem);
   return AssociateRQ.super_.prototype.getFields.call(this, f);
-};
+}
 
 AssociateRQ.prototype.readBytes = function(stream, length) {
   this.type = C.ITEM_TYPE_PDU_ASSOCIATE_RQ;
@@ -212,16 +233,16 @@ AssociateRQ.prototype.readBytes = function(stream, length) {
   var presContexts = [];
   do {
     presContexts.push(this.load(stream));
-    } while (nextItemIs(stream, C.ITEM_TYPE_PRESENTATION_CONTEXT_AC));
+  } while (nextItemIs(stream, C.ITEM_TYPE_PRESENTATION_CONTEXT));
   this.setPresentationContextItems(presContexts);
 
   var userItem = this.load(stream);
   this.setUserInformationItem(userItem);
-};
+}
 
 AssociateRQ.prototype.buffer = function() {
   return AssociateRQ.super_.prototype.buffer.call(this);
-};
+}
 
 AssociateAC = function() {
   AssociateRQ.call(this);
@@ -246,24 +267,24 @@ AssociateAC.prototype.readBytes = function(stream, length) {
 
   var userItem = this.load(stream);
   this.setUserInformationItem(userItem);
-};
+}
 
 AssociateAbort = function() {
   this.type = C.ITEM_TYPE_PDU_AABORT;
   this.source = 1;
   this.reason = 0;
   PDU.call(this);  
-};
+}
 
 util.inherits(AssociateAbort, PDU);
 
 AssociateAbort.prototype.setSource = function(src) {
   this.source = src;
-};
+}
 
 AssociateAbort.prototype.setReason = function(reason) {
   this.reason = reason;
-};
+}
 
 AssociateAbort.prototype.readBytes = function(stream, length) {
   stream.increment(2);
@@ -273,14 +294,14 @@ AssociateAbort.prototype.readBytes = function(stream, length) {
 
   var reason = stream.read(C.TYPE_UINT8);
   this.setReason(reason);
-};
+}
 
 AssociateAbort.prototype.getFields = function() {
   return AssociateAbort.super_.prototype.getFields.call(this, [
     new ReservedField(), new ReservedField(), 
     new UInt8Field(this.source), new UInt8Field(this.reason)
   ]);
-};
+}
 
 ReleaseRQ = function() {
   this.type = C.ITEM_TYPE_PDU_RELEASE_RQ;
@@ -290,13 +311,13 @@ ReleaseRQ = function() {
 util.inherits(ReleaseRQ, PDU);
 
 ReleaseRQ.prototype.getFields = function() {
-    return ReleaseRQ.super_.prototype.getFields.call(this, [ new ReservedField(4) ]);
+  return ReleaseRQ.super_.prototype.getFields.call(this, [new ReservedField(4)]);
 };
 
 ReleaseRP = function() {
   this.type = C.ITEM_TYPE_PDU_RELEASE_RP;
   PDU.call(this);
-};
+}
 
 util.inherits(ReleaseRP, PDU);
 
@@ -305,54 +326,52 @@ ReleaseRP.prototype.readBytes = function(stream, length) {
 };
 
 ReleaseRP.prototype.getFields = function() {
-    return ReleaseRP.super_.prototype.getFields.call(this, [ new ReservedField(4) ]);
+  return ReleaseRP.super_.prototype.getFields.call(this, [new ReservedField(4)]);
-};
+}
 
 PDataTF = function() {
   this.type = C.ITEM_TYPE_PDU_PDATA;
   this.presentationDataValueItems = [];
   PDU.call(this);
-};
+}
-
 util.inherits(PDataTF, PDU);
 
 PDataTF.prototype.setPresentationDataValueItems = function(items) {
   this.presentationDataValueItems = items ? items : [];
-};
+}
 
 PDataTF.prototype.getFields = function() {
   var fields = this.presentationDataValueItems;
 
   return PDataTF.super_.prototype.getFields.call(this, fields);
-};
+}
 
 PDataTF.prototype.readBytes = function(stream, length) {
   var pdvs = this.loadPDV(stream, length);
   //let merges = mergePDVs(pdvs);
 
   this.setPresentationDataValueItems(pdvs);
-};
+}
 
 Item = function() {
   PDU.call(this);
   this.lengthBytes = 2;
 };
-
 util.inherits(Item, PDU);
 
 Item.prototype.read = function(stream) {
   stream.read(C.TYPE_HEX, 1);
   var length = stream.read(C.TYPE_UINT16);
   this.readBytes(stream, length);
-};  
+}  
 
 Item.prototype.write = function(stream) {
   stream.concat(this.stream());
-};
+}
 
 Item.prototype.getFields = function(fields) {
   return Item.super_.prototype.getFields.call(this, fields);
-};
+}
 
 PresentationDataValueItem = function(context) {
   this.type = null;
@@ -364,28 +383,27 @@ PresentationDataValueItem = function(context) {
 
   this.lengthBytes = 4;
 };
-
 util.inherits(PresentationDataValueItem, Item);
 
 PresentationDataValueItem.prototype.setContextId = function(id) {
   this.contextId = id;
-};
+}
 
 PresentationDataValueItem.prototype.setFlag = function(flag) {
   this.flag = flag;
-};
+}
 
 PresentationDataValueItem.prototype.setPresentationDataValue = function(pdv) {
   this.pdv = pdv;
-};
+}
 
 PresentationDataValueItem.prototype.setMessage = function(msg) {
   this.dataFragment = msg;
-};
+}
 
 PresentationDataValueItem.prototype.getMessage = function() {
   return this.dataFragment;
-};
+}
 
 PresentationDataValueItem.prototype.readBytes = function(stream, length) {
   this.contextId = stream.read(C.TYPE_UINT8);
@@ -395,79 +413,77 @@ PresentationDataValueItem.prototype.readBytes = function(stream, length) {
 
   //load dicom messages
   this.messageStream = stream.more(length - 2);
-};
+}
 
 PresentationDataValueItem.prototype.getFields = function() {
-    var fields = [ new UInt8Field(this.contextId) ];
+  var fields = [new UInt8Field(this.contextId)];
   //define header
   var messageHeader = (1 & this.dataFragment.type) | ((this.isLast ? 1 : 0) << 1);
   fields.push(new UInt8Field(messageHeader));
 
   fields.push(this.dataFragment);
-    /*var stream = new WriteStream();this.dataFragment.write(stream);
+/*var stream = new WriteStream();this.dataFragment.write(stream);
-    //var f = this.dataFragment.getFields();
+//var f = this.dataFragment.getFields();
-    //var wr = new WriteStream();f[0].setSyntax(this.dataFragment.syntax);f[0].write(wr);
+//var wr = new WriteStream();f[0].setSyntax(this.dataFragment.syntax);f[0].write(wr);
-    var rst = stream.toReadBuffer();
+var rst = stream.toReadBuffer();
-    rst.setEndian(C.LITTLE_ENDIAN);
+rst.setEndian(C.LITTLE_ENDIAN);
   var group = rst.read(C.TYPE_UINT16), 
       element = rst.read(C.TYPE_UINT16),
       tag = tagFromNumbers(group, element);
 
       console.log(tag.toString(), rst.read(C.TYPE_UINT32));*/
   return PresentationDataValueItem.super_.prototype.getFields.call(this, fields);
-};  
+}  
 
 ApplicationContextItem = function() {
   this.type = C.ITEM_TYPE_APPLICATION_CONTEXT;
   this.applicationContextName = C.APPLICATION_CONTEXT_NAME;
   Item.call(this);  
-};
+}
-
 util.inherits(ApplicationContextItem, Item);
 
 ApplicationContextItem.prototype.setApplicationContextName = function(name) {
   this.applicationContextName = name;
-};
+}
 
 ApplicationContextItem.prototype.getFields = function() {
-    return ApplicationContextItem.super_.prototype.getFields.call(this, [ new StringField(this.applicationContextName) ]);
+  return ApplicationContextItem.super_.prototype.getFields.call(this, [new StringField(this.applicationContextName)]);
-};
+}
 
 ApplicationContextItem.prototype.readBytes = function(stream, length) {
   var appContext = stream.read(C.TYPE_ASCII, length);
   this.setApplicationContextName(appContext);
-};
+}
 
 ApplicationContextItem.prototype.buffer = function() {
   return ApplicationContextItem.super_.prototype.buffer.call(this);
-};
+}
 
 PresentationContextItem = function() {
   this.type = C.ITEM_TYPE_PRESENTATION_CONTEXT;
   Item.call(this);
 };
-
 util.inherits(PresentationContextItem, Item);
 
 PresentationContextItem.prototype.setPresentationContextID = function(id) {
   this.presentationContextID = id;
-};
+}
 
 PresentationContextItem.prototype.setAbstractSyntaxItem = function(item) {
   this.abstractSyntaxItem = item;
-};
+}
 
 PresentationContextItem.prototype.setTransferSyntaxesItems = function(items) {
   this.transferSyntaxesItems = items;
-};
+}
 
 PresentationContextItem.prototype.setResultReason = function(reason) {
   this.resultReason = reason;
-};
+}
 
 PresentationContextItem.prototype.accepted = function() {
   return this.resultReason == 0;
-};
+}
 
 PresentationContextItem.prototype.readBytes = function(stream, length) {
   var contextId = stream.read(C.TYPE_UINT8);
@@ -484,28 +500,27 @@ PresentationContextItem.prototype.readBytes = function(stream, length) {
     transContexts.push(this.load(stream));
   } while (nextItemIs(stream, C.ITEM_TYPE_TRANSFER_CONTEXT));
   this.setTransferSyntaxesItems(transContexts);
-};
+}
 
 PresentationContextItem.prototype.getFields = function() {
   var f = [
     new UInt8Field(this.presentationContextID), 
     new ReservedField(), new ReservedField(), new ReservedField(), this.abstractSyntaxItem
   ];
-    this.transferSyntaxesItems.forEach(function(syntaxItem) {
+  this.transferSyntaxesItems.forEach(function(syntaxItem){
     f.push(syntaxItem);
   });
   return PresentationContextItem.super_.prototype.getFields.call(this, f);  
-};
+}
 
 PresentationContextItem.prototype.buffer = function() {
   return PresentationContextItem.super_.prototype.buffer.call(this);
-};
+}
 
 PresentationContextItemAC = function() {
   this.type = C.ITEM_TYPE_PRESENTATION_CONTEXT_AC;
   Item.call(this);
 };
-
 util.inherits(PresentationContextItemAC, PresentationContextItem);
 
 PresentationContextItemAC.prototype.readBytes = function(stream, length) {
@@ -517,67 +532,64 @@ PresentationContextItemAC.prototype.readBytes = function(stream, length) {
   stream.increment(1);
 
   var transItem = this.load(stream);
-    this.setTransferSyntaxesItems([ transItem ]);
+  this.setTransferSyntaxesItems([transItem]);
-};
+}
 
 AbstractSyntaxItem = function() {
   this.type = C.ITEM_TYPE_ABSTRACT_CONTEXT;
   Item.call(this);  
-};
+}
-
 util.inherits(AbstractSyntaxItem, Item);
 
 AbstractSyntaxItem.prototype.setAbstractSyntaxName = function(name) {
   this.abstractSyntaxName = name;
-};
+}
 
 AbstractSyntaxItem.prototype.getFields = function() {
-    return AbstractSyntaxItem.super_.prototype.getFields.call(this, [ new StringField(this.abstractSyntaxName) ]);
+  return AbstractSyntaxItem.super_.prototype.getFields.call(this, [new StringField(this.abstractSyntaxName)]);
-};  
+}  
 
 AbstractSyntaxItem.prototype.buffer = function() {
   return AbstractSyntaxItem.super_.prototype.buffer.call(this);
-};
+}
 
 AbstractSyntaxItem.prototype.readBytes = function(stream, length) {
   var name = stream.read(C.TYPE_ASCII, length);
   this.setAbstractSyntaxName(name);
-};
+}
 
 TransferSyntaxItem = function() {
   this.type = C.ITEM_TYPE_TRANSFER_CONTEXT;
   Item.call(this);
 };
-
 util.inherits(TransferSyntaxItem, Item);
 
 TransferSyntaxItem.prototype.setTransferSyntaxName = function(name) {
   this.transferSyntaxName = name;
-};
+}
 
 TransferSyntaxItem.prototype.readBytes = function(stream, length) {
   var transfer = stream.read(C.TYPE_ASCII, length);
   this.setTransferSyntaxName(transfer);
-};
+}
 
 TransferSyntaxItem.prototype.getFields = function() {
-    return TransferSyntaxItem.super_.prototype.getFields.call(this, [ new StringField(this.transferSyntaxName) ]);
+  return TransferSyntaxItem.super_.prototype.getFields.call(this, [new StringField(this.transferSyntaxName)]);
-};
+}
 
 TransferSyntaxItem.prototype.buffer = function() {
   return TransferSyntaxItem.super_.prototype.buffer.call(this);
-};
+}
 
 UserInformationItem = function() {
   this.type = C.ITEM_TYPE_USER_INFORMATION;
   Item.call(this);
 };
-
 util.inherits(UserInformationItem, Item);
 
 UserInformationItem.prototype.setUserDataItems = function(items) {
   this.userDataItems = items;
-};
+}
 
 UserInformationItem.prototype.readBytes = function(stream, length) {
   var items = [], pdu = this.load(stream);
@@ -586,90 +598,87 @@ UserInformationItem.prototype.readBytes = function(stream, length) {
     items.push(pdu);
   } while (pdu = this.load(stream));
   this.setUserDataItems(items);
-};
+}
 
 UserInformationItem.prototype.getFields = function() {
   var f = [];
-    this.userDataItems.forEach(function(userData) {
+  this.userDataItems.forEach(function(userData){
     f.push(userData);
   });
   return UserInformationItem.super_.prototype.getFields.call(this, f);
-};
+}
 
 UserInformationItem.prototype.buffer = function() {
   return UserInformationItem.super_.prototype.buffer.call(this);
-};
+}
 
 ImplementationClassUIDItem = function() {
   this.type = C.ITEM_TYPE_IMPLEMENTATION_UID;
   Item.call(this);  
-};
+}
-
 util.inherits(ImplementationClassUIDItem, Item);
 
 ImplementationClassUIDItem.prototype.setImplementationClassUID = function(id) {
   this.implementationClassUID = id;
-};
+}
 
 ImplementationClassUIDItem.prototype.readBytes = function(stream, length) {
   var uid = stream.read(C.TYPE_ASCII, length);
   this.setImplementationClassUID(uid);
-};
+}
 
 ImplementationClassUIDItem.prototype.getFields = function() {
-    return ImplementationClassUIDItem.super_.prototype.getFields.call(this, [ new StringField(this.implementationClassUID) ]);
+  return ImplementationClassUIDItem.super_.prototype.getFields.call(this, [new StringField(this.implementationClassUID)]);
-};
+}
 
 ImplementationClassUIDItem.prototype.buffer = function() {
   return ImplementationClassUIDItem.super_.prototype.buffer.call(this);
-};
+}
 
 ImplementationVersionNameItem = function() {
   this.type = C.ITEM_TYPE_IMPLEMENTATION_VERSION;
   Item.call(this);  
-};
+}
-
 util.inherits(ImplementationVersionNameItem, Item);
 
 ImplementationVersionNameItem.prototype.setImplementationVersionName = function(name) {
   this.implementationVersionName = name;
-};
+}
 
 ImplementationVersionNameItem.prototype.readBytes = function(stream, length) {
   var name = stream.read(C.TYPE_ASCII, length);
   this.setImplementationVersionName(name);
-};
+}
 
 ImplementationVersionNameItem.prototype.getFields = function() {
-    return ImplementationVersionNameItem.super_.prototype.getFields.call(this, [ new StringField(this.implementationVersionName) ]);
+  return ImplementationVersionNameItem.super_.prototype.getFields.call(this, [new StringField(this.implementationVersionName)]);
-};
+}
 
 ImplementationVersionNameItem.prototype.buffer = function() {
   return ImplementationVersionNameItem.super_.prototype.buffer.call(this);
-};
+}
 
 MaximumLengthItem = function() {
   this.type = C.ITEM_TYPE_MAXIMUM_LENGTH;
   this.maximumLengthReceived = 32768;
   Item.call(this);  
-};
+}
-
 util.inherits(MaximumLengthItem, Item);
 
 MaximumLengthItem.prototype.setMaximumLengthReceived = function(length) {
   this.maximumLengthReceived = length;
-};
+}
 
 MaximumLengthItem.prototype.readBytes = function(stream, length) {
   var l = stream.read(C.TYPE_UINT32);
   this.setMaximumLengthReceived(l);
-};
+}
 
 MaximumLengthItem.prototype.getFields = function() {
-    return MaximumLengthItem.super_.prototype.getFields.call(this, [ new UInt32Field(this.maximumLengthReceived) ]);
+  return MaximumLengthItem.super_.prototype.getFields.call(this, [new UInt32Field(this.maximumLengthReceived)]);
-};
+}
 
 MaximumLengthItem.prototype.buffer = function() {
   return MaximumLengthItem.super_.prototype.buffer.call(this);
-};
+}
 

Packages/dimseservice/server/RWStream.js

@@ -20,7 +20,7 @@ calcLength = function(type, value) {
     default :break;
   }
   return size;
-};
+}
 
 var RWStream = function() {
   this.endian = C.BIG_ENDIAN;
@@ -28,19 +28,19 @@ var RWStream = function() {
 
 RWStream.prototype.setEndian = function(endian) {   
   this.endian = endian;
-};
+}
 
 RWStream.prototype.getEncoding = function(type) {
   return RWStream.encodings[type];
-};
+}
 
 RWStream.prototype.getWriteType = function(type) {
   return RWStream.writes[this.endian][type];
-};
+}
 
 RWStream.prototype.getReadType = function(type) {
   return RWStream.reads[this.endian][type];
-};  
+}  
 
 WriteStream = function() {
   RWStream.call(this);
@@ -48,7 +48,7 @@ WriteStream = function() {
   this.rawBuffer = new Buffer(this.defaultBufferSize);
   this.offset = 0;
   this.contentSize = 0;
-};
+}
 
 util.inherits(WriteStream, RWStream);
 
@@ -57,15 +57,15 @@ WriteStream.prototype.increment = function(add) {
   if (this.offset > this.contentSize) {
     this.contentSize = this.offset;
   }
-};
+}
 
 WriteStream.prototype.size = function() {
   return this.contentSize;
-};
+}
 
 WriteStream.prototype.skip = function(amount) {
   this.increment(amount);
-};
+}
 
 WriteStream.prototype.checkSize = function(length) {
   if (this.offset + length > this.rawBuffer.length) {
@@ -75,15 +75,15 @@ WriteStream.prototype.checkSize = function(length) {
     this.rawBuffer.copy(newBuffer, 0, 0, this.contentSize);
     this.rawBuffer = newBuffer;
   }
-};
+}
 
 WriteStream.prototype.writeToBuffer = function(type, value, length) {
-    if (value === '' || value === null) return;
+  if (value === "" || value === null) return;
   
   this.checkSize(length);
   this.rawBuffer[this.getWriteType(type)](value, this.offset);
   this.increment(length);
-};
+}
 
 WriteStream.prototype.write = function(type, value) {
   if (isString(type)) {
@@ -91,28 +91,28 @@ WriteStream.prototype.write = function(type, value) {
   } else {
     this.writeToBuffer(type, value, calcLength(type));
   }
-};
+}
 
 WriteStream.prototype.writeString = function(string, type) {
   var encoding = this.getEncoding(type), length = Buffer.byteLength(string, encoding);
   this.rawBuffer.write(string, this.offset, length, encoding);
   this.increment(length);
-};
+}
 
 WriteStream.prototype.buffer = function() {
   return this.rawBuffer.slice(0, this.contentSize);
-};
+}
 
 WriteStream.prototype.toReadBuffer = function() {
   return new ReadStream(this.buffer());
-};
+}
 
 WriteStream.prototype.concat = function(newStream) {
   var newSize = this.size() + newStream.size();
-    this.rawBuffer = Buffer.concat([ this.buffer(), newStream.buffer() ], newSize);
+  this.rawBuffer = Buffer.concat([this.buffer(), newStream.buffer()], newSize);
   this.contentSize = newSize;
   this.offset = newSize;
-};
+}
 
 ReadStream = function(buffer) {
   RWStream.call(this);
@@ -124,26 +124,26 @@ util.inherits(ReadStream, RWStream);
 
 ReadStream.prototype.size = function() {
   return this.rawBuffer.length;
-};
+}
 
 ReadStream.prototype.increment = function(add) {
   this.offset += add;
-};  
+}  
 
 ReadStream.prototype.more = function(length) {
   var newBuf = this.rawBuffer.slice(this.offset, this.offset + length);
   this.increment(length);
   return new ReadStream(newBuf);
-};
+}
 
 ReadStream.prototype.reset = function() {
   this.offset = 0;
   return this;
-};
+}
 
 ReadStream.prototype.end = function() {
   return this.offset >= this.size();
-};
+}
 
 ReadStream.prototype.readFromBuffer = function(type, length) {
   //this.checkSize(length);
@@ -151,7 +151,7 @@ ReadStream.prototype.readFromBuffer = function(type, length) {
   var value = this.rawBuffer[this.getReadType(type)](this.offset);
   this.increment(length);
   return value;
-};  
+}  
 
 ReadStream.prototype.read = function(type, length) {
   var value = null;
@@ -162,68 +162,68 @@ ReadStream.prototype.read = function(type, length) {
   }
 
   return value;
-};
+}
 
 ReadStream.prototype.readString = function(length, type) {
   var encoding = this.getEncoding(type), 
       str = this.rawBuffer.toString(encoding, this.offset, this.offset + length);
   this.increment(length);
   return str;
-};  
+}  
 
 ReadStream.prototype.buffer = function() {
   return this.rawBuffer;
-};
+}
 
 ReadStream.prototype.concat = function(newStream) {
   var newSize = this.size() + newStream.size();
-    this.rawBuffer = Buffer.concat([ this.buffer(), newStream.buffer() ], newSize);
+  this.rawBuffer = Buffer.concat([this.buffer(), newStream.buffer()], newSize);
   this.contentSize = newSize;
   this.offset = newSize;
-};  
+}  
 
 RWStream.writes = {};
 RWStream.writes[C.BIG_ENDIAN] = {};
-RWStream.writes[C.BIG_ENDIAN][C.TYPE_UINT8] = 'writeUInt8';
+RWStream.writes[C.BIG_ENDIAN][C.TYPE_UINT8] = "writeUInt8";
-RWStream.writes[C.BIG_ENDIAN][C.TYPE_UINT16] = 'writeUInt16BE';
+RWStream.writes[C.BIG_ENDIAN][C.TYPE_UINT16] = "writeUInt16BE";
-RWStream.writes[C.BIG_ENDIAN][C.TYPE_UINT32] = 'writeUInt32BE';
+RWStream.writes[C.BIG_ENDIAN][C.TYPE_UINT32] = "writeUInt32BE";
-RWStream.writes[C.BIG_ENDIAN][C.TYPE_INT8] = 'writeInt8';
+RWStream.writes[C.BIG_ENDIAN][C.TYPE_INT8] = "writeInt8";
-RWStream.writes[C.BIG_ENDIAN][C.TYPE_INT16] = 'writeInt16BE';
+RWStream.writes[C.BIG_ENDIAN][C.TYPE_INT16] = "writeInt16BE";
-RWStream.writes[C.BIG_ENDIAN][C.TYPE_INT32] = 'writeInt32BE';
+RWStream.writes[C.BIG_ENDIAN][C.TYPE_INT32] = "writeInt32BE";
-RWStream.writes[C.BIG_ENDIAN][C.TYPE_FLOAT] = 'writeFloatBE';
+RWStream.writes[C.BIG_ENDIAN][C.TYPE_FLOAT] = "writeFloatBE";
-RWStream.writes[C.BIG_ENDIAN][C.TYPE_DOUBLE] = 'writeDoubleBE';
+RWStream.writes[C.BIG_ENDIAN][C.TYPE_DOUBLE] = "writeDoubleBE";
 
 RWStream.writes[C.LITTLE_ENDIAN] = {};
-RWStream.writes[C.LITTLE_ENDIAN][C.TYPE_UINT8] = 'writeUInt8';
+RWStream.writes[C.LITTLE_ENDIAN][C.TYPE_UINT8] = "writeUInt8";
-RWStream.writes[C.LITTLE_ENDIAN][C.TYPE_UINT16] = 'writeUInt16LE';
+RWStream.writes[C.LITTLE_ENDIAN][C.TYPE_UINT16] = "writeUInt16LE";
-RWStream.writes[C.LITTLE_ENDIAN][C.TYPE_UINT32] = 'writeUInt32LE';
+RWStream.writes[C.LITTLE_ENDIAN][C.TYPE_UINT32] = "writeUInt32LE";
-RWStream.writes[C.LITTLE_ENDIAN][C.TYPE_INT8] = 'writeInt8';
+RWStream.writes[C.LITTLE_ENDIAN][C.TYPE_INT8] = "writeInt8";
-RWStream.writes[C.LITTLE_ENDIAN][C.TYPE_INT16] = 'writeInt16LE';
+RWStream.writes[C.LITTLE_ENDIAN][C.TYPE_INT16] = "writeInt16LE";
-RWStream.writes[C.LITTLE_ENDIAN][C.TYPE_INT32] = 'writeInt32LE'; 
+RWStream.writes[C.LITTLE_ENDIAN][C.TYPE_INT32] = "writeInt32LE"; 
-RWStream.writes[C.LITTLE_ENDIAN][C.TYPE_FLOAT] = 'writeFloatLE';
+RWStream.writes[C.LITTLE_ENDIAN][C.TYPE_FLOAT] = "writeFloatLE";
-RWStream.writes[C.LITTLE_ENDIAN][C.TYPE_DOUBLE] = 'writeDoubleLE';
+RWStream.writes[C.LITTLE_ENDIAN][C.TYPE_DOUBLE] = "writeDoubleLE";
 
 RWStream.reads = {};
 RWStream.reads[C.BIG_ENDIAN] = {};
-RWStream.reads[C.BIG_ENDIAN][C.TYPE_UINT8] = 'readUInt8';
+RWStream.reads[C.BIG_ENDIAN][C.TYPE_UINT8] = "readUInt8";
-RWStream.reads[C.BIG_ENDIAN][C.TYPE_UINT16] = 'readUInt16BE';
+RWStream.reads[C.BIG_ENDIAN][C.TYPE_UINT16] = "readUInt16BE";
-RWStream.reads[C.BIG_ENDIAN][C.TYPE_UINT32] = 'readUInt32BE';
+RWStream.reads[C.BIG_ENDIAN][C.TYPE_UINT32] = "readUInt32BE";
-RWStream.reads[C.BIG_ENDIAN][C.TYPE_INT8] = 'readInt8';
+RWStream.reads[C.BIG_ENDIAN][C.TYPE_INT8] = "readInt8";
-RWStream.reads[C.BIG_ENDIAN][C.TYPE_INT16] = 'readInt16BE';
+RWStream.reads[C.BIG_ENDIAN][C.TYPE_INT16] = "readInt16BE";
-RWStream.reads[C.BIG_ENDIAN][C.TYPE_INT32] = 'readInt32BE';
+RWStream.reads[C.BIG_ENDIAN][C.TYPE_INT32] = "readInt32BE";
-RWStream.reads[C.BIG_ENDIAN][C.TYPE_FLOAT] = 'readFloatBE';
+RWStream.reads[C.BIG_ENDIAN][C.TYPE_FLOAT] = "readFloatBE";
-RWStream.reads[C.BIG_ENDIAN][C.TYPE_DOUBLE] = 'readDoubleBE';
+RWStream.reads[C.BIG_ENDIAN][C.TYPE_DOUBLE] = "readDoubleBE";
 
 RWStream.reads[C.LITTLE_ENDIAN] = {};
-RWStream.reads[C.LITTLE_ENDIAN][C.TYPE_UINT8] = 'readUInt8';
+RWStream.reads[C.LITTLE_ENDIAN][C.TYPE_UINT8] = "readUInt8";
-RWStream.reads[C.LITTLE_ENDIAN][C.TYPE_UINT16] = 'readUInt16LE';
+RWStream.reads[C.LITTLE_ENDIAN][C.TYPE_UINT16] = "readUInt16LE";
-RWStream.reads[C.LITTLE_ENDIAN][C.TYPE_UINT32] = 'readUInt32LE';
+RWStream.reads[C.LITTLE_ENDIAN][C.TYPE_UINT32] = "readUInt32LE";
-RWStream.reads[C.LITTLE_ENDIAN][C.TYPE_INT8] = 'readInt8';
+RWStream.reads[C.LITTLE_ENDIAN][C.TYPE_INT8] = "readInt8";
-RWStream.reads[C.LITTLE_ENDIAN][C.TYPE_INT16] = 'readInt16LE';
+RWStream.reads[C.LITTLE_ENDIAN][C.TYPE_INT16] = "readInt16LE";
-RWStream.reads[C.LITTLE_ENDIAN][C.TYPE_INT32] = 'readInt32LE';
+RWStream.reads[C.LITTLE_ENDIAN][C.TYPE_INT32] = "readInt32LE";
-RWStream.reads[C.LITTLE_ENDIAN][C.TYPE_FLOAT] = 'readFloatLE';
+RWStream.reads[C.LITTLE_ENDIAN][C.TYPE_FLOAT] = "readFloatLE";
-RWStream.reads[C.LITTLE_ENDIAN][C.TYPE_DOUBLE] = 'readDoubleLE';
+RWStream.reads[C.LITTLE_ENDIAN][C.TYPE_DOUBLE] = "readDoubleLE";
 
 RWStream.encodings = {};
-RWStream.encodings[C.TYPE_HEX] = 'hex';
+RWStream.encodings[C.TYPE_HEX] = "hex";
-RWStream.encodings[C.TYPE_ASCII] = 'ascii';
+RWStream.encodings[C.TYPE_ASCII] = "ascii";

Packages/dimseservice/server/constants.js

@@ -1,98 +1,99 @@
 C = {
-    IMPLEM_UID: '1.2.840.0.1.3680045.8.641',
+  IMPLEM_UID : "1.2.840.0.1.3680045.8.641",
-    IMPLEM_VERSION: 'OHIF-DCM-0.1',
+  IMPLEM_VERSION : "OHIF-DCM-0.1",
-    APPLICATION_CONTEXT_NAME: '1.2.840.10008.3.1.1.1',
+  DEFAULT_MAX_PACKAGE_SIZE : 32768,
-    PROTOCOL_VERSION: '0001',
+  APPLICATION_CONTEXT_NAME : "1.2.840.10008.3.1.1.1",
-    ITEM_TYPE_RESERVED: '00',
+  PROTOCOL_VERSION : "0001",
-    ITEM_TYPE_APPLICATION_CONTEXT: '10',
+  ITEM_TYPE_RESERVED : "00",
-    ITEM_TYPE_PDU_ASSOCIATE_RQ: '01',
+  ITEM_TYPE_APPLICATION_CONTEXT : "10",
-    ITEM_TYPE_PDU_ASSOCIATE_AC: '02',
+  ITEM_TYPE_PDU_ASSOCIATE_RQ : "01",
-    ITEM_TYPE_PDU_PDATA: '04',
+  ITEM_TYPE_PDU_ASSOCIATE_AC : "02",
-    ITEM_TYPE_PDU_RELEASE_RQ: '05',
+  ITEM_TYPE_PDU_PDATA : "04",
-    ITEM_TYPE_PDU_RELEASE_RP: '06',
+  ITEM_TYPE_PDU_RELEASE_RQ : "05",
-    ITEM_TYPE_PDU_AABORT: '07',
+  ITEM_TYPE_PDU_RELEASE_RP : "06",
-    ITEM_TYPE_PRESENTATION_CONTEXT: '20',
+  ITEM_TYPE_PDU_AABORT : "07",
-    ITEM_TYPE_PRESENTATION_CONTEXT_AC: '21',
+  ITEM_TYPE_PRESENTATION_CONTEXT : "20",
-    ITEM_TYPE_ABSTRACT_CONTEXT: '30',
+  ITEM_TYPE_PRESENTATION_CONTEXT_AC : "21",
-    ITEM_TYPE_TRANSFER_CONTEXT: '40',
+  ITEM_TYPE_ABSTRACT_CONTEXT : "30",
-    ITEM_TYPE_USER_INFORMATION: '50',
+  ITEM_TYPE_TRANSFER_CONTEXT : "40",
-    ITEM_TYPE_MAXIMUM_LENGTH: '51',
+  ITEM_TYPE_USER_INFORMATION : "50",
-    ITEM_TYPE_IMPLEMENTATION_UID: '52',
+  ITEM_TYPE_MAXIMUM_LENGTH : "51",
-    ITEM_TYPE_IMPLEMENTATION_VERSION: '55',
+  ITEM_TYPE_IMPLEMENTATION_UID : "52",
-    IMPLICIT_LITTLE_ENDIAN: '1.2.840.10008.1.2',
+  ITEM_TYPE_IMPLEMENTATION_VERSION : "55",
-    EXPLICIT_LITTLE_ENDIAN: '1.2.840.10008.1.2.1',
+  IMPLICIT_LITTLE_ENDIAN : "1.2.840.10008.1.2",
-    EXPLICIT_BIG_ENDIAN: '1.2.840.10008.1.2.2',
+  EXPLICIT_LITTLE_ENDIAN : "1.2.840.10008.1.2.1",
-    SOP_PATIENT_ROOT_FIND: '1.2.840.10008.5.1.4.1.2.1.1',
+  EXPLICIT_BIG_ENDIAN : "1.2.840.10008.1.2.2",
-    SOP_PATIENT_ROOT_MOVE: '1.2.840.10008.5.1.4.1.2.1.2',
+  SOP_PATIENT_ROOT_FIND : "1.2.840.10008.5.1.4.1.2.1.1",
-    SOP_PATIENT_ROOT_GET: '1.2.840.10008.5.1.4.1.2.1.3',
+  SOP_PATIENT_ROOT_MOVE : "1.2.840.10008.5.1.4.1.2.1.2",
-    SOP_STUDY_ROOT_FIND: '1.2.840.10008.5.1.4.1.2.2.1',
+  SOP_PATIENT_ROOT_GET : "1.2.840.10008.5.1.4.1.2.1.3",
-    SOP_STUDY_ROOT_MOVE: '1.2.840.10008.5.1.4.1.2.2.2',
+  SOP_STUDY_ROOT_FIND : "1.2.840.10008.5.1.4.1.2.2.1",
-    SOP_STUDY_ROOT_GET: '1.2.840.10008.5.1.4.1.2.2.3',
+  SOP_STUDY_ROOT_MOVE : "1.2.840.10008.5.1.4.1.2.2.2",
-    SOP_VERIFICATION: '1.2.840.10008.1.1',
+  SOP_STUDY_ROOT_GET : "1.2.840.10008.5.1.4.1.2.2.3",
-    SOP_HANGING_PROTOCOL_FIND: '1.2.840.10008.5.1.4.38.2',
+  SOP_VERIFICATION : "1.2.840.10008.1.1",
-    SOP_MR_IMAGE_STORAGE: '1.2.840.10008.5.1.4.1.1.4',
+  SOP_HANGING_PROTOCOL_FIND : "1.2.840.10008.5.1.4.38.2",
-    TYPE_ASCII: 1,
+  SOP_MR_IMAGE_STORAGE : "1.2.840.10008.5.1.4.1.1.4",
-    TYPE_HEX: 2,
+  TYPE_ASCII : 1,
-    TYPE_UINT8: 3,
+  TYPE_HEX : 2,
-    TYPE_UINT16: 4,
+  TYPE_UINT8 : 3,
-    TYPE_UINT32: 5,
+  TYPE_UINT16 : 4,
-    TYPE_COMPOSITE: 6,
+  TYPE_UINT32 : 5,
-    TYPE_FLOAT: 7,
+  TYPE_COMPOSITE : 6,
-    TYPE_DOUBLE: 8,
+  TYPE_FLOAT : 7,
-    TYPE_INT8: 9,
+  TYPE_DOUBLE : 8,
-    TYPE_INT16: 10,
+  TYPE_INT8 : 9,
-    TYPE_INT32: 11,  
+  TYPE_INT16 : 10,
-    RESULT_REASON_ACCEPTANCE: 0,
+  TYPE_INT32 : 11,  
-    RESULT_REASON_USER_REJECTION: 1,
+  RESULT_REASON_ACCEPTANCE : 0,
-    RESULT_REASON_NO_REASON: 2,
+  RESULT_REASON_USER_REJECTION : 1,
-    RESULT_REASON_ABSTRACT_NOT_SUPPORTED: 3,
+  RESULT_REASON_NO_REASON :2,
-    RESULT_REASON_TRANSFER_NOT_SUPPORTED: 4,
+  RESULT_REASON_ABSTRACT_NOT_SUPPORTED : 3,
-    DEFAULT_MESSAGE_ID: 1,
+  RESULT_REASON_TRANSFER_NOT_SUPPORTED : 4,
-    LITTLE_ENDIAN: 1,
+  DEFAULT_MESSAGE_ID : 1,
-    BIG_ENDIAN: 2,
+  LITTLE_ENDIAN : 1,
-    VM_SINGLE: 1,
+  BIG_ENDIAN : 2,
-    VM_TWO: 3,
+  VM_SINGLE :1,
-    VM_THREE: 4,
+  VM_TWO : 3,
-    VM_FOUR: 5,
+  VM_THREE : 4,
-    VM_1N: 6,
+  VM_FOUR : 5,
-    VM_2N: 7,
+  VM_1N : 6,
-    VM_3N: 8,
+  VM_2N :7,
-    VM_6N: 9,
+  VM_3N :8,
-    VM_3_3N: 10,
+  VM_6N :9,
-    VM_2_2N: 11,
+  VM_3_3N : 10,
-    VM_16: 12,
+  VM_2_2N : 11,
-    VM_1_2: 13,
+  VM_16 : 12,
-    VM_1_3: 18,
+  VM_1_2 : 13,
-    VM_SIX: 14,
+  VM_1_3 : 18,
-    VM_NINE: 15,
+  VM_SIX : 14,
-    VM_1_32: 16,
+  VM_NINE : 15,
-    VM_1_99: 17,
+  VM_1_32 : 16,
-    PRIORITY_LOW: 0x2,
+  VM_1_99 : 17,
-    PRIORITY_MEDIUM: 0x0,
+  PRIORITY_LOW : 0x2,
-    PRIORITY_HIGH: 0x1,
+  PRIORITY_MEDIUM : 0x0,
-    DATA_SET_PRESENT: 1,
+  PRIORITY_HIGH : 0x1,
-    DATE_SET_ABSENCE: 0x0101,
+  DATA_SET_PRESENT : 1,
-    DATA_TYPE_COMMAND: 1,
+  DATE_SET_ABSENCE : 0x0101,
-    DATA_TYPE_DATA: 0,
+  DATA_TYPE_COMMAND : 1,
-    DATA_IS_LAST: 1,
+  DATA_TYPE_DATA : 0,
-    DATA_NOT_LAST: 0,
+  DATA_IS_LAST : 1,
-    SOURCE_SERVICE_USER: 0,
+  DATA_NOT_LAST : 0,
-    SOURCE_SERVICE_PROVIDER: 2,
+  SOURCE_SERVICE_USER : 0,
-    QUERY_RETRIEVE_LEVEL_PATIENT: 'PATIENT',
+  SOURCE_SERVICE_PROVIDER : 2,
-    QUERY_RETRIEVE_LEVEL_STUDY: 'STUDY',
+  QUERY_RETRIEVE_LEVEL_PATIENT : "PATIENT",
-    QUERY_RETRIEVE_LEVEL_SERIES: 'SERIES',
+  QUERY_RETRIEVE_LEVEL_STUDY : "STUDY",
-    QUERY_RETRIEVE_LEVEL_IMAGE: 'IMAGE',
+  QUERY_RETRIEVE_LEVEL_SERIES : "SERIES",
-    VALUE_LENGTH_UNDEFINED: 0xffffffff,
+  QUERY_RETRIEVE_LEVEL_IMAGE : "IMAGE",
-    STATUS_SUCCESS: 0x0000,
+  VALUE_LENGTH_UNDEFINED : 0xffffffff,
-    STATUS_CANCEL: 0xfe00,
+  STATUS_SUCCESS : 0x0000,
-    STATUS_CFIND_CONT_OK: 0xff00,
+  STATUS_CANCEL : 0xfe00,
-    STATUS_CFIND_CONT_WARN: 0xff01,
+  STATUS_CFIND_CONT_OK : 0xff00,
-    COMMAND_C_GET_RSP: 0x8010,
+  STATUS_CFIND_CONT_WARN : 0xff01,
-    COMMAND_C_MOVE_RSP: 0x8021,
+  COMMAND_C_GET_RSP : 0x8010,
-    COMMAND_C_GET_RQ: 0x10,
+  COMMAND_C_MOVE_RSP : 0x8021,
-    COMMAND_C_STORE_RQ: 0x01,
+  COMMAND_C_GET_RQ : 0x10,
-    COMMAND_C_FIND_RSP: 0x8020,
+  COMMAND_C_STORE_RQ : 0x01,
-    COMMAND_C_MOVE_RQ: 0x21,
+  COMMAND_C_FIND_RSP : 0x8020,
-    COMMAND_C_FIND_RQ: 0x20,
+  COMMAND_C_MOVE_RQ : 0x21,
-    COMMAND_C_STORE_RSP: 0x8001
+  COMMAND_C_FIND_RQ : 0x20,
+  COMMAND_C_STORE_RSP : 0x8001
 };

Packages/dimseservice/server/require.js

@@ -1 +1 @@
-util = Npm.require('util');
+util = Npm.require("util");

config/orthancDIMSE.json

@@ -18,10 +18,10 @@
       }
     ]
   },
-  "dimse" : {
+  "dimse" : [{
     "host" : "localhost",
     "port" : 4242,
-    "hostAE" : "ORTHANC"
+    "aeTitle" : "ORTHANCLOCAL"
-  },
+  }],
   "defaultServiceType": "dimse"
 }