@iobroker/socket-classes 0.4.11 → 0.5.1

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 +361 -154
  3. package/lib/socketCommandsAdmin.js +341 -253
  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) {
@@ -550,6 +550,42 @@ class SocketCommands {
550
550
  return this.commands[command];
551
551
  }
552
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
+
553
589
  __initCommandsCommon() {
554
590
  this.commands['authenticate'] = (socket, user, pass, callback) => {
555
591
  if (socket && socket.___socket) {
@@ -571,8 +607,8 @@ class SocketCommands {
571
607
  }
572
608
  };
573
609
 
574
- this.commands['error'] = (socket, err) => {
575
- this.adapter.log.error('Socket error: ' + err);
610
+ this.commands['error'] = (socket, error) => {
611
+ this.adapter.log.error('Socket error: ' + error);
576
612
  };
577
613
 
578
614
  this.commands['log'] = (socket, text, level) => {
@@ -598,8 +634,13 @@ class SocketCommands {
598
634
  options = options || {};
599
635
  options.user = socket._acl.user;
600
636
  options.aggregate = options.aggregate || 'none';
601
- this.adapter.getHistory(id, options, (err, ...args) =>
602
- 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
+ }
603
644
  }
604
645
  };
605
646
 
@@ -616,8 +657,8 @@ class SocketCommands {
616
657
  })
617
658
  .then(result => callback(null, {status: result.status, statusText: result.statusText}, result.data))
618
659
  .catch(error => callback(error));
619
- } catch (err) {
620
- callback(err);
660
+ } catch (error) {
661
+ callback(error);
621
662
  }
622
663
  }
623
664
  };
@@ -625,9 +666,13 @@ class SocketCommands {
625
666
  // commands
626
667
  this.commands['sendTo'] = (socket, adapterInstance, command, message, callback) => {
627
668
  if (this._checkPermissions(socket, 'sendTo', callback, command)) {
628
- this.adapter.sendTo(adapterInstance, command, message, res =>
629
- typeof callback === 'function' && setImmediate(() =>
630
- 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
+ }
631
676
  }
632
677
  };
633
678
 
@@ -644,6 +689,14 @@ class SocketCommands {
644
689
  const utils = require('@iobroker/adapter-core'); // Get common adapter utils
645
690
  zipFiles = require(utils.controllerDir + '/lib/zipFiles.js');
646
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
+
647
700
  zipFiles
648
701
  .writeDirAsZip(
649
702
  this.adapter, // normally we have to pass here the internal "objects" object, but as
@@ -651,19 +704,23 @@ class SocketCommands {
651
704
  // adapter, which has the function with the same name and arguments
652
705
  message.id,
653
706
  message.name,
654
- Buffer.from(message.data, 'base64'),
707
+ buffer,
655
708
  message.options,
656
709
  error => callback({ error }) // this is for back compatibility with js-controller@4.0 or older
657
710
  )
658
711
  .then(() => callback({}))
659
712
  .catch(error => {
660
- this.adapter.log.error(`Cannot write zip file as folder: ${error}`);
661
- callback({ error });
713
+ this.adapter.log.error(`Cannot write zip file as folder: ${error.toString()}`);
714
+ callback && callback({ error });
662
715
  });
663
716
  } else if (this._sendToHost) {
664
717
  this._sendToHost(host, command, message, callback);
665
718
  } else {
666
- 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
+ }
667
724
  }
668
725
  }
669
726
  };
@@ -726,34 +783,48 @@ class SocketCommands {
726
783
  // file operations
727
784
  this.commands['readFile'] = (socket, _adapter, fileName, callback) => {
728
785
  if (this._checkPermissions(socket, 'readFile', callback, fileName)) {
729
- this.adapter.readFile(_adapter, fileName, {user: socket._acl.user}, (err, ...args) =>
730
- 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
+ }
731
793
  }
732
794
  };
733
795
 
734
796
  this.commands['readFile64'] = (socket, _adapter, fileName, callback) => {
735
797
  if (this._checkPermissions(socket, 'readFile64', callback, fileName)) {
736
- this.adapter.readFile(_adapter, fileName, {user: socket._acl.user}, (err, buffer, type) => {
737
- let data64;
738
- if (buffer) {
739
- if (type === 'application/json') {
740
- data64 = Buffer.from(encodeURIComponent(buffer)).toString('base64');
741
- } else {
742
- if (typeof buffer === 'string') {
743
- data64 = Buffer.from(buffer).toString('base64');
744
- } else {
745
- 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());
746
814
  }
747
815
  }
748
- }
749
816
 
750
- //Convert buffer to base 64
751
- if (typeof callback === 'function') {
752
- callback(err, data64 || '', type);
753
- } else {
754
- this.adapter.log.warn('[readFile64] Invalid callback');
755
- }
756
- });
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
+ }
757
828
  }
