@iobroker/socket-classes 0.4.12 → 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 +3 -0
  2. package/lib/socketCommands.js +325 -154
  3. package/lib/socketCommandsAdmin.js +326 -215
  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) {
@@ -607,8 +607,8 @@ class SocketCommands {
607
607
  }
608
608
  };
609
609
 
610
- this.commands['error'] = (socket, err) => {
611
- this.adapter.log.error('Socket error: ' + err);
610
+ this.commands['error'] = (socket, error) => {
611
+ this.adapter.log.error('Socket error: ' + error);
612
612
  };
613
613
 
614
614
  this.commands['log'] = (socket, text, level) => {
@@ -634,8 +634,13 @@ class SocketCommands {
634
634
  options = options || {};
635
635
  options.user = socket._acl.user;
636
636
  options.aggregate = options.aggregate || 'none';
637
- this.adapter.getHistory(id, options, (err, ...args) =>
638
- 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
+ }
639
644
  }
640
645
  };
641
646
 
@@ -652,8 +657,8 @@ class SocketCommands {
652
657
  })
653
658
  .then(result => callback(null, {status: result.status, statusText: result.statusText}, result.data))
654
659
  .catch(error => callback(error));
655
- } catch (err) {
656
- callback(err);
660
+ } catch (error) {
661
+ callback(error);
657
662
  }
658
663
  }
659
664
  };
@@ -661,9 +666,13 @@ class SocketCommands {
661
666
  // commands
662
667
  this.commands['sendTo'] = (socket, adapterInstance, command, message, callback) => {
663
668
  if (this._checkPermissions(socket, 'sendTo', callback, command)) {
664
- this.adapter.sendTo(adapterInstance, command, message, res =>
665
- typeof callback === 'function' && setImmediate(() =>
666
- 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
+ }
667
676
  }
668
677
  };
669
678
 
@@ -680,6 +689,14 @@ class SocketCommands {
680
689
  const utils = require('@iobroker/adapter-core'); // Get common adapter utils
681
690
  zipFiles = require(utils.controllerDir + '/lib/zipFiles.js');
682
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
+
683
700
  zipFiles
684
701
  .writeDirAsZip(
685
702
  this.adapter, // normally we have to pass here the internal "objects" object, but as
@@ -687,19 +704,23 @@ class SocketCommands {
687
704
  // adapter, which has the function with the same name and arguments
688
705
  message.id,
689
706
  message.name,
690
- Buffer.from(message.data, 'base64'),
707
+ buffer,
691
708
  message.options,
692
709
  error => callback({ error }) // this is for back compatibility with js-controller@4.0 or older
693
710
  )
694
711
  .then(() => callback({}))
695
712
  .catch(error => {
696
- this.adapter.log.error(`Cannot write zip file as folder: ${error}`);
697
- callback({ error });
713
+ this.adapter.log.error(`Cannot write zip file as folder: ${error.toString()}`);
714
+ callback && callback({ error });
698
715
  });
699
716
  } else if (this._sendToHost) {
700
717
  this._sendToHost(host, command, message, callback);
701
718
  } else {
702
- 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
+ }
703
724
  }
704
725
  }
705
726
  };
@@ -762,34 +783,48 @@ class SocketCommands {
762
783
  // file operations
763
784
  this.commands['readFile'] = (socket, _adapter, fileName, callback) => {
764
785
  if (this._checkPermissions(socket, 'readFile', callback, fileName)) {
765
- this.adapter.readFile(_adapter, fileName, {user: socket._acl.user}, (err, ...args) =>
766
- 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
+ }
767
793
  }
768
794
  };
769
795
 
770
796
  this.commands['readFile64'] = (socket, _adapter, fileName, callback) => {
771
797
  if (this._checkPermissions(socket, 'readFile64', callback, fileName)) {
772
- this.adapter.readFile(_adapter, fileName, {user: socket._acl.user}, (err, buffer, type) => {
773
- let data64;
774
- if (buffer) {
775
- if (type === 'application/json') {
776
- data64 = Buffer.from(encodeURIComponent(buffer)).toString('base64');
777
- } else {
778
- if (typeof buffer === 'string') {
779
- data64 = Buffer.from(buffer).toString('base64');
780
- } else {
781
- 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());
782
814
  }
783
815
  }
784
- }
785
816
 
786
- //Convert buffer to base 64
787
- if (typeof callback === 'function') {
788
- callback(err, data64 || '', type);
789
- } else {
790
- this.adapter.log.warn('[readFile64] Invalid callback');
791
- }
792
- });
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
+ }
793
828
  }
