@iobroker/socket-classes 0.4.10 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/README.md +9 -0
  2. package/lib/socketCommands.js +377 -158
  3. package/lib/socketCommandsAdmin.js +326 -251
  4. package/package.json +1 -1
package/lib/socketCommands.js CHANGED
@@ -158,19 +158,19 @@ class SocketCommands {
158
158
  /**
159
159
  * Convert errors into strings and then call cb
160
160
  * @param {function} cb - callback
161
- * @param {string|Error|null} err - error argument
161
+ * @param {string|Error|null} error - error argument
162
162
  * @param {any[]} args - args passed to cb
163
163
  */
164
- static _fixCallback(cb, err, ...args) {
164
+ static _fixCallback(cb, error, ...args) {
165
165
  if (typeof cb !== 'function') {
166
166
  return;
167
167
  }
168
168
 
169
- if (err instanceof Error) {
170
- err = err.message;
169
+ if (error instanceof Error) {
170
+ error = error.message;
171
171
  }
172
172
 
173
- cb(err, ...args);
173
+ cb(error, ...args);
174
174
  }
175
175
 
176
176
  _checkPermissions(socket, command, callback, arg) {
@@ -371,7 +371,10 @@ class SocketCommands {
371
371
  } else if (type === 'objectChange') {
372
372
  this.adapter.unsubscribeForeignObjects && this.adapter.unsubscribeForeignObjects(pattern);
373
373
  } else if (type === 'log') {
374
- this.adapter.requireLog && this.adapter.requireLog(false);
374
+ if (this.adapter.requireLog && this.logEnabled) {
375
+ this.logEnabled = false;
376
+ this.adapter.requireLog(false);
377
+ }
375
378
  } else if (type === 'fileChange') {
376
379
  this.adapter.unsubscribeForeignFiles && this.adapter.unsubscribeForeignFiles(pattern, patternFile);
377
380
  }
@@ -388,7 +391,10 @@ class SocketCommands {
388
391
  this.adapter.unsubscribeForeignObjects && this.adapter.unsubscribeForeignObjects(pattern);
389
392
  } else if (type === 'log') {
390
393
  //console.log((socket._name || socket.id) + ' requireLog false');
391
- this.adapter.requireLog && this.adapter.requireLog(false);
394
+ if (this.adapter.requireLog && this.logEnabled) {
395
+ this.logEnabled = false;
396
+ this.adapter.requireLog(false);
397
+ }
392
398
  } else if (type === 'fileChange') {
393
399
  const [id, fileName] = pattern.split('####');
394
400
  this.adapter.unsubscribeForeignFiles && this.adapter.unsubscribeForeignFiles(id, fileName);
@@ -422,7 +428,10 @@ class SocketCommands {
422
428
  } else if (type === 'objectChange') {
423
429
  this.adapter.subscribeForeignObjects && this.adapter.subscribeForeignObjects(pattern);
424
430
  } else if (type === 'log') {
425
- this.adapter.requireLog && this.adapter.requireLog(true);
431
+ if (this.adapter.requireLog && !this.logEnabled) {
432
+ this.logEnabled = true;
433
+ this.adapter.requireLog(true);
434
+ }
426
435
  }
427
436
  } else {
428
437
  this.subscribes[type][pattern]++;
@@ -454,7 +463,10 @@ class SocketCommands {
454
463
  } else if (type === 'objectChange') {
455
464
  this.adapter.unsubscribeForeignObjects && this.adapter.unsubscribeForeignObjects(pattern);
456
465
  } else if (type === 'log') {
457
- this.adapter.requireLog && this.adapter.requireLog(false);
466
+ if (this.adapter.requireLog && !this.logEnabled) {
467
+ this.logEnabled = true;
468
+ this.adapter.requireLog(true);
469
+ }
458
470
  }
459
471
  delete this.subscribes[type][pattern];
460
472
  }
@@ -538,6 +550,42 @@ class SocketCommands {
538
550
  return this.commands[command];
539
551
  }
540
552
 
553
+ _fixAdminUI(obj) {
554
+ if (obj && obj.common && !obj.common.adminUI) {
555
+ if (obj.common.noConfig) {
556
+ obj.common.adminUI = obj.common.adminUI || {};
557
+ obj.common.adminUI.config = 'none';
558
+ } else if (obj.common.jsonConfig) {
559
+ obj.common.adminUI = obj.common.adminUI || {};
560
+ obj.common.adminUI.config = 'json';
561
+ } else if (obj.common.materialize) {
562
+ obj.common.adminUI = obj.common.adminUI || {};
563
+ obj.common.adminUI.config = 'materialize';
564
+ } else {
565
+ obj.common.adminUI = obj.common.adminUI || {};
566
+ obj.common.adminUI.config = 'html';
567
+ }
568
+
569
+ if (obj.common.jsonCustom) {
570
+ obj.common.adminUI = obj.common.adminUI || {};
571
+ obj.common.adminUI.custom = 'json';
572
+ } else if (obj.common.supportCustoms) {
573
+ obj.common.adminUI = obj.common.adminUI || {};
574
+ obj.common.adminUI.custom = 'json';
575
+ }
576
+
577
+ if (obj.common.materializeTab && obj.common.adminTab) {
578
+ obj.common.adminUI = obj.common.adminUI || {};
579
+ obj.common.adminUI.tab = 'materialize';
580
+ } else if (obj.common.adminTab) {
581
+ obj.common.adminUI = obj.common.adminUI || {};
582
+ obj.common.adminUI.tab = 'html';
583
+ }
584
+
585
+ obj.common.adminUI && this.adapter.log.debug(`Please add to "${obj._id.replace(/\.\d+$/, '')}" common.adminUI=${JSON.stringify(obj.common.adminUI)}`);
586
+ }
587
+ }
588
+
541
589
  __initCommandsCommon() {
542
590
  this.commands['authenticate'] = (socket, user, pass, callback) => {
543
591
  if (socket && socket.___socket) {
@@ -559,8 +607,8 @@ class SocketCommands {
559
607
  }
560
608
  };
561
609
 
562
- this.commands['error'] = (socket, err) => {
563
- this.adapter.log.error('Socket error: ' + err);
610
+ this.commands['error'] = (socket, error) => {
611
+ this.adapter.log.error('Socket error: ' + error);
564
612
  };
565
613
 
566
614
  this.commands['log'] = (socket, text, level) => {
@@ -586,8 +634,13 @@ class SocketCommands {
586
634
  options = options || {};
587
635
  options.user = socket._acl.user;
588
636
  options.aggregate = options.aggregate || 'none';
589
- this.adapter.getHistory(id, options, (err, ...args) =>
590
- SocketCommands._fixCallback(callback, err, ...args));
637
+ try {
638
+ this.adapter.getHistory(id, options, (error, ...args) =>
639
+ SocketCommands._fixCallback(callback, error, ...args));
640
+ } catch (error) {
641
+ this.adapter.log.error('[getHistory] ERROR: ' + error.toString());
642
+ SocketCommands._fixCallback(callback, error);
643
+ }
591
644
  }
592
645
  };
593
646
 
@@ -604,8 +657,8 @@ class SocketCommands {
604
657
  })
605
658
  .then(result => callback(null, {status: result.status, statusText: result.statusText}, result.data))
606
659
  .catch(error => callback(error));
607
- } catch (err) {
608
- callback(err);
660
+ } catch (error) {
661
+ callback(error);
609
662
  }
610
663
  }
611
664
  };
@@ -613,9 +666,13 @@ class SocketCommands {
613
666
  // commands
614
667
  this.commands['sendTo'] = (socket, adapterInstance, command, message, callback) => {
615
668
  if (this._checkPermissions(socket, 'sendTo', callback, command)) {
616
- this.adapter.sendTo(adapterInstance, command, message, res =>
617
- typeof callback === 'function' && setImmediate(() =>
618
- callback(res)));
669
+ try {
670
+ this.adapter.sendTo(adapterInstance, command, message, res =>
671
+ typeof callback === 'function' && setImmediate(() =>
672
+ callback(res)));
673
+ } catch (error) {
674
+ typeof callback === 'function' && setImmediate(() => callback({error}));
675
+ }
619
676
  }
620
677
  };
621
678
 
@@ -632,6 +689,14 @@ class SocketCommands {
632
689
  const utils = require('@iobroker/adapter-core'); // Get common adapter utils
633
690
  zipFiles = require(utils.controllerDir + '/lib/zipFiles.js');
634
691
  }
692
+ let buffer;
693
+ try {
694
+ buffer = Buffer.from(message.data, 'base64');
695
+ } catch (error) {
696
+ this.adapter.log.error(`Cannot convert data: ${error.toString()}`);
697
+ return callback && callback({error: `Cannot convert data: ${error.toString()}`});
698
+ }
699
+
635
700
  zipFiles
636
701
  .writeDirAsZip(
637
702
  this.adapter, // normally we have to pass here the internal "objects" object, but as
@@ -639,19 +704,23 @@ class SocketCommands {
639
704
  // adapter, which has the function with the same name and arguments
640
705
  message.id,
641
706
  message.name,
642
- Buffer.from(message.data, 'base64'),
707
+ buffer,
643
708
  message.options,
644
709
  error => callback({ error }) // this is for back compatibility with js-controller@4.0 or older
645
710
  )
646
711
  .then(() => callback({}))
647
712
  .catch(error => {
648
- this.adapter.log.error(`Cannot write zip file as folder: ${error}`);
649
- callback({ error });
713
+ this.adapter.log.error(`Cannot write zip file as folder: ${error.toString()}`);
714
+ callback && callback({ error });
650
715
  });
651
716
  } else if (this._sendToHost) {
652
717
  this._sendToHost(host, command, message, callback);
653
718
  } else {
654
- this.adapter.sendToHost(host, command, message, callback);
719
+ try {
720
+ this.adapter.sendToHost(host, command, message, callback);
721
+ } catch (error) {
722
+ return callback && callback({ error });
723
+ }
655
724
  }
656
725
  }
657
726
  };
@@ -714,34 +783,48 @@ class SocketCommands {
714
783
  // file operations
715
784
  this.commands['readFile'] = (socket, _adapter, fileName, callback) => {
716
785
  if (this._checkPermissions(socket, 'readFile', callback, fileName)) {
717
- this.adapter.readFile(_adapter, fileName, {user: socket._acl.user}, (err, ...args) =>
718
- SocketCommands._fixCallback(callback, err, ...args));
786
+ try {
787
+ this.adapter.readFile(_adapter, fileName, {user: socket._acl.user}, (error, ...args) =>
788
+ SocketCommands._fixCallback(callback, error, ...args));
789
+ } catch (error) {
790
+ this.adapter.log.error('[readFile] ERROR: ' + error.toString());
791
+ SocketCommands._fixCallback(callback, error);
792
+ }
719
793
  }
720
794
  };
721
795
 
722
796
  this.commands['readFile64'] = (socket, _adapter, fileName, callback) => {
723
797
  if (this._checkPermissions(socket, 'readFile64', callback, fileName)) {
724
- this.adapter.readFile(_adapter, fileName, {user: socket._acl.user}, (err, buffer, type) => {
725
- let data64;
726
- if (buffer) {
727
- if (type === 'application/json') {
728
- data64 = Buffer.from(encodeURIComponent(buffer)).toString('base64');
729
- } else {
730
- if (typeof buffer === 'string') {
731
- data64 = Buffer.from(buffer).toString('base64');
732
- } else {
733
- data64 = buffer.toString('base64');
798
+ try {
799
+ this.adapter.readFile(_adapter, fileName, {user: socket._acl.user}, (error, buffer, type) => {
800
+ let data64;
801
+ if (buffer) {
802
+ try {
803
+ if (type === 'application/json') {
804
+ data64 = Buffer.from(encodeURIComponent(buffer)).toString('base64');
805
+ } else {
806
+ if (typeof buffer === 'string') {
807
+ data64 = Buffer.from(buffer).toString('base64');
808
+ } else {
809
+ data64 = buffer.toString('base64');
810
+ }
811
+ }
812
+ } catch (error) {
813
+ this.adapter.log.error('[readFile64] Cannot convert data: ' + error.toString());
734
814
  }
735
815
  }
736
- }
737
816
 
738
- //Convert buffer to base 64
739
- if (typeof callback === 'function') {
740
- callback(err, data64 || '', type);
741
- } else {
742
- this.adapter.log.warn('[readFile64] Invalid callback');
743
- }
744
- });
817
+ //Convert buffer to base 64
818
+ if (typeof callback === 'function') {
819
+ callback(error, data64 || '', type);
820
+ } else {
821
+ this.adapter.log.warn('[readFile64] Invalid callback');
822
+ }
823
+ });
824
+ } catch (error) {
825
+ this.adapter.log.error('[readFile64] ERROR: ' + error.toString());
826
+ SocketCommands._fixCallback(callback, error);
827
+ }
745
828
  }
746
829
  };
747
830
 
@@ -756,12 +839,18 @@ class SocketCommands {
756
839
 
757
840
  if (this._checkPermissions(socket, 'writeFile64', callback, fileName)) {
758
841
  if (!data64) {
759
- return typeof callback === 'function' && callback('No data provided');
842
+ return SocketCommands._fixCallback(callback, 'No data provided');
760
843
  }
761
844
  // Convert base 64 to buffer
762
- const buffer = Buffer.from(data64, 'base64');
763
- this.adapter.writeFile(_adapter, fileName, buffer, options, (err, ...args) =>
764
- SocketCommands._fixCallback(callback, err, ...args));
845
+
846
+ try {
847
+ const buffer = Buffer.from(data64, 'base64');
848
+ this.adapter.writeFile(_adapter, fileName, buffer, options, (error, ...args) =>
849
+ SocketCommands._fixCallback(callback, error, ...args));
850
+ } catch (error) {
851
+ this.adapter.log.error('[writeFile64] Cannot convert data: ' + error.toString());
852
+ SocketCommands._fixCallback(callback, 'Cannot convert data: ' + error.toString());
853
+ }
765
854
  }
766
855
  };
767
856
 
@@ -776,53 +865,88 @@ class SocketCommands {
776
865
  options.user = socket._acl.user;
777
866
  this.adapter.log.debug('writeFile deprecated. Please use writeFile64');
778
867
  // const buffer = Buffer.from(data64, 'base64');
779
- this.adapter.writeFile(_adapter, fileName, data, {user: socket._acl.user}, (err, ...args) =>
780
- SocketCommands._fixCallback(callback, err, ...args));
868
+ try {
869
+ this.adapter.writeFile(_adapter, fileName, data, {user: socket._acl.user}, (error, ...args) =>
870
+ SocketCommands._fixCallback(callback, error, ...args));
871
+ } catch (error) {
872
+ this.adapter.log.error('[writeFile] ERROR: ' + error.toString());
873
+ SocketCommands._fixCallback(callback, error);
874
+ }
781
875
  }
782
876
  };
783
877
 
784
878
  this.commands['unlink'] = (socket, _adapter, name, callback) => {
785
879
  if (this._checkPermissions(socket, 'unlink', callback, name)) {
786
- this._unlink(_adapter, name, {user: socket._acl.user})
787
- .then(() => callback && callback())
788
- .catch(error => callback && callback(error));
880
+ try {
881
+ this._unlink(_adapter, name, {user: socket._acl.user})
882
+ .then(() => SocketCommands._fixCallback(callback))
883
+ .catch(error => SocketCommands._fixCallback(callback, error));
884
+ } catch (error) {
885
+ this.adapter.log.error('[unlink] ERROR: ' + error.toString());
886
+ SocketCommands._fixCallback(callback, error);
887
+ }
789
888
  }
790
889
  };
791
890
 
792
891
  this.commands['deleteFile'] = (socket, _adapter, name, callback) => {
793
892
  if (this._checkPermissions(socket, 'unlink', callback, name)) {
794
- this.adapter.unlink(_adapter, name, {user: socket._acl.user}, (err, ...args) =>
795
- SocketCommands._fixCallback(callback, err, ...args));
893
+ try {
894
+ this.adapter.unlink(_adapter, name, {user: socket._acl.user}, (error, ...args) =>
895
+ SocketCommands._fixCallback(callback, error, ...args));
896
+ } catch (error) {
897
+ this.adapter.log.error('[deleteFile] ERROR: ' + error.toString());
898
+ SocketCommands._fixCallback(callback, error);
899
+ }
796
900
  }
797
901
  };
798
902
 
799
903
  this.commands['deleteFolder'] = (socket, _adapter, name, callback) => {
800
904
  if (this._checkPermissions(socket, 'unlink', callback, name)) {
801
- this._unlink(_adapter, name, {user: socket._acl.user})
802
- .then(() => SocketCommands._fixCallback(callback, null))
803
- .catch(err => SocketCommands._fixCallback(callback, err));
905
+ try {
906
+ this._unlink(_adapter, name, {user: socket._acl.user})
907
+ .then(() => SocketCommands._fixCallback(callback, null))
908
+ .catch(error => SocketCommands._fixCallback(callback, error));
909
+ } catch (error) {
910
+ this.adapter.log.error('[deleteFolder] ERROR: ' + error.toString());
911
+ SocketCommands._fixCallback(callback, error);
912
+ }
804
913
  }
805
914
  };
806
915
 
807
916
  this.commands['renameFile'] = (socket, _adapter, oldName, newName, callback) => {
808
917
  if (this._checkPermissions(socket, 'rename', callback, oldName)) {
809
- this.adapter.rename(_adapter, oldName, newName, {user: socket._acl.user}, (err, ...args) =>
810
- SocketCommands._fixCallback(callback, err, ...args));
918
+ try {
919
+ this.adapter.rename(_adapter, oldName, newName, {user: socket._acl.user}, (error, ...args) =>
920
+ SocketCommands._fixCallback(callback, error, ...args));
921
+ } catch (error) {
922
+ this.adapter.log.error('[renameFile] ERROR: ' + error.toString());
923
+ SocketCommands._fixCallback(callback, error);
924
+ }
811
925
  }
812
926
  };
813
927
 
814
928
  this.commands['rename'] = (socket, _adapter, oldName, newName, callback) => {
815
929
  if (this._checkPermissions(socket, 'rename', callback, oldName)) {
816
- this._rename(_adapter, oldName, newName, {user: socket._acl.user})
817
- .then(() => callback && callback())
818
- .catch(error => callback && callback(error));
930
+ try {
931
+ this._rename(_adapter, oldName, newName, {user: socket._acl.user})
932
+ .then(() => SocketCommands._fixCallback(callback))
933
+ .catch(error => SocketCommands._fixCallback(callback, error));
934
+ } catch (error) {
935
+ this.adapter.log.error('[rename] ERROR: ' + error.toString());
936
+ SocketCommands._fixCallback(callback, error);
937
+ }
819
938
  }
820
939
  };
821
940
 
822
941
  this.commands['mkdir'] = (socket, _adapter, dirName, callback) => {
823
942
  if (this._checkPermissions(socket, 'mkdir', callback, dirName)) {
824
- this.adapter.mkdir(_adapter, dirName, {user: socket._acl.user}, (err, ...args) =>
825
- SocketCommands._fixCallback(callback, err, ...args));
943
+ try {
944
+ this.adapter.mkdir(_adapter, dirName, {user: socket._acl.user}, (error, ...args) =>
945
+ SocketCommands._fixCallback(callback, error, ...args));
946
+ } catch (error) {
947
+ this.adapter.log.error('[mkdir] ERROR: ' + error.toString());
948
+ SocketCommands._fixCallback(callback, error);
949
+ }
826
950
  }
827
951
  };
828
952
 
@@ -839,8 +963,13 @@ class SocketCommands {
839
963
  }
840
964
 
841
965
  if (this._checkPermissions(socket, 'readDir', callback, dirName)) {
842
- this.adapter.readDir(_adapter, dirName, {user: socket._acl.user}, (err, ...args) =>
843
- SocketCommands._fixCallback(callback, err, ...args));
966
+ try {
967
+ this.adapter.readDir(_adapter, dirName, {user: socket._acl.user}, (error, ...args) =>
968
+ SocketCommands._fixCallback(callback, error, ...args));
969
+ } catch (error) {
970
+ this.adapter.log.error('[readDir] ERROR: ' + error.toString());
971
+ SocketCommands._fixCallback(callback, error);
972
+ }
844
973
  }
845
974
  };
846
975
 
@@ -857,8 +986,13 @@ class SocketCommands {
857
986
  }
858
987
 
859
988
  if (this._checkPermissions(socket, 'chmodFile', callback, fileName)) {
860
- this.adapter.chmodFile(_adapter, fileName, options, (err, ...args) =>
861
- SocketCommands._fixCallback(callback, err, ...args));
989
+ try {
990
+ this.adapter.chmodFile(_adapter, fileName, options, (error, ...args) =>
991
+ SocketCommands._fixCallback(callback, error, ...args));
992
+ } catch (error) {
993
+ this.adapter.log.error('[chmodFile] ERROR: ' + error.toString());
994
+ SocketCommands._fixCallback(callback, error);
995
+ }
862
996
  }
863
997
  };
864
998
 
@@ -866,15 +1000,25 @@ class SocketCommands {
866
1000
  if (this._checkPermissions(socket, 'chownFile', callback, fileName)) {
867
1001
  options = options || {};
868
1002
  options.user = socket._acl.user;
869
- this.adapter.chownFile(_adapter, fileName, options, (err, ...args) =>
870
- SocketCommands._fixCallback(callback, err, ...args));
1003
+ try {
1004
+ this.adapter.chownFile(_adapter, fileName, options, (error, ...args) =>
1005
+ SocketCommands._fixCallback(callback, error, ...args));
1006
+ } catch (error) {
1007
+ this.adapter.log.error('[chownFile] ERROR: ' + error.toString());
1008
+ SocketCommands._fixCallback(callback, error);
1009
+ }
871
1010
  }
872
1011
  };
873
1012
 
874
1013
  this.commands['fileExists'] = (socket, _adapter, fileName, callback) => {
875
1014
  if (this._checkPermissions(socket, 'fileExists', callback, fileName)) {
876
- this.adapter.fileExists(_adapter, fileName, {user: socket._acl.user}, (err, ...args) =>
877
- SocketCommands._fixCallback(callback, err, ...args));
1015
+ try {
1016
+ this.adapter.fileExists(_adapter, fileName, {user: socket._acl.user}, (error, ...args) =>
1017
+ SocketCommands._fixCallback(callback, error, ...args));
1018
+ } catch (error) {
1019
+ this.adapter.log.error('[fileExists] ERROR: ' + error.toString());
1020
+ SocketCommands._fixCallback(callback, error);
1021
+ }
878
1022
  }
879
1023
  };
880
1024
 
@@ -889,24 +1033,30 @@ class SocketCommands {
889
1033
  if (_adapterName) {
890
1034
  _adapterName += '.';
891
1035
  }
892
- this.adapter.getObjectView('system', 'instance',
893
- {startkey: `system.adapter.${_adapterName}`, endkey: `system.adapter.${_adapterName}\u9999`},
894
- (err, doc) => {
895
- if (err) {
896
- callback(err);
897
- } else {
898
- callback(null, doc.rows
899
- .map(item => {
900
- const obj = item.value;
901
- if (obj.common) {
902
- delete obj.common.news;
903
- }
904
- this._fixAdminUI(obj);
905
- return obj;
906
- })
907
- .filter(obj => obj && (!adapterName || (obj.common && obj.common.name === adapterName))));
908
- }
909
- });
1036
+ try {
1037
+ this.adapter.getObjectView('system', 'instance',
1038
+ {startkey: `system.adapter.${_adapterName}`, endkey: `system.adapter.${_adapterName}\u9999`},
1039
+ (error, doc) => {
1040
+ if (error) {
1041
+ callback(error);
1042
+ } else {
1043
+ callback(null, doc.rows
1044
+ .map(item => {
1045
+ const obj = item.value;
1046
+ if (obj.common) {
1047
+ delete obj.common.news;
1048
+ }
1049
+ this._fixAdminUI(obj);
1050
+ return obj;
1051
+ })
1052
+ .filter(obj => obj && (!adapterName || (obj.common && obj.common.name === adapterName))));
1053
+ }
1054
+ });
1055
+
1056
+ } catch (error) {
1057
+ this.adapter.log.error('[getAdapterInstances] ERROR: ' + error.toString());
1058
+ SocketCommands._fixCallback(callback, error);
1059
+ }
910
1060
  }
911
1061
  }
912
1062
  };