758
829
  };
759
830
 
@@ -768,12 +839,18 @@ class SocketCommands {
768
839
 
769
840
  if (this._checkPermissions(socket, 'writeFile64', callback, fileName)) {
770
841
  if (!data64) {
771
- return typeof callback === 'function' && callback('No data provided');
842
+ return SocketCommands._fixCallback(callback, 'No data provided');
772
843
  }
773
844
  // Convert base 64 to buffer
774
- const buffer = Buffer.from(data64, 'base64');
775
- this.adapter.writeFile(_adapter, fileName, buffer, options, (err, ...args) =>
776
- 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
+ }
777
854
  }
778
855
  };
779
856
 
@@ -788,53 +865,88 @@ class SocketCommands {
788
865
  options.user = socket._acl.user;
789
866
  this.adapter.log.debug('writeFile deprecated. Please use writeFile64');
790
867
  // const buffer = Buffer.from(data64, 'base64');
791
- this.adapter.writeFile(_adapter, fileName, data, {user: socket._acl.user}, (err, ...args) =>
792
- 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
+ }
793
875
  }
794
876
  };
795
877
 
796
878
  this.commands['unlink'] = (socket, _adapter, name, callback) => {
797
879
  if (this._checkPermissions(socket, 'unlink', callback, name)) {
798
- this._unlink(_adapter, name, {user: socket._acl.user})
799
- .then(() => callback && callback())
800
- .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
+ }
801
888
  }
802
889
  };
803
890
 
804
891
  this.commands['deleteFile'] = (socket, _adapter, name, callback) => {
805
892
  if (this._checkPermissions(socket, 'unlink', callback, name)) {
806
- this.adapter.unlink(_adapter, name, {user: socket._acl.user}, (err, ...args) =>
807
- 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
+ }
808
900
  }
809
901
  };
810
902
 
811
903
  this.commands['deleteFolder'] = (socket, _adapter, name, callback) => {
812
904
  if (this._checkPermissions(socket, 'unlink', callback, name)) {
813
- this._unlink(_adapter, name, {user: socket._acl.user})
814
- .then(() => SocketCommands._fixCallback(callback, null))
815
- .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
+ }
816
913
  }
817
914
  };
818
915
 
819
916
  this.commands['renameFile'] = (socket, _adapter, oldName, newName, callback) => {
820
917
  if (this._checkPermissions(socket, 'rename', callback, oldName)) {
821
- this.adapter.rename(_adapter, oldName, newName, {user: socket._acl.user}, (err, ...args) =>
822
- 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
+ }
823
925
  }
824
926
  };
825
927
 
826
928
  this.commands['rename'] = (socket, _adapter, oldName, newName, callback) => {
827
929
  if (this._checkPermissions(socket, 'rename', callback, oldName)) {
828
- this._rename(_adapter, oldName, newName, {user: socket._acl.user})
829
- .then(() => callback && callback())
830
- .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
+ }
831
938
  }
832
939
  };
833
940
 
834
941
  this.commands['mkdir'] = (socket, _adapter, dirName, callback) => {
835
942
  if (this._checkPermissions(socket, 'mkdir', callback, dirName)) {
836
- this.adapter.mkdir(_adapter, dirName, {user: socket._acl.user}, (err, ...args) =>
837
- 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
+ }
838
950
  }
839
951
  };
840
952
 
@@ -851,8 +963,13 @@ class SocketCommands {
851
963
  }
852
964
 
853
965
  if (this._checkPermissions(socket, 'readDir', callback, dirName)) {
854
- this.adapter.readDir(_adapter, dirName, {user: socket._acl.user}, (err, ...args) =>
855
- 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
+ }
856
973
  }
857
974
  };
858
975
 
@@ -869,8 +986,13 @@ class SocketCommands {
869
986
  }
870
987
 
871
988
  if (this._checkPermissions(socket, 'chmodFile', callback, fileName)) {
872
- this.adapter.chmodFile(_adapter, fileName, options, (err, ...args) =>
873
- 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
+ }
874
996
  }
875
997
  };
876
998
 
