@ricado/api-client 2.5.7 → 2.5.9

package/lib/Controllers/Packhouse/Site/PackingLineController.js

@@ -650,13 +650,13 @@ var _default = PackingLineController;
  * A **FreshPackIntegration** Type
  * 
  * @typedef {Object} PackingLineController.FreshPackIntegration
- * @property {{graders: number, binTypes: number, printerGroups: number, materialGroups: number, rejectCategories: number, productionFacilities: number, marketHolds: number, apiCommunicationStatus: number, currentPackrunClearanceSummary: number, nextPackrunClearanceSummary: number, currentPackrunMarketHolds: ?number, nextPackrunMarketHolds: ?number, apiVersion: ?number, activePackrunName: ?number, activeTimeBatch: ?number}} points The Points used for this FreshPack Integration
+ * @property {{graders: number, binTypes: number, printerGroups: number, materialGroups: number, rejectCategories: number, productionFacilities: number, marketHolds: number, varieties: ?number, produces: ?number, growingMethods: ?number, fruitClasses: ?number, fruitSizes: ?number, packStyles: ?number, nssLabelTypes: ?number, multiGrowerBinProducts: ?number, apiCommunicationStatus: number, currentPackrunClearanceSummary: number, nextPackrunClearanceSummary: number, currentPackrunMarketHolds: ?number, nextPackrunMarketHolds: ?number, apiVersion: ?number, activePackrunName: ?number, activeTimeBatch: ?number, classTypeMultiGrowerBinProductIds: ?number}} points The Points used for this FreshPack Integration
  * @property {boolean} enabled Whether the FreshPack Integration is Enabled on this Packing Line
  * @property {number[]} graderIds An Array of FreshPack Grader IDs that relate to this Packing Line
  * @property {string} apiBaseUrl Base URL of the FreshPack Web Portal API
  * @property {string} computerName A Computer Name to use when Performing Actions on the FreshPack API
  * @property {number} productionFacilityId FreshPack Production Facility ID this Packing Line is associated with
- * @property {Array<PackingLineController.ClassTypeRejectCategory>} classTypeRejectCategoryIds An Array of FreshPack Reject Category IDs that relate to Class Types on this Packing Line
+ * @property {?Array<PackingLineController.ClassTypeRejectCategory>} [classTypeRejectCategoryIds] An Array of FreshPack Reject Category IDs that relate to Class Types on this Packing Line
  * @property {?string[]} [packrunSourceTrayClassTypes] An Optional Array of Class Types that should be collected from FreshPack Tray Totals on this Packing Line
  * @memberof Controllers.Packhouse.Site
  */

package/lib/Controllers/Packhouse/Site/PackrunController.js

@@ -1866,6 +1866,502 @@ var PackrunController = /*#__PURE__*/function () {
         });
       });
     }
