1 | function _typeof(obj) {
|
2 | if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
|
3 | _typeof = function (obj) {
|
4 | return typeof obj;
|
5 | };
|
6 | } else {
|
7 | _typeof = function (obj) {
|
8 | return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
|
9 | };
|
10 | }
|
11 |
|
12 | return _typeof(obj);
|
13 | }
|
14 |
|
15 | function _slicedToArray(arr, i) {
|
16 | return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
|
17 | }
|
18 |
|
19 | function _arrayWithHoles(arr) {
|
20 | if (Array.isArray(arr)) return arr;
|
21 | }
|
22 |
|
23 | function _iterableToArrayLimit(arr, i) {
|
24 | var _arr = [];
|
25 | var _n = true;
|
26 | var _d = false;
|
27 | var _e = undefined;
|
28 |
|
29 | try {
|
30 | for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
|
31 | _arr.push(_s.value);
|
32 |
|
33 | if (i && _arr.length === i) break;
|
34 | }
|
35 | } catch (err) {
|
36 | _d = true;
|
37 | _e = err;
|
38 | } finally {
|
39 | try {
|
40 | if (!_n && _i["return"] != null) _i["return"]();
|
41 | } finally {
|
42 | if (_d) throw _e;
|
43 | }
|
44 | }
|
45 |
|
46 | return _arr;
|
47 | }
|
48 |
|
49 | function _nonIterableRest() {
|
50 | throw new TypeError("Invalid attempt to destructure non-iterable instance");
|
51 | }
|
52 |
|
53 | const { React } = window;
|
54 | const PureComponent = React.PureComponent;
|
55 | const Component = React.Component;
|
56 | const useState = React.useState;
|
57 | const useEffect = React.useEffect;
|
58 |
|
59 | var dataUpdateEvents = ["onFieldChanged", "onRecordCreated", "onRecordDeleted", "onRecordRefreshed", "onAfterSave", "onCancelEdit", "onDataLoaded"];
|
60 | function useCurrentRow(dataObject) {
|
61 | var _useState = useState({}),
|
62 | _useState2 = _slicedToArray(_useState, 2),
|
63 | record = _useState2[0],
|
64 | setRecord = _useState2[1];
|
65 |
|
66 | function updateRecord() {
|
67 | setRecord(dataObject.currentRow());
|
68 | }
|
69 |
|
70 | useEffect(function () {
|
71 | var recordUpdateEvents = ["onCurrentIndexChanged"].concat(dataUpdateEvents);
|
72 | recordUpdateEvents.forEach(function (event) {
|
73 | return dataObject.attachEvent(event, updateRecord);
|
74 | });
|
75 | updateRecord();
|
76 | return function () {
|
77 | return recordUpdateEvents.forEach(function (event) {
|
78 | return dataObject.detachEvent(event, updateRecord);
|
79 | });
|
80 | };
|
81 | }, [dataObject]);
|
82 | return record;
|
83 | }
|
84 | function useData(dataObject) {
|
85 | var _useState3 = useState([]),
|
86 | _useState4 = _slicedToArray(_useState3, 2),
|
87 | data = _useState4[0],
|
88 | setData = _useState4[1];
|
89 |
|
90 | function updateData() {
|
91 | setData(dataObject.getData());
|
92 | }
|
93 |
|
94 | useEffect(function () {
|
95 | dataUpdateEvents.forEach(function (event) {
|
96 | return dataObject.attachEvent(event, updateData);
|
97 | });
|
98 | updateData();
|
99 | return function () {
|
100 | return dataUpdateEvents.forEach(function (event) {
|
101 | return dataObject.detachEvent(event, updateData);
|
102 | });
|
103 | };
|
104 | }, [dataObject]);
|
105 | return data;
|
106 | }
|
107 |
|
108 | function getData(dataObject, filter) {
|
109 | var data = window.af.data;
|
110 | var dataHandler = new data.DataProviderHandler({
|
111 | dataSourceId: dataObject.getDataSourceId(),
|
112 | timeout: 30000
|
113 | });
|
114 | var fields = dataObject.getFields();
|
115 | return new Promise(function (resolve, reject) {
|
116 | var filterData = {
|
117 | filterString: "",
|
118 | whereClause: typeof filter === "string" ? filter : "",
|
119 | whereObject: _typeof(filter) === "object" ? filter : null
|
120 | };
|
121 | dataHandler.retrieve(filterData, function (error, data) {
|
122 | if (error !== null) {
|
123 | reject(error);
|
124 | } else {
|
125 | var records = [];
|
126 | var _iteratorNormalCompletion = true;
|
127 | var _didIteratorError = false;
|
128 | var _iteratorError = undefined;
|
129 |
|
130 | try {
|
131 | for (var _iterator = data[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
132 | var item = _step.value;
|
133 | var record = {};
|
134 |
|
135 | for (var i = 0; i < item.length; i++) {
|
136 | record[fields[i].name] = item[i];
|
137 | }
|
138 |
|
139 | records.push(record);
|
140 | }
|
141 | } catch (err) {
|
142 | _didIteratorError = true;
|
143 | _iteratorError = err;
|
144 | } finally {
|
145 | try {
|
146 | if (!_iteratorNormalCompletion && _iterator.return != null) {
|
147 | _iterator.return();
|
148 | }
|
149 | } finally {
|
150 | if (_didIteratorError) {
|
151 | throw _iteratorError;
|
152 | }
|
153 | }
|
154 | }
|
155 |
|
156 | resolve(records);
|
157 | }
|
158 | });
|
159 | });
|
160 | }
|
161 |
|
162 | function useSingleRecord(dataObject, filter) {
|
163 |
|
164 | console.warn("DEPRECATED: useSingleRecord has been renamed to useRecord");
|
165 | return useFetchRecord(dataObject, filter);
|
166 | }
|
167 | function useDataWithoutState(dataObject, filter) {
|
168 |
|
169 | console.warn("DEPRECATED: useDataWithoutState has been renamed to useRecord");
|
170 | return useFetchData(dataObject, filter);
|
171 | }
|
172 | function useFetchRecord(dataObject, filter) {
|
173 | var _useFetchData = useFetchData(dataObject, filter),
|
174 | isLoading = _useFetchData.isLoading,
|
175 | data = _useFetchData.data,
|
176 | refresh = _useFetchData.refresh;
|
177 |
|
178 | var record = data.length > 0 ? data[0] : {};
|
179 | return {
|
180 | record: record,
|
181 | refresh: refresh,
|
182 | isLoading: isLoading
|
183 | };
|
184 | }
|
185 | function useFetchData(dataObject, filter) {
|
186 | var _useState = useState([]),
|
187 | _useState2 = _slicedToArray(_useState, 2),
|
188 | data = _useState2[0],
|
189 | setData = _useState2[1];
|
190 |
|
191 | var _useState3 = useState(true),
|
192 | _useState4 = _slicedToArray(_useState3, 2),
|
193 | isLoading = _useState4[0],
|
194 | setIsLoading = _useState4[1];
|
195 |
|
196 | function refresh() {
|
197 | setIsLoading(true);
|
198 | getData(dataObject, filter).then(function (data) {
|
199 | if (data.length > 0) {
|
200 | setData(data);
|
201 | } else {
|
202 | setData([]);
|
203 | }
|
204 |
|
205 | setIsLoading(false);
|
206 | });
|
207 | }
|
208 |
|
209 | useEffect(function () {
|
210 | refresh();
|
211 | }, [dataObject, filter]);
|
212 | return {
|
213 | data: data,
|
214 | refresh: refresh,
|
215 | isLoading: isLoading
|
216 | };
|
217 | }
|
218 |
|
219 | function useCurrentIndex(dataObject) {
|
220 | var _useState = useState(dataObject.getCurrentIndex()),
|
221 | _useState2 = _slicedToArray(_useState, 2),
|
222 | index = _useState2[0],
|
223 | setIndex = _useState2[1];
|
224 |
|
225 | useEffect(function () {
|
226 | dataObject.attachEvent("onCurrentIndexChanged", setIndex);
|
227 | setIndex(dataObject.getCurrentIndex());
|
228 | return function () {
|
229 | return dataObject.detachEvent("onCurrentIndexChanged", setIndex);
|
230 | };
|
231 | }, [dataObject]);
|
232 | return index;
|
233 | }
|
234 | function useDirty(dataObject) {
|
235 | var _useState3 = useState(false),
|
236 | _useState4 = _slicedToArray(_useState3, 2),
|
237 | isDirty = _useState4[0],
|
238 | setDirty = _useState4[1];
|
239 |
|
240 | useEffect(function () {
|
241 | dataObject.attachEvent("onDirtyChanged", setDirty);
|
242 | setDirty(dataObject.isDirty());
|
243 | return function () {
|
244 | dataObject.detachEvent("onDirtyChanged", setDirty);
|
245 | };
|
246 | }, [dataObject]);
|
247 | return isDirty;
|
248 | }
|
249 | function useError(dataObject) {
|
250 | var _useState5 = useState(null),
|
251 | _useState6 = _slicedToArray(_useState5, 2),
|
252 | loadError = _useState6[0],
|
253 | setError = _useState6[1];
|
254 |
|
255 | useEffect(function () {
|
256 | dataObject.attachEvent("onDataLoadFailed", setError);
|
257 | return function () {
|
258 | dataObject.detachEvent("onDataLoadFailed", setError);
|
259 | };
|
260 | }, [dataObject]);
|
261 | return loadError;
|
262 | }
|
263 | function useLoading(dataObject) {
|
264 | var _useState7 = useState(dataObject.isDataLoading()),
|
265 | _useState8 = _slicedToArray(_useState7, 2),
|
266 | isLoading = _useState8[0],
|
267 | setLoading = _useState8[1];
|
268 |
|
269 | function setIsLoading() {
|
270 | setLoading(true);
|
271 | }
|
272 |
|
273 | function setIsNotLoading() {
|
274 | setLoading(false);
|
275 | }
|
276 |
|
277 | useEffect(function () {
|
278 | dataObject.attachEvent("onBeforeLoad", setIsLoading);
|
279 | dataObject.attachEvent("onDataLoaded", setIsNotLoading);
|
280 | dataObject.attachEvent("onDataLoadFailed", setIsNotLoading);
|
281 | setLoading(dataObject.isDataLoading());
|
282 | return function () {
|
283 | dataObject.detachEvent("onBeforeLoad", setIsLoading);
|
284 | dataObject.detachEvent("onDataLoaded", setIsNotLoading);
|
285 | dataObject.detachEvent("onDataLoadFailed", setIsNotLoading);
|
286 | };
|
287 | }, [dataObject]);
|
288 | return isLoading;
|
289 | }
|
290 | function useStatus(dataObject) {
|
291 | var _useState9 = useState(false),
|
292 | _useState10 = _slicedToArray(_useState9, 2),
|
293 | isSaving = _useState10[0],
|
294 | setIsSaving = _useState10[1];
|
295 |
|
296 | var _useState11 = useState(false),
|
297 | _useState12 = _slicedToArray(_useState11, 2),
|
298 | isDeleting = _useState12[0],
|
299 | setIsDeleting = _useState12[1];
|
300 |
|
301 | function setSaving() {
|
302 | setIsSaving(true);
|
303 | }
|
304 |
|
305 | function setNotSaving() {
|
306 | setIsSaving(false);
|
307 | }
|
308 |
|
309 | function setDeleting() {
|
310 | setIsDeleting(true);
|
311 | }
|
312 |
|
313 | function setNotDeleting() {
|
314 | setIsDeleting(false);
|
315 | }
|
316 |
|
317 | useEffect(function () {
|
318 | dataObject.attachEvent("onBeforeSave", setSaving);
|
319 | dataObject.attachEvent("onAfterSave", setNotSaving);
|
320 | dataObject.attachEvent("onSaveFailed", setNotSaving);
|
321 | dataObject.attachEvent("onRecordDeleting", setDeleting);
|
322 | dataObject.attachEvent("onRecordDeleted", setNotDeleting);
|
323 | return function () {
|
324 | dataObject.detachEvent("onBeforeSave", setSaving);
|
325 | dataObject.detachEvent("onAfterSave", setNotSaving);
|
326 | dataObject.detachEvent("onSaveFailed", setNotSaving);
|
327 | dataObject.detachEvent("onRecordDeleting", setDeleting);
|
328 | dataObject.detachEvent("onRecordDeleted", setNotDeleting);
|
329 | };
|
330 | }, [dataObject]);
|
331 | return {
|
332 | isDeleting: isDeleting,
|
333 | isSaving: isSaving
|
334 | };
|
335 | }
|
336 | function usePermissions(dataObject) {
|
337 | var _useState13 = useState(dataObject.isDeleteAllowed()),
|
338 | _useState14 = _slicedToArray(_useState13, 2),
|
339 | allowDelete = _useState14[0],
|
340 | setAllowDelete = _useState14[1];
|
341 |
|
342 | var _useState15 = useState(dataObject.isInsertAllowed()),
|
343 | _useState16 = _slicedToArray(_useState15, 2),
|
344 | allowInsert = _useState16[0],
|
345 | setAllowInsert = _useState16[1];
|
346 |
|
347 | var _useState17 = useState(dataObject.isUpdateAllowed()),
|
348 | _useState18 = _slicedToArray(_useState17, 2),
|
349 | allowUpdate = _useState18[0],
|
350 | setAllowUpdate = _useState18[1];
|
351 |
|
352 | useEffect(function () {
|
353 | dataObject.attachEvent("onAllowDeleteChanged", setAllowDelete);
|
354 | dataObject.attachEvent("onAllowInsertChanged", setAllowInsert);
|
355 | dataObject.attachEvent("onAllowUpdateChanged", setAllowUpdate);
|
356 | return function () {
|
357 | dataObject.detachEvent("onAllowDeleteChanged", setAllowDelete);
|
358 | dataObject.detachEvent("onAllowInsertChanged", setAllowInsert);
|
359 | dataObject.detachEvent("onAllowUpdateChanged", setAllowUpdate);
|
360 | };
|
361 | }, [dataObject]);
|
362 | return {
|
363 | allowDelete: allowDelete,
|
364 | allowInsert: allowInsert,
|
365 | allowUpdate: allowUpdate
|
366 | };
|
367 | }
|
368 |
|
369 | export { useCurrentIndex, useDirty, useError, useLoading, useStatus, usePermissions, useCurrentRow, useData, useSingleRecord, useDataWithoutState, useFetchData, useFetchRecord, getData };
|