@ricado/api-client 2.3.17 → 2.3.19

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

@@ -76,7 +76,7 @@ class RejectBinWeightModel extends BaseModel
         /**
          * The Source Weights that make up the Net Weight
          * 
-         * @type {Object[]}
+         * @type {Array<{type: string, sortingTableId: string, sortingTableName: ?string, weights: Array<{classType: string, weight: number, fruitCount: ?number}>}|{type: string, beltName: ?string, weights: Array<{classType: string, weight: number, fruitCount: ?number}>}|{type: string, sizerId: string, sizerName: ?string, outletNumber: number, outletName: ?string, weights: Array<{classType: string, weight: number, fruitCount: ?number}>}|{type: string, mixedNames: string[], weights: Array<{classType: string, weight: number, fruitCount: ?number}>}>}
          * @public
          */
         this.sources = [];
@@ -84,7 +84,7 @@ class RejectBinWeightModel extends BaseModel
         /**
          * The Multi-Grower Bin Weights that will be submitted to FreshPack
          * 
-         * @type {Object[]}
+         * @type {Array<{classType: string, weight: number, weightApi: ?{requestCount: number, requestTimestamp: ?Date, responseCode: ?number, responseMessage: ?string, completed: boolean}}>}
          * @public
          */
         this.freshPackMultiGrowerBinWeights = [];
@@ -230,11 +230,6 @@ class RejectBinWeightModel extends BaseModel
         
                 return jsonObject['sources'].map((sourcesItem) => {
                     return (function(){
-                        if(typeof sourcesItem !== 'object')
-                        {
-                            return Object(sourcesItem);
-                        }
-        
                         return sourcesItem;
                     }());
                 });
