@ricado/api-client 2.3.28 → 2.4.1

package/src/Controllers/Lab/Site/index.js

@@ -0,0 +1,30 @@
+/**
+ * File Auto-Generated by the RICADO Gen 4 PHP API Project
+ * 
+ * Do Not Edit this File Manually!
+ */
+
+/**
+ * @namespace Controllers.Lab.Site
+ */
+import DehydratorController from './DehydratorController';
+import FruitProfileController from './FruitProfileController';
+import LabController from './LabController';
+import RackController from './RackController';
+import RackPositionController from './RackPositionController';
+import SampleController from './SampleController';
+import SampleFailureReasonController from './SampleFailureReasonController';
+import SampleResultController from './SampleResultController';
+
+const Site = {
+    DehydratorController,
+    FruitProfileController,
+    LabController,
+    RackController,
+    RackPositionController,
+    SampleController,
+    SampleFailureReasonController,
+    SampleResultController,
+};
+
+export default Site;

package/src/Controllers/Lab/index.js

@@ -0,0 +1,16 @@
+/**
+ * File Auto-Generated by the RICADO Gen 4 PHP API Project
+ * 
+ * Do Not Edit this File Manually!
+ */
+
+/**
+ * @namespace Controllers.Lab
+ */
+import Site from './Site/index';
+
+const Lab = {
+    Site,
+};
+
+export default Lab;

package/src/Controllers/Packhouse/Site/ShiftController.js

@@ -913,6 +913,337 @@ class ShiftController
         });
     }
 