794
829
  };
795
830
 
@@ -804,12 +839,18 @@ class SocketCommands {
804
839
 
805
840
  if (this._checkPermissions(socket, 'writeFile64', callback, fileName)) {
806
841
  if (!data64) {
807
- return typeof callback === 'function' && callback('No data provided');
842
+ return SocketCommands._fixCallback(callback, 'No data provided');
808
843
  }
809
844
  // Convert base 64 to buffer
810
- const buffer = Buffer.from(data64, 'base64');
811
- this.adapter.writeFile(_adapter, fileName, buffer, options, (err, ...args) =>
812
- 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
+ }
813
854
  }
814
855
  };
815
856
 
@@ -824,53 +865,88 @@ class SocketCommands {
824
865
  options.user = socket._acl.user;
825
866
  this.adapter.log.debug('writeFile deprecated. Please use writeFile64');
826
867
  // const buffer = Buffer.from(data64, 'base64');
827
- this.adapter.writeFile(_adapter, fileName, data, {user: socket._acl.user}, (err, ...args) =>
828
- 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
+ }
829
875
  }
830
876
  };
831
877
 
832
878
  this.commands['unlink'] = (socket, _adapter, name, callback) => {
833
879
  if (this._checkPermissions(socket, 'unlink', callback, name)) {
834
- this._unlink(_adapter, name, {user: socket._acl.user})
835
- .then(() => callback && callback())
836
- .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
+ }
837
888
  }
838
889
  };
839
890
 
840
891
  this.commands['deleteFile'] = (socket, _adapter, name, callback) => {
841
892
  if (this._checkPermissions(socket, 'unlink', callback, name)) {
842
- this.adapter.unlink(_adapter, name, {user: socket._acl.user}, (err, ...args) =>
843
- 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
+ }
844
900
  }
845
901
  };
846
902
 
847
903
  this.commands['deleteFolder'] = (socket, _adapter, name, callback) => {
848
904
  if (this._checkPermissions(socket, 'unlink', callback, name)) {
849
- this._unlink(_adapter, name, {user: socket._acl.user})
850
- .then(() => SocketCommands._fixCallback(callback, null))
851
- .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
+ }
852
913
  }
853
914
  };
854
915
 
855
916
  this.commands['renameFile'] = (socket, _adapter, oldName, newName, callback) => {
856
917
  if (this._checkPermissions(socket, 'rename', callback, oldName)) {
857
- this.adapter.rename(_adapter, oldName, newName, {user: socket._acl.user}, (err, ...args) =>
858
- 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
+ }
859
925
  }
860
926
  };
861
927
 
862
928
  this.commands['rename'] = (socket, _adapter, oldName, newName, callback) => {
863
929
  if (this._checkPermissions(socket, 'rename', callback, oldName)) {
864
- this._rename(_adapter, oldName, newName, {user: socket._acl.user})
865
- .then(() => callback && callback())
866
- .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
+ }
867
938
  }
868
939
  };
869
940
 
870
941
  this.commands['mkdir'] = (socket, _adapter, dirName, callback) => {
871
942
  if (this._checkPermissions(socket, 'mkdir', callback, dirName)) {
872
- this.adapter.mkdir(_adapter, dirName, {user: socket._acl.user}, (err, ...args) =>
873
- 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
+ }
874
950
  }
875
951
  };
876
952
 
@@ -887,8 +963,13 @@ class SocketCommands {
887
963
  }
888
964
 
889
965
  if (this._checkPermissions(socket, 'readDir', callback, dirName)) {
890
- this.adapter.readDir(_adapter, dirName, {user: socket._acl.user}, (err, ...args) =>
891
- 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
+ }
892
973
  }
893
974
  };
894
975
 
@@ -905,8 +986,13 @@ class SocketCommands {
905
986
  }
906
987
 
907
988
  if (this._checkPermissions(socket, 'chmodFile', callback, fileName)) {
908
- this.adapter.chmodFile(_adapter, fileName, options, (err, ...args) =>
909
- 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
+ }
910
996
  }
911
997
  };
912
998
 