@@ -251,12 +246,154 @@ class RejectBinWeightModel extends BaseModel
         
                 return jsonObject['freshPackMultiGrowerBinWeights'].map((freshPackMultiGrowerBinWeightsItem) => {
                     return (function(){
-                        if(typeof freshPackMultiGrowerBinWeightsItem !== 'object')
+                        let freshPackMultiGrowerBinWeightsItemObject = {};
+                        
+                        if(typeof freshPackMultiGrowerBinWeightsItem === 'object' && 'classType' in freshPackMultiGrowerBinWeightsItem)
+                        {
+                            freshPackMultiGrowerBinWeightsItemObject.classType = (function(){
+                                if(typeof freshPackMultiGrowerBinWeightsItem.classType !== 'string')
+                                {
+                                    return String(freshPackMultiGrowerBinWeightsItem.classType);
+                                }
+        
+                                return freshPackMultiGrowerBinWeightsItem.classType;
+                            }());
+                        }
+                        else
+                        {
+                            freshPackMultiGrowerBinWeightsItemObject.classType = "";
+                        }
+                        
+                        if(typeof freshPackMultiGrowerBinWeightsItem === 'object' && 'weight' in freshPackMultiGrowerBinWeightsItem)
+                        {
+                            freshPackMultiGrowerBinWeightsItemObject.weight = (function(){
+                                if(typeof freshPackMultiGrowerBinWeightsItem.weight !== 'number')
+                                {
+                                    return Number(freshPackMultiGrowerBinWeightsItem.weight);
+                                }
+        
+                                return freshPackMultiGrowerBinWeightsItem.weight;
+                            }());
+                        }
+                        else
+                        {
+                            freshPackMultiGrowerBinWeightsItemObject.weight = 0;
+                        }
+                        
+                        if(typeof freshPackMultiGrowerBinWeightsItem === 'object' && 'weightApi' in freshPackMultiGrowerBinWeightsItem)
+                        {
+                            freshPackMultiGrowerBinWeightsItemObject.weightApi = (function(){
+                                if(freshPackMultiGrowerBinWeightsItem.weightApi === null)
+                                {
+                                    return null;
+                                }
+        
+                                let weightApiObject = {};
+                                
+                                if(typeof freshPackMultiGrowerBinWeightsItem.weightApi === 'object' && 'requestCount' in freshPackMultiGrowerBinWeightsItem.weightApi)
+                                {
+                                    weightApiObject.requestCount = (function(){
+                                        if(typeof freshPackMultiGrowerBinWeightsItem.weightApi.requestCount !== 'number')
+                                        {
+                                            return Number.isInteger(Number(freshPackMultiGrowerBinWeightsItem.weightApi.requestCount)) ? Number(freshPackMultiGrowerBinWeightsItem.weightApi.requestCount) : Math.floor(Number(freshPackMultiGrowerBinWeightsItem.weightApi.requestCount));
+                                        }
+        
+                                        return Number.isInteger(freshPackMultiGrowerBinWeightsItem.weightApi.requestCount) ? freshPackMultiGrowerBinWeightsItem.weightApi.requestCount : Math.floor(freshPackMultiGrowerBinWeightsItem.weightApi.requestCount);
+                                    }());
+                                }
+                                else
+                                {
+                                    weightApiObject.requestCount = 0;
+                                }
+                                
+                                if(typeof freshPackMultiGrowerBinWeightsItem.weightApi === 'object' && 'requestTimestamp' in freshPackMultiGrowerBinWeightsItem.weightApi)
+                                {
+                                    weightApiObject.requestTimestamp = (function(){
+                                        if(freshPackMultiGrowerBinWeightsItem.weightApi.requestTimestamp === null)
+                                        {
+                                            return null;
+                                        }
+        
+                                        if(typeof freshPackMultiGrowerBinWeightsItem.weightApi.requestTimestamp !== 'string')
+                                        {
+                                            return new Date(String(freshPackMultiGrowerBinWeightsItem.weightApi.requestTimestamp));
+                                        }
+        
+                                        return new Date(freshPackMultiGrowerBinWeightsItem.weightApi.requestTimestamp);
+                                    }());
+                                }
+                                else
+                                {
+                                    weightApiObject.requestTimestamp = null;
+                                }
+                                
+                                if(typeof freshPackMultiGrowerBinWeightsItem.weightApi === 'object' && 'responseCode' in freshPackMultiGrowerBinWeightsItem.weightApi)
+                                {
+                                    weightApiObject.responseCode = (function(){
+                                        if(freshPackMultiGrowerBinWeightsItem.weightApi.responseCode === null)
+                                        {
+                                            return null;
+                                        }
+        
+                                        if(typeof freshPackMultiGrowerBinWeightsItem.weightApi.responseCode !== 'number')
+                                        {
+                                            return Number.isInteger(Number(freshPackMultiGrowerBinWeightsItem.weightApi.responseCode)) ? Number(freshPackMultiGrowerBinWeightsItem.weightApi.responseCode) : Math.floor(Number(freshPackMultiGrowerBinWeightsItem.weightApi.responseCode));
+                                        }
+        
+                                        return Number.isInteger(freshPackMultiGrowerBinWeightsItem.weightApi.responseCode) ? freshPackMultiGrowerBinWeightsItem.weightApi.responseCode : Math.floor(freshPackMultiGrowerBinWeightsItem.weightApi.responseCode);
+                                    }());
+                                }
+                                else
+                                {
+                                    weightApiObject.responseCode = null;
+                                }
+                                
+                                if(typeof freshPackMultiGrowerBinWeightsItem.weightApi === 'object' && 'responseMessage' in freshPackMultiGrowerBinWeightsItem.weightApi)
+                                {
+                                    weightApiObject.responseMessage = (function(){
+                                        if(freshPackMultiGrowerBinWeightsItem.weightApi.responseMessage === null)
+                                        {
+                                            return null;
+                                        }
+        
+                                        if(typeof freshPackMultiGrowerBinWeightsItem.weightApi.responseMessage !== 'string')
+                                        {
+                                            return String(freshPackMultiGrowerBinWeightsItem.weightApi.responseMessage);
+                                        }
+        
+                                        return freshPackMultiGrowerBinWeightsItem.weightApi.responseMessage;
+                                    }());
+                                }
+                                else
+                                {
+                                    weightApiObject.responseMessage = null;
+                                }
+                                
+                                if(typeof freshPackMultiGrowerBinWeightsItem.weightApi === 'object' && 'completed' in freshPackMultiGrowerBinWeightsItem.weightApi)
+                                {
+                                    weightApiObject.completed = (function(){
+                                        if(typeof freshPackMultiGrowerBinWeightsItem.weightApi.completed !== 'boolean')
+                                        {
+                                            return Boolean(freshPackMultiGrowerBinWeightsItem.weightApi.completed);
+                                        }
+        
+                                        return freshPackMultiGrowerBinWeightsItem.weightApi.completed;
+                                    }());
+                                }
+                                else
+                                {
+                                    weightApiObject.completed = false;
+                                }
+        
+                                return weightApiObject;
+                            }());
+                        }
+                        else
                         {
-                            return Object(freshPackMultiGrowerBinWeightsItem);
+                            freshPackMultiGrowerBinWeightsItemObject.weightApi = null;
                         }
         
-                        return freshPackMultiGrowerBinWeightsItem;
+                        return freshPackMultiGrowerBinWeightsItemObject;
                     }());
                 });
             }());

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

