@ricado/api-client 2.1.0 → 2.1.1

package/src/Models/Packhouse/Site/RejectBinScaleModel.js

@@ -92,11 +92,99 @@ class RejectBinScaleModel extends BaseModel
         /**
          * The Auto Packrun Change Configuration for this Reject Bin Scale
          * 
-         * @type {?number}
+         * @type {?{delay: ?number}}
          * @public
          */
         this.autoPackrunChange = undefined;
         
+        /**
+         * Whether this Reject Bin Scale supports Live Weighing
+         * 
+         * @type {?boolean}
+         * @public
+         */
+        this.supportsLiveWeighing = undefined;
+        
+        /**
+         * The Minimum Weight Change Required to Automatically Start Live Weighing
+         * 
+         * @type {?number}
+         * @public
+         */
+        this.autoWeighingStartThreshold = undefined;
+        
+        /**
+         * The Delay in Milliseconds before Auto Live Weighing would Start
+         * 
+         * @type {?number}
+         * @public
+         */
+        this.autoWeighingStartDelay = undefined;
+        
+        /**
+         * The Minimum Weight Change Required to Automatically Finish Live Weighing
+         * 
+         * @type {?number}
+         * @public
+         */
+        this.autoWeighingFinishThreshold = undefined;
+        
+        /**
+         * The Delay in Milliseconds before Auto Live Weighing would Finish
+         * 
+         * @type {?number}
+         * @public
+         */
+        this.autoWeighingFinishDelay = undefined;
+        
+        /**
+         * The Maximum Duration in Milliseconds before a Manual Intervention would end
+         * 
+         * @type {?number}
+         * @public
+         */
+        this.manualInterventionMaximumDuration = undefined;
+        
+        /**
+         * The Maximum Weight Increase allowed within a single Live Weighing Update Interval
+         * 
+         * @type {?number}
+         * @public
+         */
+        this.liveWeighingIncreaseTolerance = undefined;
+        
+        /**
+         * The Maximum Weight Decrease allowed within a single Live Weighing Update Interval
+         * 
+         * @type {?number}
+         * @public
+         */
+        this.liveWeighingDecreaseTolerance = undefined;
+        
+        /**
+         * The Interval in Milliseconds between Live Weighing Updates
+         * 
+         * @type {?number}
+         * @public
+         */
+        this.liveWeighingUpdateInterval = undefined;
+        
+        /**
+         * Whether the Loadcell Stable Status is used to ignore Changes during Live Weighing
+         * 
+         * @type {?boolean}
+         * @public
+         */
+        this.liveWeighingUsesStableStatus = undefined;
+        
+        /**
+         * The Maximum Weight Change allowed while Live Weighing before an Incorrect Operation is Logged
+         * 
+         * @type {?number}
+         * @public
+         */
+        this.incorrectOperationTolerance = undefined;
+        
         /**
          * The FreshPack Integration Configuration for this Reject Bin Scale
          * 
@@ -287,12 +375,217 @@ class RejectBinScaleModel extends BaseModel
                     return null;
                 }
         
-                if(typeof jsonObject['autoPackrunChange'] !== 'number')
+                let autoPackrunChangeObject = {};
+                
+                if(typeof jsonObject['autoPackrunChange'] === 'object' && 'delay' in jsonObject['autoPackrunChange'])
+                {
+                    autoPackrunChangeObject.delay = (function(){
+                        if(jsonObject['autoPackrunChange'].delay === null)
+                        {
+                            return null;
+                        }
+        
+                        if(typeof jsonObject['autoPackrunChange'].delay !== 'number')
+                        {
+                            return Number.isInteger(Number(jsonObject['autoPackrunChange'].delay)) ? Number(jsonObject['autoPackrunChange'].delay) : Math.floor(Number(jsonObject['autoPackrunChange'].delay));
+                        }
+        
+                        return Number.isInteger(jsonObject['autoPackrunChange'].delay) ? jsonObject['autoPackrunChange'].delay : Math.floor(jsonObject['autoPackrunChange'].delay);
+                    }());
+                }
+                else
+                {
+                    autoPackrunChangeObject.delay = null;
+                }
+        
+                return autoPackrunChangeObject;
+            }());
+        }
+        
+        if('supportsLiveWeighing' in jsonObject)
+        {
+            model.supportsLiveWeighing = (function(){
+                if(jsonObject['supportsLiveWeighing'] === null)
+                {
+                    return null;
+                }
+        
+                if(typeof jsonObject['supportsLiveWeighing'] !== 'boolean')
+                {
+                    return Boolean(jsonObject['supportsLiveWeighing']);
+                }
+        
+                return jsonObject['supportsLiveWeighing'];
+            }());
+        }
+        
+        if('autoWeighingStartThreshold' in jsonObject)
+        {
+            model.autoWeighingStartThreshold = (function(){
+                if(jsonObject['autoWeighingStartThreshold'] === null)
+                {
+                    return null;
+                }
+        
+                if(typeof jsonObject['autoWeighingStartThreshold'] !== 'number')
+                {
+                    return Number(jsonObject['autoWeighingStartThreshold']);
+                }
+        
+                return jsonObject['autoWeighingStartThreshold'];
+            }());
+        }
+        
+        if('autoWeighingStartDelay' in jsonObject)
+        {
+            model.autoWeighingStartDelay = (function(){
+                if(jsonObject['autoWeighingStartDelay'] === null)
+                {
+                    return null;
+                }
+        
+                if(typeof jsonObject['autoWeighingStartDelay'] !== 'number')
+                {
+                    return Number.isInteger(Number(jsonObject['autoWeighingStartDelay'])) ? Number(jsonObject['autoWeighingStartDelay']) : Math.floor(Number(jsonObject['autoWeighingStartDelay']));
+                }
+        
+                return Number.isInteger(jsonObject['autoWeighingStartDelay']) ? jsonObject['autoWeighingStartDelay'] : Math.floor(jsonObject['autoWeighingStartDelay']);
+            }());
+        }
+        
+        if('autoWeighingFinishThreshold' in jsonObject)
+        {
+            model.autoWeighingFinishThreshold = (function(){
+                if(jsonObject['autoWeighingFinishThreshold'] === null)
+                {
+                    return null;
+                }
+        
+                if(typeof jsonObject['autoWeighingFinishThreshold'] !== 'number')
+                {
+                    return Number(jsonObject['autoWeighingFinishThreshold']);
+                }
+        
+                return jsonObject['autoWeighingFinishThreshold'];
+            }());
+        }
+        
+        if('autoWeighingFinishDelay' in jsonObject)
+        {
+            model.autoWeighingFinishDelay = (function(){
+                if(jsonObject['autoWeighingFinishDelay'] === null)
+                {
+                    return null;
+                }
+        
+                if(typeof jsonObject['autoWeighingFinishDelay'] !== 'number')
+                {
+                    return Number.isInteger(Number(jsonObject['autoWeighingFinishDelay'])) ? Number(jsonObject['autoWeighingFinishDelay']) : Math.floor(Number(jsonObject['autoWeighingFinishDelay']));
+                }
+        
+                return Number.isInteger(jsonObject['autoWeighingFinishDelay']) ? jsonObject['autoWeighingFinishDelay'] : Math.floor(jsonObject['autoWeighingFinishDelay']);
+            }());
+        }
+        
+        if('manualInterventionMaximumDuration' in jsonObject)
+        {
+            model.manualInterventionMaximumDuration = (function(){
+                if(jsonObject['manualInterventionMaximumDuration'] === null)
+                {
+                    return null;
+                }
+        
+                if(typeof jsonObject['manualInterventionMaximumDuration'] !== 'number')
+                {
+                    return Number.isInteger(Number(jsonObject['manualInterventionMaximumDuration'])) ? Number(jsonObject['manualInterventionMaximumDuration']) : Math.floor(Number(jsonObject['manualInterventionMaximumDuration']));
+                }
+        
+                return Number.isInteger(jsonObject['manualInterventionMaximumDuration']) ? jsonObject['manualInterventionMaximumDuration'] : Math.floor(jsonObject['manualInterventionMaximumDuration']);
+            }());
+        }
+        
+        if('liveWeighingIncreaseTolerance' in jsonObject)
+        {
+            model.liveWeighingIncreaseTolerance = (function(){
+                if(jsonObject['liveWeighingIncreaseTolerance'] === null)
+                {
+                    return null;
+                }
+        
+                if(typeof jsonObject['liveWeighingIncreaseTolerance'] !== 'number')
+                {
+                    return Number(jsonObject['liveWeighingIncreaseTolerance']);
+                }
+        
+                return jsonObject['liveWeighingIncreaseTolerance'];
+            }());
+        }
+        
+        if('liveWeighingDecreaseTolerance' in jsonObject)
+        {
+            model.liveWeighingDecreaseTolerance = (function(){
+                if(jsonObject['liveWeighingDecreaseTolerance'] === null)
+                {
+                    return null;
+                }
+        
+                if(typeof jsonObject['liveWeighingDecreaseTolerance'] !== 'number')
+                {
+                    return Number(jsonObject['liveWeighingDecreaseTolerance']);
+                }
+        
+                return jsonObject['liveWeighingDecreaseTolerance'];
+            }());
+        }
+        
+        if('liveWeighingUpdateInterval' in jsonObject)
+        {
+            model.liveWeighingUpdateInterval = (function(){
+                if(jsonObject['liveWeighingUpdateInterval'] === null)
+                {
+                    return null;
+                }
+        
+                if(typeof jsonObject['liveWeighingUpdateInterval'] !== 'number')
+                {
+                    return Number.isInteger(Number(jsonObject['liveWeighingUpdateInterval'])) ? Number(jsonObject['liveWeighingUpdateInterval']) : Math.floor(Number(jsonObject['liveWeighingUpdateInterval']));
+                }
+        
+                return Number.isInteger(jsonObject['liveWeighingUpdateInterval']) ? jsonObject['liveWeighingUpdateInterval'] : Math.floor(jsonObject['liveWeighingUpdateInterval']);
+            }());
+        }
+        
+        if('liveWeighingUsesStableStatus' in jsonObject)
+        {
+            model.liveWeighingUsesStableStatus = (function(){
+                if(jsonObject['liveWeighingUsesStableStatus'] === null)
+                {
+                    return null;
+                }
+        
+                if(typeof jsonObject['liveWeighingUsesStableStatus'] !== 'boolean')
+                {
+                    return Boolean(jsonObject['liveWeighingUsesStableStatus']);
+                }
+        
+                return jsonObject['liveWeighingUsesStableStatus'];
+            }());
+        }
+        
+        if('incorrectOperationTolerance' in jsonObject)
+        {
+            model.incorrectOperationTolerance = (function(){
+                if(jsonObject['incorrectOperationTolerance'] === null)
+                {
+                    return null;
+                }
+        
+                if(typeof jsonObject['incorrectOperationTolerance'] !== 'number')
                 {
-                    return Number.isInteger(Number(jsonObject['autoPackrunChange'])) ? Number(jsonObject['autoPackrunChange']) : Math.floor(Number(jsonObject['autoPackrunChange']));
+                    return Number(jsonObject['incorrectOperationTolerance']);
                 }
         
-                return Number.isInteger(jsonObject['autoPackrunChange']) ? jsonObject['autoPackrunChange'] : Math.floor(jsonObject['autoPackrunChange']);
+                return jsonObject['incorrectOperationTolerance'];
             }());
         }
         

package/src/Models/Packhouse/Site/SoftSortBeltModel.js

@@ -0,0 +1,215 @@
+/**
+ * File Auto-Generated by the RICADO Gen 4 PHP API Project
+ * 
+ * Do Not Edit this File Manually!
+ */
+
+import BaseModel from '../../../Models/BaseModel';
+
+/**
+ * Model Class for a Soft Sort Belt
+ * 
+ * @class
+ * @hideconstructor
+ * @extends BaseModel
+ */
+class SoftSortBeltModel extends BaseModel
+{
+    /**
+     * SoftSortBeltModel Constructor
+     * 
+     * @protected
+     * @param {number} siteId The Site ID associated with this Soft Sort Belt
+     */
+    constructor(siteId)
+    {
+        super();
+        
+        /**
+         * The Soft Sort Belt ID
+         * 
+         * @type {string}
+         * @public
+         */
+        this.id = undefined;
+        
+        /**
+         * The RTU this Soft Sort Belt belongs to
+         * 
+         * @type {?number}
+         * @public
+         */
+        this.rtuId = undefined;
+        
+        /**
+         * The Name of this Soft Sort Belt
+         * 
+         * @type {string}
+         * @public
+         */
+        this.name = undefined;
+        
+        /**
+         * The Points used by this Soft Sort Belt
+         * 
+         * @type {Object}
+         * @public
+         */
+        this.points = undefined;
+        
+        /**
+         * The Packing Line that owns this Soft Sort Belt
+         * 
+         * @type {string}
+         * @public
+         */
+        this.packingLineId = undefined;
+        
+        /**
+         * Whether the Soft Sort Belt has been deleted
+         * 
+         * @type {boolean}
+         * @public
+         */
+        this.deleted = undefined;
+        
+        /**
+         * When the Soft Sort Belt was last updated
+         * 
+         * @type {Date}
+         * @public
+         */
+        this.updateTimestamp = undefined;
+        
+        /**
+         * The Site ID associated with this Soft Sort Belt
+         * 
+         * @type {number}
+         * @public
+         */
+        this.siteId = siteId;
+    }
+
+    /**
+     * Create a new **SoftSortBeltModel** from a JSON Object or JSON String
+     * 
+     * @static
+     * @public
+     * @param {Object<string, any>|string} json A JSON Object or JSON String
+     * @param {number} siteId The Site ID associated with this Soft Sort Belt
+     * @return {SoftSortBeltModel}
+     */
+    static fromJSON(json, siteId)
+    {
+        let model = new SoftSortBeltModel(siteId);
+        
+        /**
+         * The JSON Object
+         * 
+         * @type {Object<string, any>}
+         */
+        let jsonObject = {};
+        
+        if(typeof json === 'string')
+        {
+            jsonObject = JSON.parse(json);
+        }
+        else if(typeof json === 'object')
+        {
+            jsonObject = json;
+        }
+        
+        if('id' in jsonObject)
+        {
+            model.id = (function(){
+                if(typeof jsonObject['id'] !== 'string')
+                {
+                    return String(jsonObject['id']);
+                }
+        
+                return jsonObject['id'];
+            }());
+        }
+        
+        if('rtuId' in jsonObject)
+        {
+            model.rtuId = (function(){
+                if(jsonObject['rtuId'] === null)
+                {
+                    return null;
+                }
+        
+                if(typeof jsonObject['rtuId'] !== 'number')
+                {
+                    return Number.isInteger(Number(jsonObject['rtuId'])) ? Number(jsonObject['rtuId']) : Math.floor(Number(jsonObject['rtuId']));
+                }
+        
+                return Number.isInteger(jsonObject['rtuId']) ? jsonObject['rtuId'] : Math.floor(jsonObject['rtuId']);
+            }());
+        }
+        
+        if('name' in jsonObject)
+        {
+            model.name = (function(){
+                if(typeof jsonObject['name'] !== 'string')
+                {
+                    return String(jsonObject['name']);
+                }
+        
+                return jsonObject['name'];
+            }());
+        }
+        
+        if('points' in jsonObject)
+        {
+            model.points = (function(){
+                if(typeof jsonObject['points'] !== 'object')
+                {
+                    return Object(jsonObject['points']);
+                }
+        
+                return jsonObject['points'];
+            }());
+        }
+        
+        if('packingLineId' in jsonObject)
+        {
+            model.packingLineId = (function(){
+                if(typeof jsonObject['packingLineId'] !== 'string')
+                {
+                    return String(jsonObject['packingLineId']);
+                }
+        
+                return jsonObject['packingLineId'];
+            }());
+        }
+        
+        if('deleted' in jsonObject)
+        {
+            model.deleted = (function(){
+                if(typeof jsonObject['deleted'] !== 'boolean')
+                {
+                    return Boolean(jsonObject['deleted']);
+                }
+        
+                return jsonObject['deleted'];
+            }());
+        }
+        
+        if('updateTimestamp' in jsonObject)
+        {
+            model.updateTimestamp = (function(){
+                if(typeof jsonObject['updateTimestamp'] !== 'string')
+                {
+                    return new Date(String(jsonObject['updateTimestamp']));
+                }
+        
+                return new Date(jsonObject['updateTimestamp']);
+            }());
+        }
+        
+        return model;
+    }
+}
+
+export default SoftSortBeltModel;

package/src/Models/Packhouse/Site/index.js

@@ -26,6 +26,7 @@ import RejectBinWeightModel from './RejectBinWeightModel';
 import ShiftFocusMeetingModel from './ShiftFocusMeetingModel';
 import ShiftHourlyEntryModel from './ShiftHourlyEntryModel';
 import ShiftModel from './ShiftModel';
+import SoftSortBeltModel from './SoftSortBeltModel';
 import VarietyModel from './VarietyModel';
 
 const Site = {
@@ -48,6 +49,7 @@ const Site = {
     ShiftFocusMeetingModel,
     ShiftHourlyEntryModel,
     ShiftModel,
+    SoftSortBeltModel,
     VarietyModel,
 };
 

package/src/PackageVersion.js

@@ -1,2 +1,2 @@
 // generated by genversion
-export const version = '2.1.0';
+export const version = '2.1.1';