@@ -920,8 +1070,13 @@ class SocketCommands {
920
1070
  pattern = null;
921
1071
  }
922
1072
  if (typeof callback === 'function') {
923
- this.adapter.getForeignStates(pattern || '*', {user: socket._acl.user}, (err, ...args) =>
924
- SocketCommands._fixCallback(callback, err, ...args));
1073
+ try {
1074
+ this.adapter.getForeignStates(pattern || '*', {user: socket._acl.user}, (error, ...args) =>
1075
+ SocketCommands._fixCallback(callback, error, ...args));
1076
+ } catch (error) {
1077
+ this.adapter.log.error('[getStates] ERROR: ' + error.toString());
1078
+ SocketCommands._fixCallback(callback, error);
1079
+ }
925
1080
  } else {
926
1081
  this.adapter.log.warn('[getStates] Invalid callback')
927
1082
  }
@@ -933,12 +1088,16 @@ class SocketCommands {
933
1088
  // only flot allowed
934
1089
  if (id.startsWith('flot.')) {
935
1090
  if (this._checkPermissions(socket, 'delObject', callback, id)) {
936
- this.adapter.delForeignObject(id, {user: socket._acl.user}, callback);
1091
+ try {
1092
+ this.adapter.delForeignObject(id, {user: socket._acl.user}, (error, ...args) =>
1093
+ SocketCommands._fixCallback(callback, error, ...args));
1094
+ } catch (error) {
1095
+ this.adapter.log.error('[delObject] ERROR: ' + error.toString());
1096
+ SocketCommands._fixCallback(callback, error);
1097
+ }
937
1098
  }
938
1099
  } else {
939
- if (typeof callback === 'function') {
940
- callback(SocketCommands.ERROR_PERMISSION);
941
- }
1100
+ SocketCommands._fixCallback(callback, SocketCommands.ERROR_PERMISSION);
942
1101
  }
943
1102
  };