@@ -914,15 +1000,25 @@ class SocketCommands {
914
1000
  if (this._checkPermissions(socket, 'chownFile', callback, fileName)) {
915
1001
  options = options || {};
916
1002
  options.user = socket._acl.user;
917
- this.adapter.chownFile(_adapter, fileName, options, (err, ...args) =>
918
- 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
+ }
919
1010
  }
920
1011
  };
921
1012
 
922
1013
  this.commands['fileExists'] = (socket, _adapter, fileName, callback) => {
923
1014
  if (this._checkPermissions(socket, 'fileExists', callback, fileName)) {
924
- this.adapter.fileExists(_adapter, fileName, {user: socket._acl.user}, (err, ...args) =>
925
- 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
+ }
926
1022
  }
927
1023
  };
928
1024
 
@@ -937,24 +1033,30 @@ class SocketCommands {
937
1033
  if (_adapterName) {
938
1034
  _adapterName += '.';
939
1035
  }
940
- this.adapter.getObjectView('system', 'instance',
941
- {startkey: `system.adapter.${_adapterName}`, endkey: `system.adapter.${_adapterName}\u9999`},
942
- (err, doc) => {
943
- if (err) {
944
- callback(err);
945
- } else {
946
- callback(null, doc.rows
947
- .map(item => {
948
- const obj = item.value;
949
- if (obj.common) {
950
- delete obj.common.news;
951
- }
952
- this._fixAdminUI(obj);
953
- return obj;
954
- })
955
- .filter(obj => obj && (!adapterName || (obj.common && obj.common.name === adapterName))));
956
- }
957
- });
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
+ }
958
1060
  }
959
1061
  }
960
1062
  };
@@ -968,8 +1070,13 @@ class SocketCommands {
968
1070
  pattern = null;
969
1071
  }
970
1072
  if (typeof callback === 'function') {
971
- this.adapter.getForeignStates(pattern || '*', {user: socket._acl.user}, (err, ...args) =>
972
- 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
+ }
973
1080
  } else {
974
1081
  this.adapter.log.warn('[getStates] Invalid callback')
975
1082
  }
@@ -981,12 +1088,16 @@ class SocketCommands {
981
1088
  // only flot allowed
982
1089
  if (id.startsWith('flot.')) {
983
1090
  if (this._checkPermissions(socket, 'delObject', callback, id)) {
984
- 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
+ }
985
1098
  }
986
1099
  } else {
987
- if (typeof callback === 'function') {
988
- callback(SocketCommands.ERROR_PERMISSION);
989
- }
1100
+ SocketCommands._fixCallback(callback, SocketCommands.ERROR_PERMISSION);
990
1101
  }
991
1102
  };
992
1103
 
@@ -996,8 +1107,13 @@ class SocketCommands {
996
1107
  if (this.states && this.states[id]) {
997
1108
  callback(null, this.states[id]);
998
1109
  } else {
999
- this.adapter.getForeignState(id, {user: socket._acl.user}, (err, ...args) =>
1000
- 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
+ }
1001
1117
  }
1002
1118
  } else {
1003
1119
  this.adapter.log.warn('[getState] Invalid callback');
@@ -1016,28 +1132,46 @@ class SocketCommands {
1016
1132
  delete this.states[id];
1017
1133
  }
1018
1134
 
1019
- this.adapter.setForeignState(id, state, {user: socket._acl.user}, (err, ...args) =>
1020
- 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
+ }
1021
1142
  }
1022
1143
  };
1023
1144
 