@@ -113,6 +113,22 @@ class ShiftHourlyEntryModel extends BaseModel
          */
         this.averageClass2ManningTarget = null;
         
+        /**
+         * An Array of Manning Teams and their Headcounts for this Hour. Only Applies when *manningUsesTeams* is *true*
+         * 
+         * @type {?Array<{id: string, name: string, headcount: number, group: string}>}
+         * @public
+         */
+        this.manningTeams = null;
+        
+        /**
+         * Whether Manning is tracked at the Team Level for this Hour
+         * 
+         * @type {?boolean}
+         * @public
+         */
+        this.manningUsesTeams = null;
+        
         /**
          * The Average Cost per Person working in all Areas for this Hour
          * 
@@ -596,6 +612,110 @@ class ShiftHourlyEntryModel extends BaseModel
             }());
         }
         
+        if('manningTeams' in jsonObject)
+        {
+            model.manningTeams = (function(){
+                if(jsonObject['manningTeams'] === null)
+                {
+                    return null;
+                }
+        
+                if(Array.isArray(jsonObject['manningTeams']) !== true)
+                {
+                    return [];
+                }
+        
+                return jsonObject['manningTeams'].map((manningTeamsItem) => {
+                    return (function(){
+                        let manningTeamsItemObject = {};
+                        
+                        if(typeof manningTeamsItem === 'object' && 'id' in manningTeamsItem)
+                        {
+                            manningTeamsItemObject.id = (function(){
+                                if(typeof manningTeamsItem.id !== 'string')
+                                {
+                                    return String(manningTeamsItem.id);
+                                }
+        
+                                return manningTeamsItem.id;
+                            }());
+                        }
+                        else
+                        {
+                            manningTeamsItemObject.id = "";
+                        }
+                        
+                        if(typeof manningTeamsItem === 'object' && 'name' in manningTeamsItem)
+                        {
+                            manningTeamsItemObject.name = (function(){
+                                if(typeof manningTeamsItem.name !== 'string')
+                                {
+                                    return String(manningTeamsItem.name);
+                                }
+        
+                                return manningTeamsItem.name;
+                            }());
+                        }
+                        else
+                        {
+                            manningTeamsItemObject.name = "";
+                        }
+                        
+                        if(typeof manningTeamsItem === 'object' && 'headcount' in manningTeamsItem)
+                        {
+                            manningTeamsItemObject.headcount = (function(){
+                                if(typeof manningTeamsItem.headcount !== 'number')
+                                {
+                                    return Number.isInteger(Number(manningTeamsItem.headcount)) ? Number(manningTeamsItem.headcount) : Math.floor(Number(manningTeamsItem.headcount));
+                                }
+        
+                                return Number.isInteger(manningTeamsItem.headcount) ? manningTeamsItem.headcount : Math.floor(manningTeamsItem.headcount);
+                            }());
+                        }
+                        else
+                        {
+                            manningTeamsItemObject.headcount = 0;
+                        }
+                        
+                        if(typeof manningTeamsItem === 'object' && 'group' in manningTeamsItem)
+                        {
+                            manningTeamsItemObject.group = (function(){
+                                if(typeof manningTeamsItem.group !== 'string')
+                                {
+                                    return String(manningTeamsItem.group);
+                                }
+        
+                                return manningTeamsItem.group;
+                            }());
+                        }
+                        else
+                        {
+                            manningTeamsItemObject.group = "";
+                        }
+        
+                        return manningTeamsItemObject;
+                    }());
+                });
+            }());
+        }
+        
+        if('manningUsesTeams' in jsonObject)
+        {
+            model.manningUsesTeams = (function(){
+                if(jsonObject['manningUsesTeams'] === null)
+                {
+                    return null;
+                }
+        
+                if(typeof jsonObject['manningUsesTeams'] !== 'boolean')
+                {
+                    return Boolean(jsonObject['manningUsesTeams']);
+                }
+        
+                return jsonObject['manningUsesTeams'];
+            }());
+        }
+        
         if('averageCostPerManningUnit' in jsonObject)
         {
             model.averageCostPerManningUnit = (function(){

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

@@ -52,10 +52,20 @@ class SoftSortBeltModel extends BaseModel
         /**
          * The Points used by this Soft Sort Belt
          * 
-         * @type {Object}
+         * @type {{runAuto: number, slowMode: ?number, stopMode: number}}
          * @public
          */