944
1103
 
@@ -948,8 +1107,13 @@ class SocketCommands {
948
1107
  if (this.states && this.states[id]) {
949
1108
  callback(null, this.states[id]);
950
1109
  } else {
951
- this.adapter.getForeignState(id, {user: socket._acl.user}, (err, ...args) =>
952
- SocketCommands._fixCallback(callback, err, ...args));
1110
+ try {
1111
+ this.adapter.getForeignState(id, {user: socket._acl.user}, (error, ...args) =>
1112
+ SocketCommands._fixCallback(callback, error, ...args));
1113
+ } catch (error) {
1114
+ this.adapter.log.error('[getState] ERROR: ' + error.toString());
1115
+ SocketCommands._fixCallback(callback, error);
1116
+ }
953
1117
  }
954
1118
  } else {
955
1119
  this.adapter.log.warn('[getState] Invalid callback');
@@ -968,28 +1132,46 @@ class SocketCommands {
968
1132
  delete this.states[id];
969
1133
  }
970
1134
 
971
- this.adapter.setForeignState(id, state, {user: socket._acl.user}, (err, ...args) =>
972
- SocketCommands._fixCallback(callback, err, ...args));
1135
+ try {
1136
+ this.adapter.setForeignState(id, state, {user: socket._acl.user}, (error, ...args) =>
1137
+ SocketCommands._fixCallback(callback, error, ...args));
1138
+ } catch (error) {
1139
+ this.adapter.log.error('[setState] ERROR: ' + error.toString());
1140
+ SocketCommands._fixCallback(callback, error);
1141
+ }
973
1142
  }