@@ -878,15 +1000,25 @@ class SocketCommands {
878
1000
  if (this._checkPermissions(socket, 'chownFile', callback, fileName)) {
879
1001
  options = options || {};
880
1002
  options.user = socket._acl.user;
881
- this.adapter.chownFile(_adapter, fileName, options, (err, ...args) =>
882
- 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
+ }
883
1010
  }
884
1011
  };
885
1012
 
886
1013
  this.commands['fileExists'] = (socket, _adapter, fileName, callback) => {
887
1014
  if (this._checkPermissions(socket, 'fileExists', callback, fileName)) {
888
- this.adapter.fileExists(_adapter, fileName, {user: socket._acl.user}, (err, ...args) =>
889
- 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
+ }
890
1022
  }
891
1023
  };
892
1024
 
@@ -901,24 +1033,30 @@ class SocketCommands {
901
1033
  if (_adapterName) {
902
1034
  _adapterName += '.';
903
1035
  }
904
- this.adapter.getObjectView('system', 'instance',
905
- {startkey: `system.adapter.${_adapterName}`, endkey: `system.adapter.${_adapterName}\u9999`},
906
- (err, doc) => {
907
- if (err) {
908
- callback(err);
909
- } else {
910
- callback(null, doc.rows
911
- .map(item => {
912
- const obj = item.value;
913
- if (obj.common) {
914
- delete obj.common.news;
915
- }
916
- this._fixAdminUI(obj);
917
- return obj;
918
- })
919
- .filter(obj => obj && (!adapterName || (obj.common && obj.common.name === adapterName))));
920
- }
921
- });
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
+ }
922
1060
  }
923
1061
  }
924
1062
  };
@@ -932,8 +1070,13 @@ class SocketCommands {
932
1070
  pattern = null;
933
1071
  }
934
1072
  if (typeof callback === 'function') {
935
- this.adapter.getForeignStates(pattern || '*', {user: socket._acl.user}, (err, ...args) =>
936
- 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
+ }
937
1080
  } else {
938
1081
  this.adapter.log.warn('[getStates] Invalid callback')
939
1082
  }
@@ -945,12 +1088,16 @@ class SocketCommands {
945
1088
  // only flot allowed
946
1089
  if (id.startsWith('flot.')) {
947
1090
  if (this._checkPermissions(socket, 'delObject', callback, id)) {
948
- 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
+ }
949
1098
  }
950
1099
  } else {
951
- if (typeof callback === 'function') {
952
- callback(SocketCommands.ERROR_PERMISSION);
953
- }
1100
+ SocketCommands._fixCallback(callback, SocketCommands.ERROR_PERMISSION);
954
1101
  }
955
1102
  };
956
1103
 
@@ -960,8 +1107,13 @@ class SocketCommands {
960
1107
  if (this.states && this.states[id]) {
961
1108
  callback(null, this.states[id]);
962
1109
  } else {
963
- this.adapter.getForeignState(id, {user: socket._acl.user}, (err, ...args) =>
964
- 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
+ }
965
1117
  }
966
1118
  } else {
967
1119
  this.adapter.log.warn('[getState] Invalid callback');
@@ -980,28 +1132,46 @@ class SocketCommands {
980
1132
  delete this.states[id];
981
1133
  }
982
1134
 
983
- this.adapter.setForeignState(id, state, {user: socket._acl.user}, (err, ...args) =>
984
- 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
+ }
985
1142
  }
986
1143
  };
987
1144
 
