@azteam/express 1.2.500 → 1.2.502

package/lib/Server.js

@@ -453,22 +453,33 @@ var Server = /*#__PURE__*/function () {
         httpServer.on('listening', function () {
           console.log('listening', "ServerIO start at http://localhost:".concat(httpServer.address().port));
         });
-        var listenEventList = [];
-        var staticEventList = [];
+        var listEventListen = [];
         var msg = [];
         _lodash["default"].map(socketEvents, function (data) {
           var event = data.event;
           var eventName = data.name;
           var eventVersion = data.version;
-          var listPublicEvent = event.__getPublicEvents();
-          _lodash["default"].map(listPublicEvent, function (method) {
+          var _event$__getPublicEve = event.__getPublicEvents(),
+            lstEvListen = _event$__getPublicEve.listen,
+            listEventStatic = _event$__getPublicEve["static"];
+          _lodash["default"].map(lstEvListen, function (method) {
             var name = method.name,
               type = method.type;
-            if (type === 'listen') {
-              listenEventList.push(event[name]);
-            } else if (type === 'static') {
-              staticEventList.push(event[name]);
-            }
+            listEventListen.push({
+              event: event,
+              name: name
+            });
+            msg.push({
+              name: eventName,
+              version: eventVersion,
+              type: type,
+              method: name
+            });
+          });
+          _lodash["default"].map(listEventStatic, function (_ref4) {
+            var type = _ref4.type,
+              name = _ref4.name;
+            event[name](io);
             msg.push({
               name: eventName,
               version: eventVersion,
@@ -478,14 +489,8 @@ var Server = /*#__PURE__*/function () {
           });
         });
         console.table(msg);
-        _lodash["default"].map(staticEventList, function (event) {
-          event(io);
-        });
         io.on('connection', function (socket) {
           console.log('connected', socket.id);
-          socket.emit('ping', _controller.SocketEvent.compressJson({
-            ts: Date.now()
-          }));
           var interval = (0, _util.setIntervalImmediately)(function () {
             socket.emit('ping', _controller.SocketEvent.compressJson({
               ts: Date.now()
@@ -495,8 +500,10 @@ var Server = /*#__PURE__*/function () {
             console.log('disconnected', socket.id);
             clearInterval(interval);
           });
-          _lodash["default"].map(listenEventList, function (event) {
-            event(io, socket);
+          _lodash["default"].map(listEventListen, function (_ref5) {
+            var event = _ref5.event,
+              name = _ref5.name;
+            event[name](io, socket);
           });
         });
         return io;

package/lib/controller/SocketEvent.js

@@ -20,7 +20,10 @@ var SocketEvent = /*#__PURE__*/function () {
     key: "__getPublicEvents",
     value: function __getPublicEvents() {
       var child = this;
-      var result = [];
+      var result = {
+        listen: [],
+        "static": []
+      };
 
       // eslint-disable-next-line no-proto
       while (Object.getPrototypeOf(child.__proto__)) {
@@ -28,10 +31,17 @@ var SocketEvent = /*#__PURE__*/function () {
         data.map(function (methodName) {
           var matches = methodName.match(/^(listen|static)/);
           if (matches) {
-            result.push({
-              type: matches[0],
-              name: methodName
-            });
+            if (matches[0] === 'listen') {
+              result.listen.push({
+                type: matches[0],
+                name: methodName
+              });
+            } else if (matches[0] === 'static') {
+              result["static"].push({
+                type: matches[0],
+                name: methodName
+              });
+            }
           }
           return true;
         });
@@ -45,6 +55,34 @@ var SocketEvent = /*#__PURE__*/function () {
     value: function compressJson(message) {
       return _pako["default"].deflate(JSON.stringify(message));
     }
+  }, {
+    key: "handleMessage",
+    value: function handleMessage(socket, arg, func) {
+      var message = arg.at(0);
+      var callback = arg.at(-1);
+      var data = message;
+      try {
+        if (message.body) {
+          data = JSON.parse(message.body);
+        }
+      } catch (err) {
+        callback(SocketEvent.compressJson({
+          status: 'error',
+          message: 'Incorrect JSON format'
+        }));
+      }
+      try {
+        func(data);
+      } catch (err) {
+        callback(SocketEvent.compressJson({
+          status: 'error',
+          message: err.toString()
+        }));
+      }
+      callback(SocketEvent.compressJson({
+        status: 'ok'
+      }));
+    }
   }]);
   return SocketEvent;
 }();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@azteam/express",
-    "version": "1.2.500",
+    "version": "1.2.502",
     "license": "MIT",
     "author": "toda <sp.azsolution.net@gmail.com>",
     "main": "./lib/index.js",

package/src/Server.js

@@ -436,23 +436,19 @@ class Server {
                 console.log('listening', `ServerIO start at http://localhost:${httpServer.address().port}`);
             });
 
-            const listenEventList = [];
-            const staticEventList = [];
+            const listEventListen = [];
             const msg = [];
 
-            _.map(socketEvents, (data) => {
+            _.map(socketEvents, function (data) {
                 const {event} = data;
                 const eventName = data.name;
                 const eventVersion = data.version;
-                const listPublicEvent = event.__getPublicEvents();
+                const {listen: lstEvListen, static: listEventStatic} = event.__getPublicEvents();
 
-                _.map(listPublicEvent, (method) => {
+                _.map(lstEvListen, (method) => {
                     const {name, type} = method;
-                    if (type === 'listen') {
-                        listenEventList.push(event[name]);
-                    } else if (type === 'static') {
-                        staticEventList.push(event[name]);
-                    }
+                    listEventListen.push({event, name});
+
                     msg.push({
                         name: eventName,
                         version: eventVersion,
@@ -460,22 +456,22 @@ class Server {
                         method: name,
                     });
                 });
-            });
 
-            console.table(msg);
+                _.map(listEventStatic, function ({type, name}) {
+                    event[name](io);
 
-            _.map(staticEventList, (event) => {
-                event(io);
+                    msg.push({
+                        name: eventName,
+                        version: eventVersion,
+                        type,
+                        method: name,
+                    });
+                });
             });
+            console.table(msg);
 
-            io.on('connection', (socket) => {
+            io.on('connection', function (socket) {
                 console.log('connected', socket.id);
-                socket.emit(
-                    'ping',
-                    SocketEvent.compressJson({
-                        ts: Date.now(),
-                    })
-                );
                 const interval = setIntervalImmediately(function () {
                     socket.emit(
                         'ping',
@@ -489,8 +485,8 @@ class Server {
                     clearInterval(interval);
                 });
 
-                _.map(listenEventList, (event) => {
-                    event(io, socket);
+                _.map(listEventListen, ({event, name}) => {
+                    event[name](io, socket);
                 });
             });
 

package/src/controller/SocketEvent.js

@@ -3,7 +3,10 @@ import pako from 'pako';
 class SocketEvent {
     __getPublicEvents() {
         let child = this;
-        const result = [];
+        const result = {
+            listen: [],
+            static: [],
+        };
 
         // eslint-disable-next-line no-proto
         while (Object.getPrototypeOf(child.__proto__)) {
@@ -12,10 +15,17 @@ class SocketEvent {
             data.map(function (methodName) {
                 const matches = methodName.match(/^(listen|static)/);
                 if (matches) {
-                    result.push({
-                        type: matches[0],
-                        name: methodName,
-                    });
+                    if (matches[0] === 'listen') {
+                        result.listen.push({
+                            type: matches[0],
+                            name: methodName,
+                        });
+                    } else if (matches[0] === 'static') {
+                        result.static.push({
+                            type: matches[0],
+                            name: methodName,
+                        });
+                    }
                 }
                 return true;
             });
@@ -28,6 +38,40 @@ class SocketEvent {
     static compressJson(message) {
         return pako.deflate(JSON.stringify(message));
     }
+
+    static handleMessage(socket, arg, func) {
+        const message = arg.at(0);
+        const callback = arg.at(-1);
+        let data = message;
+        try {
+            if (message.body) {
+                data = JSON.parse(message.body);
+            }
+        } catch (err) {
+            callback(
+                SocketEvent.compressJson({
+                    status: 'error',
+                    message: 'Incorrect JSON format',
+                })
+            );
+        }
+        try {
+            func(data);
+        } catch (err) {
+            callback(
+                SocketEvent.compressJson({
+                    status: 'error',
+                    message: err.toString(),
+                })
+            );
+        }
+
+        callback(
+            SocketEvent.compressJson({
+                status: 'ok',
+            })
+        );
+    }
 }
 
 export default SocketEvent;