974
1143
  };
975
1144
 
976
1145
  this.commands['getBinaryState'] = (socket, id, callback) => {
977
1146
  if (this._checkPermissions(socket, 'getState', callback, id)) {
978
1147
  if (typeof callback === 'function') {
979
- if (this.adapter.getForeignBinaryState) {
980
- this.adapter.getForeignBinaryState(id, (err, data) => {
981
- if (data) {
982
- data = Buffer.from(data).toString('base64');
983
- }
984
- SocketCommands._fixCallback(callback, err, data);
985
- });
986
- } else {
987
- this.adapter.getBinaryState(id, (err, data) => {
988
- if (data) {
989
- data = Buffer.from(data).toString('base64');
990
- }
991
- SocketCommands._fixCallback(callback, err, data);
992
- });
1148
+ try {
1149
+ if (this.adapter.getForeignBinaryState) {
1150
+ this.adapter.getForeignBinaryState(id, (error, data) => {
1151
+ if (data) {
1152
+ try {
1153
+ data = Buffer.from(data).toString('base64');
1154
+ } catch (error) {
1155
+ this.adapter.log.error('[getBinaryState] Cannot convert data: ' + error.toString());
1156
+ }
1157
+ }
1158
+ SocketCommands._fixCallback(callback, error, data);
1159
+ });
1160
+ } else {
1161
+ this.adapter.getBinaryState(id, (error, data) => {
1162
+ if (data) {
1163
+ try {
1164
+ data = Buffer.from(data).toString('base64');
1165
+ } catch (error) {
1166
+ this.adapter.log.error('[getBinaryState] Cannot convert data: ' + error.toString());
1167
+ }
1168
+ }
1169
+ SocketCommands._fixCallback(callback, error, data);
1170
+ });
1171
+ }
1172
+ } catch (error) {
1173
+ this.adapter.log.error('[getBinaryState] ERROR: ' + error.toString());
1174
+ SocketCommands._fixCallback(callback, error);
993
1175
  }
994
1176
  } else {
995
1177
  this.adapter.log.warn('[getBinaryState] Invalid callback')
@@ -1003,16 +1185,21 @@ class SocketCommands {
1003
1185
  let data = null;
1004
1186
  try {
1005
1187
  data = Buffer.from(base64, 'base64')
1006
- } catch (e) {
1007
- this.adapter.log.warn('[setBinaryState] Cannot convert base64 data: ' + e);
1188
+ } catch (error) {
1189
+ this.adapter.log.warn('[setBinaryState] Cannot convert base64 data: ' + error.toString());
1008
1190
  }
1009
1191
 
1010
- if (this.adapter.setForeignBinaryState) {
1011
- this.adapter.setForeignBinaryState(id, data, (err, ...args) =>
1012
- SocketCommands._fixCallback(callback, err, ...args));
1013
- } else {
1014
- this.adapter.setBinaryState(id, data, (err, ...args) =>
1015
- SocketCommands._fixCallback(callback, err, ...args));
1192
+ try {
1193
+ if (this.adapter.setForeignBinaryState) {
1194
+ this.adapter.setForeignBinaryState(id, data, (error, ...args) =>
1195
+ SocketCommands._fixCallback(callback, error, ...args));
1196
+ } else {
1197
+ this.adapter.setBinaryState(id, data, (error, ...args) =>
1198
+ SocketCommands._fixCallback(callback, error, ...args));
1199
+ }
1200
+ } catch (error) {
1201
+ this.adapter.log.error('[setBinaryState] ERROR: ' + error.toString());
1202
+ SocketCommands._fixCallback(callback, error);
1016
1203
  }
1017
1204
  } else {
1018
1205
  this.adapter.log.warn('[setBinaryState] Invalid callback');
@@ -1030,60 +1217,82 @@ class SocketCommands {
1030
1217
  __initCommandsObjects() {
1031
1218
  this.commands['getObject'] = (socket, id, callback) => {
1032
1219
  if (this._checkPermissions(socket, 'getObject', callback, id)) {
1033
- this.adapter.getForeignObject(id, {user: socket._acl.user}, (err, obj) => {
1034
- // overload language from current instance
1035
- if (this.adapter._language && id === 'system.config' && obj.common) {
1036
- obj.common.language = this.adapter._language;
1037
- }
1038
- SocketCommands._fixCallback(callback, err, obj);
1039
- });
1220
+ try {
1221
+ this.adapter.getForeignObject(id, {user: socket._acl.user}, (error, obj) => {
1222
+ // overload language from current instance
1223
+ if (this.adapter._language && id === 'system.config' && obj.common) {
1224
+ obj.common.language = this.adapter._language;
1225
+ }
1226
+ SocketCommands._fixCallback(callback, error, obj);
1227
+ });
1228
+ } catch (error) {
1229
+ this.adapter.log.error('[getObject] ERROR: ' + error.toString());
1230
+ SocketCommands._fixCallback(callback, error);
1231
+ }
1040
1232
  }
1041
1233
  };
1042
1234
 
1043
1235
  // not admin version of "all objects"
1044
1236
  this.commands['getObjects'] = (socket, callback) => {
1045
1237
  if (this._checkPermissions(socket, 'getObjects', callback)) {
1046
- this.adapter.getForeignObjects('*', 'state', 'rooms', {user: socket._acl.user}, (err, objs) => {
1047
- if (typeof callback === 'function') {
1048
- // overload language
1049
- if (this.adapter._language && objs['system.config'] && objs['system.config'].common) {
1050
- objs['system.config'].common.language = this.adapter._language;
1051
- }
1238
+ try {
1239
+ this.adapter.getForeignObjects('*', 'state', 'rooms', {user: socket._acl.user}, (error, objs) => {
1240
+ if (typeof callback === 'function') {
1241
+ // overload language
1242
+ if (this.adapter._language && objs['system.config'] && objs['system.config'].common) {
1243
+ objs['system.config'].common.language = this.adapter._language;
1244
+ }
1052
1245
 
1053
- callback(err, objs);
1054
- } else {
1055
- this.adapter.log.warn('[getObjects] Invalid callback');
1056
- }
1057
- });
1246
+ SocketCommands._fixCallback(callback, error, objs);
1247
+ } else {
1248
+ this.adapter.log.warn('[getObjects] Invalid callback');
1249
+ }
1250
+ });
1251
+ } catch (error) {
1252
+ this.adapter.log.error('[getObjects] ERROR: ' + error.toString());
1253
+ SocketCommands._fixCallback(callback, error);
1254
+ }
1058
1255
  }
1059
1256
  };
1060
1257
 
1061
1258
  this.commands['subscribeObjects'] = (socket, pattern, callback) => {
1062
1259
  if (this._checkPermissions(socket, 'subscribeObjects', callback, pattern)) {
1063
- if (pattern && typeof pattern === 'object' && pattern instanceof Array) {
1064
- for (let p = 0; p < pattern.length; p++) {
1065
- this.subscribe(socket, 'objectChange', pattern[p]);
1260
+ try {
1261
+ if (pattern && typeof pattern === 'object' && pattern instanceof Array) {
1262
+ for (let p = 0; p < pattern.length; p++) {
1263
+ this.subscribe(socket, 'objectChange', pattern[p]);
1264
+ }
1265
+ } else {
1266
+ this.subscribe(socket, 'objectChange', pattern);
1267
+ }
1268
+ if (typeof callback === 'function') {
1269
+ setImmediate(callback, null);
1270
+ }
1271
+ } catch (error) {
1272
+ if (typeof callback === 'function') {
1273
+ setImmediate(callback, error);
1066
1274
  }
1067
- } else {
1068
- this.subscribe(socket, 'objectChange', pattern);
1069
- }
1070
- if (typeof callback === 'function') {
1071
- setImmediate(callback, null);
1072
1275
  }
1073
1276
  }
1074
1277
  };
1075
1278
 
1076
1279
  this.commands['unsubscribeObjects'] = (socket, pattern, callback) => {
1077
1280
  if (this._checkPermissions(socket, 'unsubscribeObjects', callback, pattern)) {
1078
- if (pattern && typeof pattern === 'object' && pattern instanceof Array) {
1079
- for (let p = 0; p < pattern.length; p++) {
1080
- this.unsubscribe(socket, 'objectChange', pattern[p]);
1281
+ try {
1282
+ if (pattern && typeof pattern === 'object' && pattern instanceof Array) {
1283
+ for (let p = 0; p < pattern.length; p++) {
1284
+ this.unsubscribe(socket, 'objectChange', pattern[p]);
1285
+ }
1286
+ } else {
1287
+ this.unsubscribe(socket, 'objectChange', pattern);
1288
+ }
1289
+ if (typeof callback === 'function') {
1290
+ setImmediate(callback, null);
1291
+ }
1292
+ } catch (error) {
1293
+ if (typeof callback === 'function') {
1294
+ setImmediate(callback, error);
1081
1295
  }
1082
- } else {
1083
- this.unsubscribe(socket, 'objectChange', pattern);
1084
- }
1085
- if (typeof callback === 'function') {
1086
- setImmediate(callback, null);
1087
1296
  }
1088
1297
  }
1089
1298
  };
@@ -1091,7 +1300,12 @@ class SocketCommands {
1091
1300
  this.commands['getObjectView'] = (socket, design, search, params, callback) => {
1092
1301
  if (typeof callback === 'function') {
1093
1302
  if (this._checkPermissions(socket, 'getObjectView', callback, search)) {
1094
- this.adapter.getObjectView(design, search, params, {user: socket._acl.user}, callback);
1303
+ try {
1304
+ this.adapter.getObjectView(design, search, params, {user: socket._acl.user}, callback);
1305
+ } catch (error) {
1306
+ this.adapter.log.error('[getObjectView] ERROR: ' + error.toString());
1307
+ SocketCommands._fixCallback(callback, error);
1308
+ }
1095
1309
  }
1096
1310
  } else {
1097
1311
  this.adapter.log.error('Callback is not a function');
@@ -1100,8 +1314,13 @@ class SocketCommands {
1100
1314
 
1101
1315
  this.commands['setObject'] = (socket, id, obj, callback) => {
1102
1316
  if (this._checkPermissions(socket, 'setObject', callback, id)) {
1103
- this.adapter.setForeignObject(id, obj, {user: socket._acl.user}, (err, ...args) =>
1104
- SocketCommands._fixCallback(callback, err, ...args));
1317
+ try {
1318
+ this.adapter.setForeignObject(id, obj, {user: socket._acl.user}, (error, ...args) =>
1319
+ SocketCommands._fixCallback(callback, error, ...args));
1320
+ } catch (error) {
1321
+ this.adapter.log.error('[setObject] ERROR: ' + error.toString());
1322
+ SocketCommands._fixCallback(callback, error);
1323
+ }
1105
1324
  }
1106
1325
  };
1107
1326
  }