-        this.points = {}
+        this.points = (function(){
+            let pointsDefaultValue = {};
+            
+            pointsDefaultValue.runAuto = 0;
+            
+            pointsDefaultValue.slowMode = null;
+            
+            pointsDefaultValue.stopMode = 0;
+            
+            return pointsDefaultValue;
+        }());
         
         /**
          * The Packing Line that owns this Soft Sort Belt
@@ -163,12 +173,62 @@ class SoftSortBeltModel extends BaseModel
         if('points' in jsonObject)
         {
             model.points = (function(){
-                if(typeof jsonObject['points'] !== 'object')
+                let pointsObject = {};
+                
+                if(typeof jsonObject['points'] === 'object' && 'runAuto' in jsonObject['points'])
                 {
-                    return Object(jsonObject['points']);
+                    pointsObject.runAuto = (function(){
+                        if(typeof jsonObject['points'].runAuto !== 'number')
+                        {
+                            return Number.isInteger(Number(jsonObject['points'].runAuto)) ? Number(jsonObject['points'].runAuto) : Math.floor(Number(jsonObject['points'].runAuto));
+                        }
+        
+                        return Number.isInteger(jsonObject['points'].runAuto) ? jsonObject['points'].runAuto : Math.floor(jsonObject['points'].runAuto);
+                    }());
+                }
+                else
+                {
+                    pointsObject.runAuto = 0;
+                }
+                
+                if(typeof jsonObject['points'] === 'object' && 'slowMode' in jsonObject['points'])
+                {
+                    pointsObject.slowMode = (function(){
+                        if(jsonObject['points'].slowMode === null)
+                        {
+                            return null;
+                        }
+        
+                        if(typeof jsonObject['points'].slowMode !== 'number')
+                        {
+                            return Number.isInteger(Number(jsonObject['points'].slowMode)) ? Number(jsonObject['points'].slowMode) : Math.floor(Number(jsonObject['points'].slowMode));
+                        }
+        
+                        return Number.isInteger(jsonObject['points'].slowMode) ? jsonObject['points'].slowMode : Math.floor(jsonObject['points'].slowMode);
+                    }());
+                }
+                else
+                {
+                    pointsObject.slowMode = null;
+                }
+                
+                if(typeof jsonObject['points'] === 'object' && 'stopMode' in jsonObject['points'])
+                {
+                    pointsObject.stopMode = (function(){
+                        if(typeof jsonObject['points'].stopMode !== 'number')
+                        {
+                            return Number.isInteger(Number(jsonObject['points'].stopMode)) ? Number(jsonObject['points'].stopMode) : Math.floor(Number(jsonObject['points'].stopMode));
+                        }
+        
+                        return Number.isInteger(jsonObject['points'].stopMode) ? jsonObject['points'].stopMode : Math.floor(jsonObject['points'].stopMode);
+                    }());
+                }
+                else
+                {
+                    pointsObject.stopMode = 0;
                 }
         
-                return jsonObject['points'];
+                return pointsObject;
             }());
         }
         

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

@@ -114,9 +114,9 @@ class SoftSortPackrunSummaryModel extends BaseModel
         this.eventsNotAccurateReason = null;
         
         /**
-         * The FreshPack Soft-Sort API Data
+         * Results from Interacting with the FreshPack API to Send Soft-Sort Events Data
          * 
-         * @type {?Object}
+         * @type {?{requestCount: number, requestTimestamp: ?Date, responseCode: ?number, responseMessage: ?string, completed: boolean}}
          * @public
          */
         this.freshPackSoftSortApi = null;