1024
1145
  this.commands['getBinaryState'] = (socket, id, callback) => {
1025
1146
  if (this._checkPermissions(socket, 'getState', callback, id)) {
1026
1147
  if (typeof callback === 'function') {
1027
- if (this.adapter.getForeignBinaryState) {
1028
- this.adapter.getForeignBinaryState(id, (err, data) => {
1029
- if (data) {
1030
- data = Buffer.from(data).toString('base64');
1031
- }
1032
- SocketCommands._fixCallback(callback, err, data);
1033
- });
1034
- } else {
1035
- this.adapter.getBinaryState(id, (err, data) => {
1036
- if (data) {
1037
- data = Buffer.from(data).toString('base64');
1038
- }
1039
- SocketCommands._fixCallback(callback, err, data);
1040
- });
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);
1041
1175
  }
1042
1176
  } else {
1043
1177
  this.adapter.log.warn('[getBinaryState] Invalid callback')
@@ -1051,16 +1185,21 @@ class SocketCommands {
1051
1185
  let data = null;
1052
1186
  try {
1053
1187
  data = Buffer.from(base64, 'base64')
1054
- } catch (e) {
1055
- 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());
1056
1190
  }
1057
1191
 
1058
- if (this.adapter.setForeignBinaryState) {
1059
- this.adapter.setForeignBinaryState(id, data, (err, ...args) =>
1060
- SocketCommands._fixCallback(callback, err, ...args));
1061
- } else {
1062
- this.adapter.setBinaryState(id, data, (err, ...args) =>
1063
- 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);
1064
1203
  }
1065
1204
  } else {
1066
1205
  this.adapter.log.warn('[setBinaryState] Invalid callback');
@@ -1078,60 +1217,82 @@ class SocketCommands {
1078
1217
  __initCommandsObjects() {
1079
1218
  this.commands['getObject'] = (socket, id, callback) => {
1080
1219
  if (this._checkPermissions(socket, 'getObject', callback, id)) {
1081
- this.adapter.getForeignObject(id, {user: socket._acl.user}, (err, obj) => {
1082
- // overload language from current instance
1083
- if (this.adapter._language && id === 'system.config' && obj.common) {
1084
- obj.common.language = this.adapter._language;
1085
- }
1086
- SocketCommands._fixCallback(callback, err, obj);
1087
- });
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
+ }
1088
1232
  }
1089
1233
  };
1090
1234
 
1091
1235
  // not admin version of "all objects"
1092
1236
  this.commands['getObjects'] = (socket, callback) => {
1093
1237
  if (this._checkPermissions(socket, 'getObjects', callback)) {
1094
- this.adapter.getForeignObjects('*', 'state', 'rooms', {user: socket._acl.user}, (err, objs) => {
1095
- if (typeof callback === 'function') {
1096
- // overload language
1097
- if (this.adapter._language && objs['system.config'] && objs['system.config'].common) {
1098
- objs['system.config'].common.language = this.adapter._language;
1099
- }
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
+ }
1100
1245
 
1101
- callback(err, objs);
1102
- } else {
1103
- this.adapter.log.warn('[getObjects] Invalid callback');
1104
- }
1105
- });
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
+ }
1106
1255
  }
1107
1256
  };
1108
1257
 
1109
1258
  this.commands['subscribeObjects'] = (socket, pattern, callback) => {
1110
1259
  if (this._checkPermissions(socket, 'subscribeObjects', callback, pattern)) {
1111
- if (pattern && typeof pattern === 'object' && pattern instanceof Array) {
1112
- for (let p = 0; p < pattern.length; p++) {
1113
- 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);
1114
1274
  }
1115
- } else {
1116
- this.subscribe(socket, 'objectChange', pattern);
1117
- }
1118
- if (typeof callback === 'function') {
1119
- setImmediate(callback, null);
1120
1275
  }
1121
1276
  }
1122
1277
  };
1123
1278
 
1124
1279
  this.commands['unsubscribeObjects'] = (socket, pattern, callback) => {
1125
1280
  if (this._checkPermissions(socket, 'unsubscribeObjects', callback, pattern)) {
1126
- if (pattern && typeof pattern === 'object' && pattern instanceof Array) {
1127
- for (let p = 0; p < pattern.length; p++) {
1128
- 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);
1129
1295
  }
1130
- } else {
1131
- this.unsubscribe(socket, 'objectChange', pattern);
1132
- }
1133
- if (typeof callback === 'function') {
1134
- setImmediate(callback, null);
1135
1296
  }
1136
1297
  }
1137
1298
  };
@@ -1139,7 +1300,12 @@ class SocketCommands {
1139
1300
  this.commands['getObjectView'] = (socket, design, search, params, callback) => {
1140
1301
  if (typeof callback === 'function') {
1141
1302
  if (this._checkPermissions(socket, 'getObjectView', callback, search)) {
1142
- 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
+ }
1143
1309
  }
1144
1310
  } else {
1145
1311
  this.adapter.log.error('Callback is not a function');
@@ -1148,8 +1314,13 @@ class SocketCommands {
1148
1314
 
1149
1315
  this.commands['setObject'] = (socket, id, obj, callback) => {
1150
1316
  if (this._checkPermissions(socket, 'setObject', callback, id)) {
1151
- this.adapter.setForeignObject(id, obj, {user: socket._acl.user}, (err, ...args) =>
1152
- 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
+ }
1153
1324
  }
1154
1325
  };
1155
1326
  }