+    /**
+     * Retrive a Packrun's Latest Summary Data [GET /packhouse/sites/{siteId}/packruns/{id}/latestSummaryData]
+     * 
+     * Retrieves the Latest Summary Data for a Packrun
+     * 
+     * @static
+     * @public
+     * @param {number} siteId The Site ID
+     * @param {string} id The Packrun ID
+     * @return {Promise<PackrunController.PackrunLatestSummaryData>}
+     */
+
+  }, {
+    key: "getLatestSummaryData",
+    value: function getLatestSummaryData(siteId, id) {
+      return new Promise(function (resolve, reject) {
+        _RequestHelper.default.getRequest("/packhouse/sites/".concat(siteId, "/packruns/").concat(id, "/latestSummaryData")).then(function (result) {
+          var resolveValue = function () {
+            var resultObject = {};
+
+            if (_typeof(result) === 'object' && 'id' in result) {
+              resultObject.id = function () {
+                if (typeof result.id !== 'string') {
+                  return String(result.id);
+                }
+
+                return result.id;
+              }();
+            } else {
+              resultObject.id = "";
+            }
+
+            if (_typeof(result) === 'object' && 'name' in result) {
+              resultObject.name = function () {
+                if (typeof result.name !== 'string') {
+                  return String(result.name);
+                }
+
+                return result.name;
+              }();
+            } else {
+              resultObject.name = "";
+            }
+
+            if (_typeof(result) === 'object' && 'createdTimestamp' in result) {
+              resultObject.createdTimestamp = function () {
+                if (typeof result.createdTimestamp !== 'string') {
+                  return new Date(String(result.createdTimestamp));
+                }
+
+                return new Date(result.createdTimestamp);
+              }();
+            } else {
+              resultObject.createdTimestamp = new Date();
+            }
+
+            if (_typeof(result) === 'object' && 'growerName' in result) {
+              resultObject.growerName = function () {
+                if (typeof result.growerName !== 'string') {
+                  return String(result.growerName);
+                }
+
+                return result.growerName;
+              }();
+            } else {
+              resultObject.growerName = "";
+            }
+
+            if (_typeof(result) === 'object' && 'growerCode' in result) {
+              resultObject.growerCode = function () {
+                if (typeof result.growerCode !== 'string') {
+                  return String(result.growerCode);
+                }
+
+                return result.growerCode;
+              }();
+            } else {
+              resultObject.growerCode = "";
+            }
+
+            if (_typeof(result) === 'object' && 'maturityArea' in result) {
+              resultObject.maturityArea = function () {
+                if (result.maturityArea === null) {
+                  return null;
+                }
+
+                if (typeof result.maturityArea !== 'string') {
+                  return String(result.maturityArea);
+                }
+
+                return result.maturityArea;
+              }();
+            } else {
+              resultObject.maturityArea = null;
+            }
+
+            if (_typeof(result) === 'object' && 'startTimestamp' in result) {
+              resultObject.startTimestamp = function () {
+                if (result.startTimestamp === null) {
+                  return null;
+                }
+
+                if (typeof result.startTimestamp !== 'string') {
+                  return new Date(String(result.startTimestamp));
+                }
+
+                return new Date(result.startTimestamp);
+              }();
+            } else {
+              resultObject.startTimestamp = null;
+            }
+
+            if (_typeof(result) === 'object' && 'finishTimestamp' in result) {
+              resultObject.finishTimestamp = function () {
+                if (result.finishTimestamp === null) {
+                  return null;
+                }
+
+                if (typeof result.finishTimestamp !== 'string') {
+                  return new Date(String(result.finishTimestamp));
+                }
+
+                return new Date(result.finishTimestamp);
+              }();
+            } else {
+              resultObject.finishTimestamp = null;
+            }
+
+            if (_typeof(result) === 'object' && 'variety' in result) {
+              resultObject.variety = function () {
+                var varietyObject = {};
+
+                if (_typeof(result.variety) === 'object' && 'id' in result.variety) {
+                  varietyObject.id = function () {
+                    if (typeof result.variety.id !== 'string') {
+                      return String(result.variety.id);
+                    }
+
+                    return result.variety.id;
+                  }();
+                } else {
+                  varietyObject.id = "";
+                }
+
+                if (_typeof(result.variety) === 'object' && 'code' in result.variety) {
+                  varietyObject.code = function () {
+                    if (typeof result.variety.code !== 'string') {
+                      return String(result.variety.code);
+                    }
+
+                    return result.variety.code;
+                  }();
+                } else {
+                  varietyObject.code = "";
+                }
+
+                if (_typeof(result.variety) === 'object' && 'name' in result.variety) {
+                  varietyObject.name = function () {
+                    if (typeof result.variety.name !== 'string') {
+                      return String(result.variety.name);
+                    }
+
+                    return result.variety.name;
+                  }();
+                } else {
+                  varietyObject.name = "";
+                }
+
+                if (_typeof(result.variety) === 'object' && 'description' in result.variety) {
+                  varietyObject.description = function () {
+                    if (typeof result.variety.description !== 'string') {
+                      return String(result.variety.description);
+                    }
+
+                    return result.variety.description;
+                  }();
+                } else {
+                  varietyObject.description = "";
+                }
+
+                if (_typeof(result.variety) === 'object' && 'image' in result.variety) {
+                  varietyObject.image = function () {
+                    if (typeof result.variety.image !== 'string') {
+                      return String(result.variety.image);
+                    }
+
+                    return result.variety.image;
+                  }();
+                } else {
+                  varietyObject.image = "";
+                }
+
+                return varietyObject;
+              }();
+            } else {
+              resultObject.variety = function () {
+                var varietyDefaultValue = {};
+                varietyDefaultValue.id = "";
+                varietyDefaultValue.code = "";
+                varietyDefaultValue.name = "";
+                varietyDefaultValue.description = "";
+                varietyDefaultValue.image = "";
+                return varietyDefaultValue;
+              }();
+            }
+
+            if (_typeof(result) === 'object' && 'growingMethod' in result) {
+              resultObject.growingMethod = function () {
+                var growingMethodObject = {};
+
+                if (_typeof(result.growingMethod) === 'object' && 'id' in result.growingMethod) {
+                  growingMethodObject.id = function () {
+                    if (typeof result.growingMethod.id !== 'string') {
+                      return String(result.growingMethod.id);
+                    }
+
+                    return result.growingMethod.id;
+                  }();
+                } else {
+                  growingMethodObject.id = "";
+                }
+
+                if (_typeof(result.growingMethod) === 'object' && 'code' in result.growingMethod) {
+                  growingMethodObject.code = function () {
+                    if (typeof result.growingMethod.code !== 'string') {
+                      return String(result.growingMethod.code);
+                    }
+
+                    return result.growingMethod.code;
+                  }();
+                } else {
+                  growingMethodObject.code = "";
+                }
+
+                if (_typeof(result.growingMethod) === 'object' && 'name' in result.growingMethod) {
+                  growingMethodObject.name = function () {
+                    if (typeof result.growingMethod.name !== 'string') {
+                      return String(result.growingMethod.name);
+                    }
+
+                    return result.growingMethod.name;
+                  }();
+                } else {
+                  growingMethodObject.name = "";
+                }
+
+                if (_typeof(result.growingMethod) === 'object' && 'description' in result.growingMethod) {
+                  growingMethodObject.description = function () {
+                    if (typeof result.growingMethod.description !== 'string') {
+                      return String(result.growingMethod.description);
+                    }
+
+                    return result.growingMethod.description;
+                  }();
+                } else {
+                  growingMethodObject.description = "";
+                }
+
+                return growingMethodObject;
+              }();
+            } else {
+              resultObject.growingMethod = function () {
+                var growingMethodDefaultValue = {};
+                growingMethodDefaultValue.id = "";
+                growingMethodDefaultValue.code = "";
+                growingMethodDefaultValue.name = "";
+                growingMethodDefaultValue.description = "";
+                return growingMethodDefaultValue;
+              }();
+            }
+
+            if (_typeof(result) === 'object' && 'packingLineId' in result) {
+              resultObject.packingLineId = function () {
+                if (typeof result.packingLineId !== 'string') {
+                  return String(result.packingLineId);
+                }
+
+                return result.packingLineId;
+              }();
+            } else {
+              resultObject.packingLineId = "";
+            }
+
+            if (_typeof(result) === 'object' && 'packingLineName' in result) {
+              resultObject.packingLineName = function () {
+                if (typeof result.packingLineName !== 'string') {
+                  return String(result.packingLineName);
+                }
+
+                return result.packingLineName;
+              }();
+            } else {
+              resultObject.packingLineName = "";
+            }
+
+            if (_typeof(result) === 'object' && 'status' in result) {
+              resultObject.status = function () {
+                if (typeof result.status !== 'string') {
+                  return String(result.status);
+                }
+
+                return result.status;
+              }();
+            } else {
+              resultObject.status = "";
+            }
+
+            if (_typeof(result) === 'object' && 'allocatedBins' in result) {
+              resultObject.allocatedBins = function () {
+                if (typeof result.allocatedBins !== 'number') {
+                  return Number.isInteger(Number(result.allocatedBins)) ? Number(result.allocatedBins) : Math.floor(Number(result.allocatedBins));
+                }
+
+                return Number.isInteger(result.allocatedBins) ? result.allocatedBins : Math.floor(result.allocatedBins);
+              }();
+            } else {
+              resultObject.allocatedBins = 0;
+            }
+
+            if (_typeof(result) === 'object' && 'tippedBins' in result) {
+              resultObject.tippedBins = function () {
+                if (typeof result.tippedBins !== 'number') {
+                  return Number.isInteger(Number(result.tippedBins)) ? Number(result.tippedBins) : Math.floor(Number(result.tippedBins));
+                }
+
+                return Number.isInteger(result.tippedBins) ? result.tippedBins : Math.floor(result.tippedBins);
+              }();
+            } else {
+              resultObject.tippedBins = 0;
+            }
+
+            if (_typeof(result) === 'object' && 'class1FruitSizeProfile' in result) {
+              resultObject.class1FruitSizeProfile = function () {
+                if (Array.isArray(result.class1FruitSizeProfile) !== true) {
+                  return [];
+                }
+
+                return result.class1FruitSizeProfile.map(function (class1FruitSizeProfileItem) {
+                  return function () {
+                    var class1FruitSizeProfileItemObject = {};
+
+                    if (_typeof(class1FruitSizeProfileItem) === 'object' && 'fruitSize' in class1FruitSizeProfileItem) {
+                      class1FruitSizeProfileItemObject.fruitSize = function () {
+                        if (typeof class1FruitSizeProfileItem.fruitSize !== 'string') {
+                          return String(class1FruitSizeProfileItem.fruitSize);
+                        }
+
+                        return class1FruitSizeProfileItem.fruitSize;
+                      }();
+                    } else {
+                      class1FruitSizeProfileItemObject.fruitSize = "";
+                    }
+
+                    if (_typeof(class1FruitSizeProfileItem) === 'object' && 'fruitCount' in class1FruitSizeProfileItem) {
+                      class1FruitSizeProfileItemObject.fruitCount = function () {
+                        if (typeof class1FruitSizeProfileItem.fruitCount !== 'number') {
+                          return Number.isInteger(Number(class1FruitSizeProfileItem.fruitCount)) ? Number(class1FruitSizeProfileItem.fruitCount) : Math.floor(Number(class1FruitSizeProfileItem.fruitCount));
+                        }
+
+                        return Number.isInteger(class1FruitSizeProfileItem.fruitCount) ? class1FruitSizeProfileItem.fruitCount : Math.floor(class1FruitSizeProfileItem.fruitCount);
+                      }();
+                    } else {
+                      class1FruitSizeProfileItemObject.fruitCount = 0;
+                    }
+
+                    if (_typeof(class1FruitSizeProfileItem) === 'object' && 'percentage' in class1FruitSizeProfileItem) {
+                      class1FruitSizeProfileItemObject.percentage = function () {
+                        if (typeof class1FruitSizeProfileItem.percentage !== 'number') {
+                          return Number(class1FruitSizeProfileItem.percentage);
+                        }
+
+                        return class1FruitSizeProfileItem.percentage;
+                      }();
+                    } else {
+                      class1FruitSizeProfileItemObject.percentage = 0;
+                    }
+
+                    return class1FruitSizeProfileItemObject;
+                  }();
+                });
+              }();
+            } else {
+              resultObject.class1FruitSizeProfile = [];
+            }
+
+            if (_typeof(result) === 'object' && 'class1TotalTrays' in result) {
+              resultObject.class1TotalTrays = function () {
+                if (typeof result.class1TotalTrays !== 'number') {
+                  return Number(result.class1TotalTrays);
+                }
+
+                return result.class1TotalTrays;
+              }();
+            } else {
+              resultObject.class1TotalTrays = 0;
+            }
+
+            if (_typeof(result) === 'object' && 'class1TraysPerBin' in result) {
+              resultObject.class1TraysPerBin = function () {
+                if (typeof result.class1TraysPerBin !== 'number') {
+                  return Number(result.class1TraysPerBin);
+                }
+
+                return result.class1TraysPerBin;
+              }();
+            } else {
+              resultObject.class1TraysPerBin = 0;
+            }
+
+            if (_typeof(result) === 'object' && 'class1AverageFruitSize' in result) {
+              resultObject.class1AverageFruitSize = function () {
+                if (typeof result.class1AverageFruitSize !== 'number') {
+                  return Number(result.class1AverageFruitSize);
+                }
+
+                return result.class1AverageFruitSize;
+              }();
+            } else {
+              resultObject.class1AverageFruitSize = 0;
+            }
+
+            if (_typeof(result) === 'object' && 'class2TotalTrays' in result) {
+              resultObject.class2TotalTrays = function () {
+                if (typeof result.class2TotalTrays !== 'number') {
+                  return Number(result.class2TotalTrays);
+                }
+
+                return result.class2TotalTrays;
+              }();
+            } else {
+              resultObject.class2TotalTrays = 0;
+            }
+
+            if (_typeof(result) === 'object' && 'classTypes' in result) {
+              resultObject.classTypes = function () {
+                if (Array.isArray(result.classTypes) !== true) {
+                  return [];
+                }
+
+                return result.classTypes.map(function (classTypesItem) {
+                  return function () {
+                    var classTypesItemObject = {};
+
+                    if (_typeof(classTypesItem) === 'object' && 'classType' in classTypesItem) {
+                      classTypesItemObject.classType = function () {
+                        if (typeof classTypesItem.classType !== 'string') {
+                          return String(classTypesItem.classType);
+                        }
+
+                        return classTypesItem.classType;
+                      }();
+                    } else {
+                      classTypesItemObject.classType = "";
+                    }
+
+                    if (_typeof(classTypesItem) === 'object' && 'name' in classTypesItem) {
+                      classTypesItemObject.name = function () {
+                        if (typeof classTypesItem.name !== 'string') {
+                          return String(classTypesItem.name);
+                        }
+
+                        return classTypesItem.name;
+                      }();
+                    } else {
+                      classTypesItemObject.name = "";
+                    }
+
+                    if (_typeof(classTypesItem) === 'object' && 'percentage' in classTypesItem) {
+                      classTypesItemObject.percentage = function () {
+                        if (typeof classTypesItem.percentage !== 'number') {
+                          return Number(classTypesItem.percentage);
+                        }
+
+                        return classTypesItem.percentage;
+                      }();
+                    } else {
+                      classTypesItemObject.percentage = 0;
+                    }
+
+                    return classTypesItemObject;
+                  }();
+                });
+              }();
+            } else {
+              resultObject.classTypes = [];
+            }
+
+            return resultObject;
+          }();
+
+          resolve(resolveValue);
+        }).catch(function (error) {
+          return reject(error);
+        });
+      });
+    }
     /**
      * List all Packruns [GET /packhouse/sites/{siteId}/packruns]
      * 
@@ -2153,6 +2649,54 @@ var _default = PackrunController;
  * @memberof Controllers.Packhouse.Site
  */
 
+/**
+ * A **FruitSizeProfileItem** Type
+ * 
+ * @typedef {Object} PackrunController.FruitSizeProfileItem
+ * @property {string} fruitSize The Fruit Size
+ * @property {number} fruitCount The Fruit Count
+ * @property {number} percentage The Percentage of Total Fruit for this Fruit Size
+ * @memberof Controllers.Packhouse.Site
+ */
+
+/**
+ * A **ClassTypePercentageItem** Type
+ * 
+ * @typedef {Object} PackrunController.ClassTypePercentageItem
+ * @property {string} classType The Class Type
+ * @property {string} name The Class Type Name
+ * @property {number} percentage The Percentage of Total Weight for this Class Type
+ * @memberof Controllers.Packhouse.Site
+ */
+
+/**
+ * A **PackrunLatestSummaryData** Type
+ * 
+ * @typedef {Object} PackrunController.PackrunLatestSummaryData
+ * @property {string} id The Packrun ID
+ * @property {string} name The Packrun Name
+ * @property {Date} createdTimestamp When the Packrun was Created
+ * @property {string} growerName The Grower Name
+ * @property {string} growerCode The Grower Code
+ * @property {?string} maturityArea The Maturity Area
+ * @property {?Date} startTimestamp When the Packrun was Started
+ * @property {?Date} finishTimestamp When the Packrun was Finished
+ * @property {PackrunController.VarietyItem} variety The Variety for the Packrun
+ * @property {PackrunController.GrowingMethodItem} growingMethod The Growing Method for the Packrun
+ * @property {string} packingLineId The Packing Line ID
+ * @property {string} packingLineName The Packing Line Name
+ * @property {string} status The Status of this Packrun
+ * @property {number} allocatedBins The Number of Bins Allocated for the Packrun
+ * @property {number} tippedBins The Number of Bins Tipped for the Packrun
+ * @property {Array<PackrunController.FruitSizeProfileItem>} class1FruitSizeProfile An Array of Class 1 Fruit Profiles by Size for the Packrun
+ * @property {number} class1TotalTrays The Total Class 1 Trays for this Packrun
+ * @property {number} class1TraysPerBin The Number of Class 1 Trays per Bin for this Packrun
+ * @property {number} class1AverageFruitSize The Average Class 1 Fruit Size for this Packrun
+ * @property {number} class2TotalTrays The Total Class 2 Trays for this Packrun
+ * @property {Array<PackrunController.ClassTypePercentageItem>} classTypes An Array of Class Types and their Percentages for this Packrun
+ * @memberof Controllers.Packhouse.Site
+ */
+
 /**
  * A **TimeBatch** Type
  * 

package/lib/Controllers/Packhouse/Site/RejectBinScaleController.js

@@ -267,7 +267,7 @@ var _default = RejectBinScaleController;
  * @typedef {Object} RejectBinScaleController.FreshPackBinScaleIntegration
  * @property {Object} points The Points used by this FreshPack Bin Scale Integration
  * @property {boolean} enabled Whether this FreshPack Bin Scale Integration is Enabled
- * @property {number} materialGroupId The FreshPack Material Group ID to be used for Multi-Grower Bins from this Reject Bin Scale
+ * @property {?number} materialGroupId The FreshPack Material Group ID to be used for Multi-Grower Bins from this Reject Bin Scale
  * @property {number} binTypeId The FreshPack Bin Type ID to be used for Multi-Grower Bins from this Reject Bin Scale
  * @property {?number} printerGroupId The FreshPack Printer Group ID to be used when Printing Multi-Grower Bin Cards for this Reject Bin Scale
  * @property {boolean} binCardPrintingEnabled Whether Bin Card Printing is Enabled