988
1145
  this.commands['getBinaryState'] = (socket, id, callback) => {
989
1146
  if (this._checkPermissions(socket, 'getState', callback, id)) {
990
1147
  if (typeof callback === 'function') {
991
- if (this.adapter.getForeignBinaryState) {
992
- this.adapter.getForeignBinaryState(id, (err, data) => {
993
- if (data) {
994
- data = Buffer.from(data).toString('base64');
995
- }
996
- SocketCommands._fixCallback(callback, err, data);
997
- });
998
- } else {
999
- this.adapter.getBinaryState(id, (err, data) => {
1000
- if (data) {
1001
- data = Buffer.from(data).toString('base64');
1002
- }
1003
- SocketCommands._fixCallback(callback, err, data);
1004
- });
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);
1005
1175
  }
1006
1176
  } else {
1007
1177
  this.adapter.log.warn('[getBinaryState] Invalid callback')
@@ -1015,16 +1185,21 @@ class SocketCommands {
1015
1185
  let data = null;
1016
1186
  try {
1017
1187
  data = Buffer.from(base64, 'base64')
1018
- } catch (e) {
1019
- 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());
1020
1190
  }
1021
1191
 
1022
- if (this.adapter.setForeignBinaryState) {
1023
- this.adapter.setForeignBinaryState(id, data, (err, ...args) =>
1024
- SocketCommands._fixCallback(callback, err, ...args));
1025
- } else {
1026
- this.adapter.setBinaryState(id, data, (err, ...args) =>
1027
- 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);
1028
1203
  }
1029
1204
  } else {
1030
1205
  this.adapter.log.warn('[setBinaryState] Invalid callback');
@@ -1042,60 +1217,82 @@ class SocketCommands {
1042
1217
  __initCommandsObjects() {
1043
1218
  this.commands['getObject'] = (socket, id, callback) => {
1044
1219
  if (this._checkPermissions(socket, 'getObject', callback, id)) {
1045
- this.adapter.getForeignObject(id, {user: socket._acl.user}, (err, obj) => {
1046
- // overload language from current instance
1047
- if (this.adapter._language && id === 'system.config' && obj.common) {
1048
- obj.common.language = this.adapter._language;
1049
- }
1050
- SocketCommands._fixCallback(callback, err, obj);
1051
- });
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
+ }
1052
1232
  }
1053
1233
  };
1054
1234
 
1055
1235
  // not admin version of "all objects"
1056
1236
  this.commands['getObjects'] = (socket, callback) => {
1057
1237
  if (this._checkPermissions(socket, 'getObjects', callback)) {
1058
- this.adapter.getForeignObjects('*', 'state', 'rooms', {user: socket._acl.user}, (err, objs) => {
1059
- if (typeof callback === 'function') {
1060
- // overload language
1061
- if (this.adapter._language && objs['system.config'] && objs['system.config'].common) {
1062
- objs['system.config'].common.language = this.adapter._language;
1063
- }
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
+ }
1064
1245
 
1065
- callback(err, objs);
1066
- } else {
1067
- this.adapter.log.warn('[getObjects] Invalid callback');
1068
- }
1069
- });
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
+ }
1070
1255
  }
1071
1256
  };
1072
1257
 
1073
1258
  this.commands['subscribeObjects'] = (socket, pattern, callback) => {
1074
1259
  if (this._checkPermissions(socket, 'subscribeObjects', callback, pattern)) {
1075
- if (pattern && typeof pattern === 'object' && pattern instanceof Array) {
1076
- for (let p = 0; p < pattern.length; p++) {
1077
- 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);
1078
1274
  }
1079
- } else {
1080
- this.subscribe(socket, 'objectChange', pattern);
1081
- }
1082
- if (typeof callback === 'function') {
1083
- setImmediate(callback, null);
1084
1275
  }
1085
1276
  }
1086
1277
  };
1087
1278
 
1088
1279
  this.commands['unsubscribeObjects'] = (socket, pattern, callback) => {
1089
1280
  if (this._checkPermissions(socket, 'unsubscribeObjects', callback, pattern)) {
1090
- if (pattern && typeof pattern === 'object' && pattern instanceof Array) {
1091
- for (let p = 0; p < pattern.length; p++) {
1092
- 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);
1093
1295
  }
1094
- } else {
1095
- this.unsubscribe(socket, 'objectChange', pattern);
1096
- }
1097
- if (typeof callback === 'function') {
1098
- setImmediate(callback, null);
1099
1296
  }
1100
1297
  }
1101
1298
  };
@@ -1103,7 +1300,12 @@ class SocketCommands {
1103
1300
  this.commands['getObjectView'] = (socket, design, search, params, callback) => {
1104
1301
  if (typeof callback === 'function') {
1105
1302
  if (this._checkPermissions(socket, 'getObjectView', callback, search)) {
1106
- 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
+ }
1107
1309
  }
1108
1310
  } else {
1109
1311
  this.adapter.log.error('Callback is not a function');
@@ -1112,8 +1314,13 @@ class SocketCommands {
1112
1314
 
1113
1315
  this.commands['setObject'] = (socket, id, obj, callback) => {
1114
1316
  if (this._checkPermissions(socket, 'setObject', callback, id)) {
1115
- this.adapter.setForeignObject(id, obj, {user: socket._acl.user}, (err, ...args) =>
1116
- 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
+ }
1117
1324
  }
1118
1325
  };
1119
1326
  }