@@ -330,12 +330,104 @@ class SoftSortPackrunSummaryModel extends BaseModel
                     return null;
                 }
         
-                if(typeof jsonObject['freshPackSoftSortApi'] !== 'object')
+                let freshPackSoftSortApiObject = {};
+                
+                if(typeof jsonObject['freshPackSoftSortApi'] === 'object' && 'requestCount' in jsonObject['freshPackSoftSortApi'])
                 {
-                    return Object(jsonObject['freshPackSoftSortApi']);
+                    freshPackSoftSortApiObject.requestCount = (function(){
+                        if(typeof jsonObject['freshPackSoftSortApi'].requestCount !== 'number')
+                        {
+                            return Number.isInteger(Number(jsonObject['freshPackSoftSortApi'].requestCount)) ? Number(jsonObject['freshPackSoftSortApi'].requestCount) : Math.floor(Number(jsonObject['freshPackSoftSortApi'].requestCount));
+                        }
+        
+                        return Number.isInteger(jsonObject['freshPackSoftSortApi'].requestCount) ? jsonObject['freshPackSoftSortApi'].requestCount : Math.floor(jsonObject['freshPackSoftSortApi'].requestCount);
+                    }());
+                }
+                else
+                {
+                    freshPackSoftSortApiObject.requestCount = 0;
+                }
+                
+                if(typeof jsonObject['freshPackSoftSortApi'] === 'object' && 'requestTimestamp' in jsonObject['freshPackSoftSortApi'])
+                {
+                    freshPackSoftSortApiObject.requestTimestamp = (function(){
+                        if(jsonObject['freshPackSoftSortApi'].requestTimestamp === null)
+                        {
+                            return null;
+                        }
+        
+                        if(typeof jsonObject['freshPackSoftSortApi'].requestTimestamp !== 'string')
+                        {
+                            return new Date(String(jsonObject['freshPackSoftSortApi'].requestTimestamp));
+                        }
+        
+                        return new Date(jsonObject['freshPackSoftSortApi'].requestTimestamp);
+                    }());
+                }
+                else
+                {
+                    freshPackSoftSortApiObject.requestTimestamp = null;
+                }
+                
+                if(typeof jsonObject['freshPackSoftSortApi'] === 'object' && 'responseCode' in jsonObject['freshPackSoftSortApi'])
+                {
+                    freshPackSoftSortApiObject.responseCode = (function(){
+                        if(jsonObject['freshPackSoftSortApi'].responseCode === null)
+                        {
+                            return null;
+                        }
+        
+                        if(typeof jsonObject['freshPackSoftSortApi'].responseCode !== 'number')
+                        {
+                            return Number.isInteger(Number(jsonObject['freshPackSoftSortApi'].responseCode)) ? Number(jsonObject['freshPackSoftSortApi'].responseCode) : Math.floor(Number(jsonObject['freshPackSoftSortApi'].responseCode));
+                        }
+        
+                        return Number.isInteger(jsonObject['freshPackSoftSortApi'].responseCode) ? jsonObject['freshPackSoftSortApi'].responseCode : Math.floor(jsonObject['freshPackSoftSortApi'].responseCode);
+                    }());
+                }
+                else
+                {
+                    freshPackSoftSortApiObject.responseCode = null;
+                }
+                
+                if(typeof jsonObject['freshPackSoftSortApi'] === 'object' && 'responseMessage' in jsonObject['freshPackSoftSortApi'])
+                {
+                    freshPackSoftSortApiObject.responseMessage = (function(){
+                        if(jsonObject['freshPackSoftSortApi'].responseMessage === null)
+                        {
+                            return null;
+                        }
+        
+                        if(typeof jsonObject['freshPackSoftSortApi'].responseMessage !== 'string')
+                        {
+                            return String(jsonObject['freshPackSoftSortApi'].responseMessage);
+                        }
+        
+                        return jsonObject['freshPackSoftSortApi'].responseMessage;
+                    }());
+                }
+                else
+                {
+                    freshPackSoftSortApiObject.responseMessage = null;
+                }
+                
+                if(typeof jsonObject['freshPackSoftSortApi'] === 'object' && 'completed' in jsonObject['freshPackSoftSortApi'])
+                {
+                    freshPackSoftSortApiObject.completed = (function(){
+                        if(typeof jsonObject['freshPackSoftSortApi'].completed !== 'boolean')
+                        {
+                            return Boolean(jsonObject['freshPackSoftSortApi'].completed);
+                        }
+        
+                        return jsonObject['freshPackSoftSortApi'].completed;
+                    }());
+                }
+                else
+                {
+                    freshPackSoftSortApiObject.completed = false;
                 }
         
