@bringg/dashboard-sdk 4.2.3 → 4.3.1

package/dist/bringg-dashboard-sdk-cjs2.js

@@ -35589,7 +35589,7 @@ var Logger_1 = __webpack_require__(48);
 var lodash_1 = __webpack_require__(11);
 var BringgException_1 = __webpack_require__(15);
 var abort_1 = __webpack_require__(169);
-var version = '4.2.3';
+var version = '4.3.1';
 function logErrorResponse(response) {
     var data = response.data, status = response.status;
     try {
@@ -44814,6 +44814,15 @@ var TasksApi = /** @class */ (function () {
     TasksApi.prototype.onCreate = function (callback) {
         this.taskRealtimeSubscriptions.onCreate(callback);
     };
+    TasksApi.prototype.onDelete = function (callback) {
+        this.taskRealtimeSubscriptions.onDelete(callback);
+    };
+    TasksApi.prototype.onWayPointUpdate = function (callback) {
+        this.taskRealtimeSubscriptions.onWayPointUpdate(callback);
+    };
+    TasksApi.prototype.onWayPointDelete = function (callback) {
+        this.taskRealtimeSubscriptions.onWayPointDelete(callback);
+    };
     TasksApi.prototype.get = function (id, fields) {
         return this.getMany([id], this.getFieldsToLoad(fields))[0];
     };
@@ -44826,6 +44835,11 @@ var TasksApi = /** @class */ (function () {
     TasksApi.prototype.getAllById = function () {
         return this.tasksStore.getAllById();
     };
+    TasksApi.prototype.load = function (id, options) {
+        var _this = this;
+        if (options === void 0) { options = data_entity_1.DEFAULT_OPTIONS; }
+        return this.storableDataService.load('load', function () { return _this.tasksService.load(id); }, id, options);
+    };
     TasksApi.prototype.loadMany = function (ids, fields, options) {
         if (options === void 0) { options = data_entity_1.DEFAULT_OPTIONS; }
         return __awaiter(this, void 0, void 0, function () {
@@ -44893,6 +44907,76 @@ var TasksApi = /** @class */ (function () {
     TasksApi.prototype.massUnassign = function (taskIds, options) {
         return this.tasksService.massUnassign(taskIds, options);
     };
+    TasksApi.prototype.massCancel = function (taskIds, reasonId, text, automaticallyCancelled) {
+        return this.tasksService.massCancel(taskIds, reasonId, text, automaticallyCancelled);
+    };
+    TasksApi.prototype.loadInvalid = function (options) {
+        var _this = this;
+        if (options === void 0) { options = data_entity_1.DEFAULT_OPTIONS; }
+        return this.storableDataService.loadAll('loadInvalid', function () { return _this.tasksService.loadInvalid(); }, __assign(__assign({}, options), { groupType: Tasks_consts_1.TaskGroupTypes.Main, groupValue: Tasks_consts_1.GROUP_VALUES.Invalid }));
+    };
+    TasksApi.prototype.loadClosed = function (options) {
+        var _this = this;
+        if (options === void 0) { options = data_entity_1.DEFAULT_OPTIONS; }
+        return this.storableDataService.loadAll('loadClosed', function () { return _this.tasksService.loadClosed(); }, __assign(__assign({}, options), { groupType: Tasks_consts_1.TaskGroupTypes.Main, groupValue: Tasks_consts_1.GROUP_VALUES.Closed }));
+    };
+    TasksApi.prototype.broadcastToDrivers = function (id, userIds, message) {
+        return this.tasksService.broadcastToDrivers(id, userIds, message);
+    };
+    TasksApi.prototype.acknowledgeTask = function (id) {
+        var _this = this;
+        return this.storableDataService.modify('acknowledgeTask', function () { return _this.tasksService.acknowledgeTask(id); });
+    };
+    TasksApi.prototype.releaseToDrivers = function (ids) {
+        return this.tasksService.releaseToDrivers(ids);
+    };
+    TasksApi.prototype.moveToPlanning = function (ids) {
+        return this.tasksService.moveToPlanning(ids);
+    };
+    TasksApi.prototype.update = function (task) {
+        var _this = this;
+        return this.storableDataService.modify('update', function () { return _this.tasksService.update(task); });
+    };
+    TasksApi.prototype.updatePreparationStatus = function (taskId, preparationStatus) {
+        return this.tasksService.updatePreparationStatus(taskId, preparationStatus);
+    };
+    TasksApi.prototype.rescheduleVirtualTasks = function (taskIds, noLaterThan, noEarlierThan) {
+        return this.tasksService.rescheduleVirtualTasks(taskIds, noLaterThan, noEarlierThan);
+    };
+    TasksApi.prototype.duplicate = function (taskId) {
+        return this.tasksService.duplicate(taskId);
+    };
+    TasksApi.prototype.getChildTasks = function (taskId) {
+        return this.tasksService.getChildTasks(taskId);
+    };
+    TasksApi.prototype.lock = function (taskIds) {
+        return this.tasksService.lock(taskIds);
+    };
+    TasksApi.prototype.unlock = function (taskIds) {
+        return this.tasksService.unlock(taskIds);
+    };
+    TasksApi.prototype.finish = function (id) {
+        var _this = this;
+        return this.storableDataService.modify('finish', function () { return _this.tasksService.finish(id); });
+    };
+    TasksApi.prototype.rescheduleCancelled = function (taskId) {
+        return this.tasksService.rescheduleCancelled(taskId);
+    };
+    TasksApi.prototype.addTaskNote = function (taskId, wayPointId, note, type, image) {
+        return this.tasksService.addTaskNote(taskId, wayPointId, note, type, image);
+    };
+    TasksApi.prototype.getLocations = function (taskId) {
+        return this.tasksService.getLocations(taskId);
+    };
+    TasksApi.prototype.deleteWayPoint = function (taskId, wayPointId) {
+        return this.tasksService.deleteWayPoint(taskId, wayPointId);
+    };
+    TasksApi.prototype.importTasksCsv = function (file) {
+        return this.tasksService.importTasksCsv(file);
+    };
+    TasksApi.prototype.activityLog = function (taskId) {
+        return this.tasksService.activityLog(taskId);
+    };
     TasksApi.prototype.getFieldsToLoad = function (fields) {
         if (!fields) {
             return fields;
@@ -76805,26 +76889,20 @@ var VehicleTypeEntity = /** @class */ (function (_super) {
     };
     VehicleTypeEntity.prototype.createVehicleType = function (vehicle_type) {
         return __awaiter(this, void 0, void 0, function () {
-            var response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.create(vehicle_type)];
-                    case 1:
-                        response = _a.sent();
-                        return [2 /*return*/, (0, exports.singleExtractor)(response)];
+                    case 0: return [4 /*yield*/, this.create(vehicle_type, exports.singleExtractor, exports.singleExtractor)];
+                    case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
     VehicleTypeEntity.prototype.updateVehicleType = function (id, vehicle_type) {
         return __awaiter(this, void 0, void 0, function () {
-            var response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.update(id, vehicle_type)];
-                    case 1:
-                        response = _a.sent();
-                        return [2 /*return*/, (0, exports.singleExtractor)(response)];
+                    case 0: return [4 /*yield*/, this.update(id, vehicle_type, exports.singleExtractor, exports.singleExtractor)];
+                    case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
@@ -93462,6 +93540,18 @@ var CrudService_1 = __webpack_require__(38);
 var Tasks_consts_1 = __webpack_require__(52);
 var TasksService = /** @class */ (function () {
     function TasksService(session) {
+        var _this = this;
+        this.addTaskNote = function (taskId, wayPointId, note, type, image, commonOptions) {
+            return _this.service.routeGenerator
+                .post(Tasks_consts_1.Routes.CREATE_TASK_NOTE)
+                .withRouteParams({ id: taskId, way_point_id: wayPointId })
+                .withQueryString({ note: note })
+                .withPayload({ type: type, image: image })
+                .setException("failed to add note to task : ".concat(taskId))
+                .withExtractor(Tasks_consts_1.taskExtractor)
+                .withCommonOptions(commonOptions)
+                .invoke();
+        };
         this.service = new CrudService_1.default(session, 'tasks');
     }
     TasksService.prototype.load = function (id) {
@@ -93500,6 +93590,62 @@ var TasksService = /** @class */ (function () {
             .withCommonOptions(commonOptions)
             .invoke();
     };
+    TasksService.prototype.loadInvalid = function (commonOptions) {
+        return this.service.routeGenerator
+            .get(Tasks_consts_1.Routes.GET_INVALID_TASKS)
+            .setException("failed to fetch invalid tasks")
+            .withCommonOptions(commonOptions)
+            .invoke();
+    };
+    TasksService.prototype.loadClosed = function (commonOptions) {
+        return this.service.routeGenerator
+            .get(Tasks_consts_1.Routes.GET_CLOSED_TASKS_SINCE_TIMESTAMP)
+            .setException("failed to fetch closed tasks")
+            .withCommonOptions(commonOptions)
+            .invoke();
+    };
+    TasksService.prototype.broadcastToDrivers = function (id, userIds, message, commonOptions) {
+        return this.service.routeGenerator
+            .post(Tasks_consts_1.Routes.BROADCAST_TO_DRIVERS)
+            .withPayload({ task_id: id, user_ids: userIds, message: message })
+            .withCommonOptions(commonOptions)
+            .setException("failed to broadcast to drivers task : ".concat(id))
+            .invoke();
+    };
+    TasksService.prototype.acknowledgeTask = function (id, commonOptions) {
+        return this.service.routeGenerator
+            .post(Tasks_consts_1.Routes.ACKNOWLEDGE_TASK)
+            .withExtractor(Tasks_consts_1.taskExtractor)
+            .setException("failed to acknowledge task - ".concat(id))
+            .withPayload({ task_id: id })
+            .withCommonOptions(commonOptions)
+            .invoke();
+    };
+    TasksService.prototype.releaseToDrivers = function (ids, commonOptions) {
+        return this.service.routeGenerator
+            .post(Tasks_consts_1.Routes.RELEASE_TASKS_TO_DRIVERS)
+            .setException("failed to release tasks [".concat(ids.join(', '), "] to drivers"))
+            .withPayload({ ids: ids })
+            .withCommonOptions(commonOptions)
+            .invoke();
+    };
+    TasksService.prototype.moveToPlanning = function (ids, commonOptions) {
+        return this.service.routeGenerator
+            .post(Tasks_consts_1.Routes.MOVE_TASKS_TO_PLANNING)
+            .setException("failed to move tasks [".concat(ids.join(', '), "] to planning"))
+            .withPayload({ task_ids: ids })
+            .withCommonOptions(commonOptions)
+            .invoke();
+    };
+    TasksService.prototype.massCancel = function (taskIds, reasonId, text, automaticallyCancelled, commonOptions) {
+        return this.service.routeGenerator
+            .post(Tasks_consts_1.Routes.MASS_TASK_CANCEL)
+            .withExtractor(Tasks_consts_1.successExtractor)
+            .setException("failed to cancel tasks [".concat(taskIds.join(', '), "]"))
+            .withPayload({ task_ids: taskIds, reason: reasonId, text: text, automatically_cancelled: automaticallyCancelled })
+            .withCommonOptions(commonOptions)
+            .invoke();
+    };
     TasksService.prototype.massAssign = function (user_id, ids, options, targetRun) {
         return this.service.routeGenerator
             .post(Tasks_consts_1.Routes.MASS_TASK_ASSIGN)
@@ -93516,6 +93662,39 @@ var TasksService = /** @class */ (function () {
             .withCommonOptions(options)
             .invoke();
     };
+    TasksService.prototype.update = function (task) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.service.update(task.id, task)];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.task];
+                }
+            });
+        });
+    };
+    TasksService.prototype.updatePreparationStatus = function (taskId, preparationStatus, commonOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.service.routeGenerator
+                        .post(Tasks_consts_1.Routes.UPDATE_TASK_PREPARATION_STATUS)
+                        .setException("failed to update preparation status taskId: ".concat(taskId, ", status: ").concat(preparationStatus))
+                        .withPayload({ task_id: taskId, preparation_status: preparationStatus })
+                        .withCommonOptions(commonOptions)
+                        .invoke()];
+            });
+        });
+    };
+    TasksService.prototype.rescheduleVirtualTasks = function (taskIds, noLaterThan, noEarlierThan) {
+        return this.service.routeGenerator
+            .post(Tasks_consts_1.Routes.RESCHEDULE_VIRTUAL_TASKS)
+            .withExtractor(Tasks_consts_1.taskIdsExtractor)
+            .withPayload({ task_ids: taskIds, no_later_than: noLaterThan, no_earlier_than: noEarlierThan })
+            .setException("failed to get reschedule virtual tasks for tasks : [".concat(taskIds.join(', '), "]"))
+            .invoke();
+    };
     TasksService.prototype.batchLoad = function (ids, fields, options) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
@@ -93529,6 +93708,92 @@ var TasksService = /** @class */ (function () {
             });
         });
     };
+    TasksService.prototype.duplicate = function (taskId, commonOptions) {
+        return this.service.routeGenerator
+            .post(Tasks_consts_1.Routes.DUPLICATE_TASK)
+            .withExtractor(Tasks_consts_1.taskExtractor)
+            .withPayload({ id: taskId })
+            .setException("failed to duplicate task ".concat(taskId))
+            .withRouteParams({ id: taskId })
+            .withCommonOptions(commonOptions)
+            .invoke();
+    };
+    TasksService.prototype.getChildTasks = function (taskId, commonOptions) {
+        return this.service.routeGenerator
+            .get(Tasks_consts_1.Routes.GET_CHILD_TASKS)
+            .withExtractor(Tasks_consts_1.childTasksExtractor)
+            .withRouteParams({ id: taskId })
+            .setException("failed to get child tasks for task ".concat(taskId))
+            .withCommonOptions(commonOptions)
+            .invoke();
+    };
+    TasksService.prototype.unlock = function (taskIds, commonOptions) {
+        return this.service.routeGenerator
+            .post(Tasks_consts_1.Routes.UNLOCK_TASK)
+            .withExtractor(Tasks_consts_1.successExtractor)
+            .withPayload({ task_ids: taskIds })
+            .setException("failed to unlock the tasks [".concat(taskIds.join(', '), "]"))
+            .withCommonOptions(commonOptions)
+            .invoke();
+    };
+    TasksService.prototype.lock = function (taskIds, commonOptions) {
+        return this.service.routeGenerator
+            .post(Tasks_consts_1.Routes.LOCK_TASK)
+            .withExtractor(Tasks_consts_1.successExtractor)
+            .withPayload({ task_ids: taskIds })
+            .setException("failed to lock the tasks [".concat(taskIds.join(', '), "]"))
+            .withCommonOptions(commonOptions)
+            .invoke();
+    };
+    TasksService.prototype.finish = function (id, commonOptions) {
+        return this.service.routeGenerator
+            .post(Tasks_consts_1.Routes.FINISH_TASK)
+            .withExtractor(Tasks_consts_1.defaultExtractor)
+            .setException("failed to finish task - ".concat(id))
+            .withRouteParams({ id: id })
+            .withCommonOptions(commonOptions)
+            .invoke();
+    };
+    TasksService.prototype.rescheduleCancelled = function (id, commonOptions) {
+        return this.service.routeGenerator
+            .post(Tasks_consts_1.Routes.RESCHEDULE_CANCELED)
+            .withPayload({ id: id })
+            .setException("failed to reschedule cancelled task ".concat(id))
+            .withCommonOptions(commonOptions)
+            .invoke();
+    };
+    TasksService.prototype.getLocations = function (id) {
+        return this.service.routeGenerator
+            .get(Tasks_consts_1.Routes.GET_TASK_LOCATIONS)
+            .withExtractor(Tasks_consts_1.locationExtractor)
+            .withRouteParams({ id: id })
+            .setException("failed to get location of the task ".concat(id))
+            .invoke();
+    };
+    TasksService.prototype.deleteWayPoint = function (taskId, wayPointId) {
+        return this.service.routeGenerator
+            .delete(Tasks_consts_1.Routes.DELETE_WAYPOINT)
+            .withRouteParams({ id: taskId, way_point_id: wayPointId })
+            .setException("failed to delete waypoint : task ".concat(taskId, ", waypoint ").concat(wayPointId))
+            .invoke();
+    };
+    TasksService.prototype.importTasksCsv = function (file) {
+        var formData = new FormData();
+        formData.append('file', file);
+        return this.service.routeGenerator
+            .post(Tasks_consts_1.Routes.IMPORT_TASKS_CSV)
+            .withHeaders({ 'Content-Type': 'multipart/form-data' })
+            .withPayload(formData)
+            .invoke();
+    };
+    TasksService.prototype.activityLog = function (id) {
+        return this.service.routeGenerator
+            .get(Tasks_consts_1.Routes.GET_TASK_ACTIVITY_LOG)
+            .withExtractor(Tasks_consts_1.defaultExtractor)
+            .withRouteParams({ id: id })
+            .setException("failed to get activity log for task ".concat(id))
+            .invoke();
+    };
     return TasksService;
 }());
 exports.default = TasksService;
@@ -107099,24 +107364,16 @@ var TaskRealtimeSubscriptions = /** @class */ (function () {
         });
     };
     TaskRealtimeSubscriptions.prototype.onCreate = function (callback) {
-        var subscriptions = [];
-        subscriptions.push(this.onEvent(Tasks_consts_1.TaskRealTimeEvents.NEW_TASK, callback));
-        return function () {
-            var e_1, _a;
-            try {
-                for (var subscriptions_1 = __values(subscriptions), subscriptions_1_1 = subscriptions_1.next(); !subscriptions_1_1.done; subscriptions_1_1 = subscriptions_1.next()) {
-                    var subscription = subscriptions_1_1.value;
-                    subscription();
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (subscriptions_1_1 && !subscriptions_1_1.done && (_a = subscriptions_1.return)) _a.call(subscriptions_1);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-        };
+        this.onEvent(Tasks_consts_1.TaskRealTimeEvents.NEW_TASK, callback);
+    };
+    TaskRealtimeSubscriptions.prototype.onDelete = function (callback) {
+        this.onEvent(Tasks_consts_1.TaskRealTimeEvents.TASK_DELETED, callback);
+    };
+    TaskRealtimeSubscriptions.prototype.onWayPointUpdate = function (callback) {
+        this.onEvent(Tasks_consts_1.TaskRealTimeEvents.WAYPOINT_UPDATED, callback);
+    };
+    TaskRealtimeSubscriptions.prototype.onWayPointDelete = function (callback) {
+        this.onEvent(Tasks_consts_1.TaskRealTimeEvents.WAYPOINT_DELETED, callback);
     };
     TaskRealtimeSubscriptions.prototype.onUpdate = function (callback) {
         var subscriptions = [];
@@ -107127,19 +107384,19 @@ var TaskRealtimeSubscriptions = /** @class */ (function () {
         subscriptions.push(this.onEvent(Tasks_consts_1.TaskRealTimeEvents.WAYPOINT_ADDED, callback));
         subscriptions.push(this.onEvent(Tasks_consts_1.TaskRealTimeEvents.WAYPOINT_DELETED, callback));
         return function () {
-            var e_2, _a;
+            var e_1, _a;
             try {
-                for (var subscriptions_2 = __values(subscriptions), subscriptions_2_1 = subscriptions_2.next(); !subscriptions_2_1.done; subscriptions_2_1 = subscriptions_2.next()) {
-                    var subscription = subscriptions_2_1.value;
+                for (var subscriptions_1 = __values(subscriptions), subscriptions_1_1 = subscriptions_1.next(); !subscriptions_1_1.done; subscriptions_1_1 = subscriptions_1.next()) {
+                    var subscription = subscriptions_1_1.value;
                     subscription();
                 }
             }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
-                    if (subscriptions_2_1 && !subscriptions_2_1.done && (_a = subscriptions_2.return)) _a.call(subscriptions_2);
+                    if (subscriptions_1_1 && !subscriptions_1_1.done && (_a = subscriptions_1.return)) _a.call(subscriptions_1);
                 }
-                finally { if (e_2) throw e_2.error; }
+                finally { if (e_1) throw e_1.error; }
             }
         };
     };