+    /**
+     * Retrieve a Shift's Score History [GET /packhouse/sites/{siteId}/shifts/{id}/scoreHistory]
+     * 
+     * Retrieves the Score History for a Shift
+     * 
+     * @static
+     * @public
+     * @param {number} siteId The Site ID
+     * @param {string} id The Shift ID
+     * @return {Promise<Array<ShiftController.ScoreHistoryItem>>}
+     */
+    static getScoreHistory(siteId, id)
+    {
+        return new Promise((resolve, reject) => {
+            RequestHelper.getRequest(`/packhouse/sites/${siteId}/shifts/${id}/scoreHistory`)
+            .then((result) => {
+                let resolveValue = (function(){
+                    if(Array.isArray(result) !== true)
+                    {
+                        return [];
+                    }
+                
+                    return result.map((resultItem) => {
+                        return (function(){
+                            let resultItemObject = {};
+                            
+                            if(typeof resultItem === 'object' && 'timestamp' in resultItem)
+                            {
+                                resultItemObject.timestamp = (function(){
+                                    if(typeof resultItem.timestamp !== 'string')
+                                    {
+                                        return new Date(String(resultItem.timestamp));
+                                    }
+                
+                                    return new Date(resultItem.timestamp);
+                                }());
+                            }
+                            else
+                            {
+                                resultItemObject.timestamp = new Date();
+                            }
+                            
+                            if(typeof resultItem === 'object' && 'score' in resultItem)
+                            {
+                                resultItemObject.score = (function(){
+                                    if(typeof resultItem.score !== 'number')
+                                    {
+                                        return Number(resultItem.score);
+                                    }
+                
+                                    return resultItem.score;
+                                }());
+                            }
+                            else
+                            {
+                                resultItemObject.score = 0;
+                            }
+                
+                            return resultItemObject;
+                        }());
+                    });
+                }());
+                
+                resolve(resolveValue);
+            })
+            .catch(error => reject(error));
+        });
+    }
+
+    /**
+     * Retrieve a Shift Score Metrics [GET /packhouse/sites/{siteId}/shifts/{id}/scoreMetrics]
+     * 
+     * Retrieves the Score Metrics for a Shift
+     * 
+     * @static
+     * @public
+     * @param {number} siteId The Site ID
+     * @param {string} id The Shift ID
+     * @return {Promise<ShiftController.ShiftScoreMetrics>}
+     */
+    static getScoreMetrics(siteId, id)
+    {
+        return new Promise((resolve, reject) => {
+            RequestHelper.getRequest(`/packhouse/sites/${siteId}/shifts/${id}/scoreMetrics`)
+            .then((result) => {
+                let resolveValue = (function(){
+                    let resultObject = {};
+                    
+                    if(typeof result === 'object' && 'scoreActual' in result)
+                    {
+                        resultObject.scoreActual = (function(){
+                            if(typeof result.scoreActual !== 'number')
+                            {
+                                return Number(result.scoreActual);
+                            }
+                
+                            return result.scoreActual;
+                        }());
+                    }
+                    else
+                    {
+                        resultObject.scoreActual = 0;
+                    }
+                    
+                    if(typeof result === 'object' && 'traysPerHourActual' in result)
+                    {
+                        resultObject.traysPerHourActual = (function(){
+                            if(typeof result.traysPerHourActual !== 'number')
+                            {
+                                return Number.isInteger(Number(result.traysPerHourActual)) ? Number(result.traysPerHourActual) : Math.floor(Number(result.traysPerHourActual));
+                            }
+                
+                            return Number.isInteger(result.traysPerHourActual) ? result.traysPerHourActual : Math.floor(result.traysPerHourActual);
+                        }());
+                    }
+                    else
+                    {
+                        resultObject.traysPerHourActual = 0;
+                    }
+                    
+                    if(typeof result === 'object' && 'traysPerHourTarget' in result)
+                    {
+                        resultObject.traysPerHourTarget = (function(){
+                            if(result.traysPerHourTarget === null)
+                            {
+                                return null;
+                            }
+                
+                            if(typeof result.traysPerHourTarget !== 'number')
+                            {
+                                return Number.isInteger(Number(result.traysPerHourTarget)) ? Number(result.traysPerHourTarget) : Math.floor(Number(result.traysPerHourTarget));
+                            }
+                
+                            return Number.isInteger(result.traysPerHourTarget) ? result.traysPerHourTarget : Math.floor(result.traysPerHourTarget);
+                        }());
+                    }
+                    else
+                    {
+                        resultObject.traysPerHourTarget = null;
+                    }
+                    
+                    if(typeof result === 'object' && 'costPerTrayActual' in result)
+                    {
+                        resultObject.costPerTrayActual = (function(){
+                            if(typeof result.costPerTrayActual !== 'number')
+                            {
+                                return Number(result.costPerTrayActual);
+                            }
+                
+                            return result.costPerTrayActual;
+                        }());
+                    }
+                    else
+                    {
+                        resultObject.costPerTrayActual = 0;
+                    }
+                    
+                    if(typeof result === 'object' && 'costPerTrayTarget' in result)
+                    {
+                        resultObject.costPerTrayTarget = (function(){
+                            if(result.costPerTrayTarget === null)
+                            {
+                                return null;
+                            }
+                
+                            if(typeof result.costPerTrayTarget !== 'number')
+                            {
+                                return Number(result.costPerTrayTarget);
+                            }
+                
+                            return result.costPerTrayTarget;
+                        }());
+                    }
+                    else
+                    {
+                        resultObject.costPerTrayTarget = null;
+                    }
+                    
+                    if(typeof result === 'object' && 'qualityR600IdealActual' in result)
+                    {
+                        resultObject.qualityR600IdealActual = (function(){
+                            if(typeof result.qualityR600IdealActual !== 'number')
+                            {
+                                return Number(result.qualityR600IdealActual);
+                            }
+                
+                            return result.qualityR600IdealActual;
+                        }());
+                    }
+                    else
+                    {
+                        resultObject.qualityR600IdealActual = 0;
+                    }
+                    
+                    if(typeof result === 'object' && 'qualityR600IdealTarget' in result)
+                    {
+                        resultObject.qualityR600IdealTarget = (function(){
+                            if(result.qualityR600IdealTarget === null)
+                            {
+                                return null;
+                            }
+                
+                            if(typeof result.qualityR600IdealTarget !== 'number')
+                            {
+                                return Number(result.qualityR600IdealTarget);
+                            }
+                
+                            return result.qualityR600IdealTarget;
+                        }());
+                    }
+                    else
+                    {
+                        resultObject.qualityR600IdealTarget = null;
+                    }
+                    
+                    if(typeof result === 'object' && 'customQualityMetrics' in result)
+                    {
+                        resultObject.customQualityMetrics = (function(){
+                            if(Array.isArray(result.customQualityMetrics) !== true)
+                            {
+                                return [];
+                            }
+                
+                            return result.customQualityMetrics.map((customQualityMetricsItem) => {
+                                return (function(){
+                                    let customQualityMetricsItemObject = {};
+                                    
+                                    if(typeof customQualityMetricsItem === 'object' && 'id' in customQualityMetricsItem)
+                                    {
+                                        customQualityMetricsItemObject.id = (function(){
+                                            if(typeof customQualityMetricsItem.id !== 'string')
+                                            {
+                                                return String(customQualityMetricsItem.id);
+                                            }
+                
+                                            return customQualityMetricsItem.id;
+                                        }());
+                                    }
+                                    else
+                                    {
+                                        customQualityMetricsItemObject.id = "";
+                                    }
+                                    
+                                    if(typeof customQualityMetricsItem === 'object' && 'name' in customQualityMetricsItem)
+                                    {
+                                        customQualityMetricsItemObject.name = (function(){
+                                            if(typeof customQualityMetricsItem.name !== 'string')
+                                            {
+                                                return String(customQualityMetricsItem.name);
+                                            }
+                
+                                            return customQualityMetricsItem.name;
+                                        }());
+                                    }
+                                    else
+                                    {
+                                        customQualityMetricsItemObject.name = "";
+                                    }
+                                    
+                                    if(typeof customQualityMetricsItem === 'object' && 'type' in customQualityMetricsItem)
+                                    {
+                                        customQualityMetricsItemObject.type = (function(){
+                                            if(typeof customQualityMetricsItem.type !== 'string')
+                                            {
+                                                return String(customQualityMetricsItem.type);
+                                            }
+                
+                                            return customQualityMetricsItem.type;
+                                        }());
+                                    }
+                                    else
+                                    {
+                                        customQualityMetricsItemObject.type = "";
+                                    }
+                                    
+                                    if(typeof customQualityMetricsItem === 'object' && 'value' in customQualityMetricsItem)
+                                    {
+                                        customQualityMetricsItemObject.value = (function(){
+                                            if(typeof customQualityMetricsItem.value !== 'number')
+                                            {
+                                                return Number(customQualityMetricsItem.value);
+                                            }
+                
+                                            return customQualityMetricsItem.value;
+                                        }());
+                                    }
+                                    else
+                                    {
+                                        customQualityMetricsItemObject.value = 0;
+                                    }
+                                    
+                                    if(typeof customQualityMetricsItem === 'object' && 'target' in customQualityMetricsItem)
+                                    {
+                                        customQualityMetricsItemObject.target = (function(){
+                                            if(customQualityMetricsItem.target === null)
+                                            {
+                                                return null;
+                                            }
+                
+                                            if(typeof customQualityMetricsItem.target !== 'number')
+                                            {
+                                                return Number(customQualityMetricsItem.target);
+                                            }
+                
+                                            return customQualityMetricsItem.target;
+                                        }());
+                                    }
+                                    else
+                                    {
+                                        customQualityMetricsItemObject.target = null;
+                                    }
+                
+                                    return customQualityMetricsItemObject;
+                                }());
+                            });
+                        }());
+                    }
+                    else
+                    {
+                        resultObject.customQualityMetrics = [];
+                    }
+                
+                    return resultObject;
+                }());
+                
+                resolve(resolveValue);
+            })
+            .catch(error => reject(error));
+        });
+    }
+
     /**
      * List all Shifts [GET /packhouse/sites/{siteId}/shifts]
      * 
@@ -1061,6 +1392,42 @@ export default ShiftController;
  * @memberof Controllers.Packhouse.Site
  */
 