-                return jsonObject['freshPackSoftSortApi'];
+                return freshPackSoftSortApiObject;
             }());
         }
         

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

@@ -7,10 +7,12 @@
 /**
  * @namespace Models.Packhouse.Site
  */
+import BinTipBarcodeScannerModel from './BinTipBarcodeScannerModel';
 import BinTipBinCardModel from './BinTipBinCardModel';
 import BinTipBinModel from './BinTipBinModel';
 import BinTipWeightModel from './BinTipWeightModel';
 import CompacSizerBatchModel from './CompacSizerBatchModel';
+import CompacSizerBinWeightModel from './CompacSizerBinWeightModel';
 import CompacSizerModel from './CompacSizerModel';
 import CompacSizerOutletProductChangeModel from './CompacSizerOutletProductChangeModel';
 import CompacSizerOutletTypeChangeModel from './CompacSizerOutletTypeChangeModel';
@@ -41,10 +43,12 @@ import SoftSortPackrunSummaryModel from './SoftSortPackrunSummaryModel';
 import VarietyModel from './VarietyModel';
 
 const Site = {
+    BinTipBarcodeScannerModel,
     BinTipBinCardModel,
     BinTipBinModel,
     BinTipWeightModel,
     CompacSizerBatchModel,
+    CompacSizerBinWeightModel,
     CompacSizerModel,
     CompacSizerOutletProductChangeModel,
     CompacSizerOutletTypeChangeModel,

package/src/PackageVersion.js

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '2.3.17';
+export const version = '2.3.19';