+/**
+ * A **ScoreHistoryItem** Type
+ * 
+ * @typedef {Object} ShiftController.ScoreHistoryItem
+ * @property {Date} timestamp The Timestamp for the Score Percentage Value
+ * @property {number} score The Score Value as a Percentage
+ * @memberof Controllers.Packhouse.Site
+ */
+
+/**
+ * A **CustomQualityMetricItem** Type
+ * 
+ * @typedef {Object} ShiftController.CustomQualityMetricItem
+ * @property {string} id The ID of this Custom Quality Metric Item
+ * @property {string} name The Name of this Custom Quality Metric Item
+ * @property {string} type The Display Type for this Custom Quality Metric Item
+ * @property {number} value The Actual Value for this Custom Quality Metric Item
+ * @property {?number} target The Target Value for this Custom Quality Metric Item
+ * @memberof Controllers.Packhouse.Site
+ */
+
+/**
+ * A **ShiftScoreMetrics** Type
+ * 
+ * @typedef {Object} ShiftController.ShiftScoreMetrics
+ * @property {number} scoreActual The Actual Score represented as a Percentage
+ * @property {number} traysPerHourActual The Actual Tray Equivalents per Hour
+ * @property {?number} traysPerHourTarget The Target Tray Equivalents per Hour
+ * @property {number} costPerTrayActual The Actual Cost per Tray Equivalent represented in cents
+ * @property {?number} costPerTrayTarget The Target Cost per Tray Equivalent represented in cents
+ * @property {number} qualityR600IdealActual The Actual Quality R600 Ideal Samples represented as a Percentage
+ * @property {?number} qualityR600IdealTarget The Target Quality R600 Ideal Samples represented as a Percentage
+ * @property {Array<ShiftController.CustomQualityMetricItem>} customQualityMetrics An Array of Custom Quality Metric Items for the Shift
+ * @memberof Controllers.Packhouse.Site
+ */
+
 /**
  * A **ShiftHandoverNote** Type
  * 

package/src/Controllers/index.js

@@ -18,6 +18,7 @@ import TokenController from './TokenController';
 import ToolsController from './ToolsController';
 import UserAccountActionTokenController from './UserAccountActionTokenController';
 import UserAccountController from './UserAccountController';
+import Lab from './Lab/index';
 import Packhouse from './Packhouse/index';
 import RTU from './RTU/index';
 import Site from './Site/index';
@@ -34,6 +35,7 @@ const Controllers = {
     ToolsController,
     UserAccountActionTokenController,
     UserAccountController,
+    Lab,
     Packhouse,
     RTU,
     Site,

package/src/Models/Lab/Site/DehydratorModel.js

@@ -0,0 +1,234 @@
+/**
+ * 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 Dehydrator
+ * 
+ * @class
+ * @hideconstructor
+ * @extends BaseModel
+ */
+class DehydratorModel extends BaseModel
+{
+    /**
+     * DehydratorModel Constructor
+     * 
+     * @protected
+     * @param {number} siteId The Site ID associated with this Dehydrator
+     */
+    constructor(siteId)
+    {
+        super();
+        
+        /**
+         * The Dehydrator ID
+         * 
+         * @type {string}
+         * @public
+         */
+        this.id = "";
+        
+        /**
+         * The RTU this Dehydrator belongs to
+         * 
+         * @type {?number}
+         * @public
+         */
+        this.rtuId = null;
+        
+        /**
+         * The Name of this Dehydrator
+         * 
+         * @type {string}
+         * @public
+         */
+        this.name = "";
+        
+        /**
+         * The Points used by this Dehydrator
+         * 
+         * @type {{rackPositionId: number}}
+         * @public
+         */
+        this.points = (function(){
+            let pointsDefaultValue = {};
+            
+            pointsDefaultValue.rackPositionId = 0;
+            
+            return pointsDefaultValue;
+        }());
+        
+        /**
+         * The Lab that owns this Dehydrator
+         * 
+         * @type {string}
+         * @public
+         */
+        this.labId = "";
+        
+        /**
+         * Whether the Dehydrator has been deleted
+         * 
+         * @type {boolean}
+         * @public
+         */
+        this.deleted = false;
+        
+        /**
+         * When the Dehydrator was last updated
+         * 
+         * @type {Date}
+         * @public
+         */
+        this.updateTimestamp = new Date();
+        
+        /**
+         * The Site ID associated with this Dehydrator
+         * 
+         * @type {number}
+         * @public
+         */
+        this.siteId = siteId;
+    }
+
+    /**
+     * Create a new **DehydratorModel** 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 Dehydrator
+     * @return {DehydratorModel}
+     */
+    static fromJSON(json, siteId)
+    {
+        let model = new DehydratorModel(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(){
+                let pointsObject = {};
+                
+                if(typeof jsonObject['points'] === 'object' && 'rackPositionId' in jsonObject['points'])
+                {
+                    pointsObject.rackPositionId = (function(){
+                        if(typeof jsonObject['points'].rackPositionId !== 'number')
+                        {
+                            return Number.isInteger(Number(jsonObject['points'].rackPositionId)) ? Number(jsonObject['points'].rackPositionId) : Math.floor(Number(jsonObject['points'].rackPositionId));
+                        }
+        
+                        return Number.isInteger(jsonObject['points'].rackPositionId) ? jsonObject['points'].rackPositionId : Math.floor(jsonObject['points'].rackPositionId);
+                    }());
+                }
+                else
+                {
+                    pointsObject.rackPositionId = 0;
+                }
+        
+                return pointsObject;
+            }());
+        }
+        
+        if('labId' in jsonObject)
+        {
+            model.labId = (function(){
+                if(typeof jsonObject['labId'] !== 'string')
+                {
+                    return String(jsonObject['labId']);
+                }
+        
+                return jsonObject['labId'];
+            }());
+        }
+        
+        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 DehydratorModel;