meadow-endpoints 3.0.7 → 4.0.2

package/source/endpoints/delete/Meadow-Endpoint-Delete.js

@@ -0,0 +1,93 @@
+/**
+* Meadow Endpoint - Delete a Record
+*/
+const doAPIEndpointDelete = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'Delete');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	tmpRequestState.IDRecord = 0;
+	tmpRequestState.RecordCount = { Count:0 };
+
+	this.waterfall(
+		[
+			(fStageComplete) =>
+			{
+				if (typeof(pRequest.params.IDRecord) === 'string')
+				{
+					tmpRequestState.IDRecord = pRequest.params.IDRecord;
+				}
+				else if (typeof(pRequest.body[this.DAL.defaultIdentifier]) === 'number')
+				{
+					tmpRequestState.IDRecord = pRequest.body[this.DAL.defaultIdentifier];
+				}
+				else if (typeof(pRequest.body[this.DAL.defaultIdentifier]) === 'string')
+				{
+					tmpRequestState.IDRecord = pRequest.body[this.DAL.defaultIdentifier];
+				}
+				// Although the Meadow delete behavior does allow multiple deletes, we require an identifier.
+				// If a developer wants bulk delete, it will require a custom endpoint.
+				if (tmpRequestState.IDRecord < 1)
+				{
+					return fStageComplete(this.ErrorHandler.getError('Record delete failure - a valid record ID is required in the passed-in record.', 500));
+				}
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				tmpRequestState.Query = this.DAL.query;
+				tmpRequestState.Query.addFilter(this.DAL.defaultIdentifier, tmpRequestState.IDRecord);
+				tmpRequestState.Query.setIDUser(tmpRequestState.SessionData.UserID);
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				return this.BehaviorInjection.runBehavior(`Delete-QueryConfiguration`, this, pRequest, tmpRequestState, fStageComplete);
+			},
+			(fStageComplete) =>
+			{
+				// Load the record so we can do security checks on it
+				this.DAL.doRead(tmpRequestState.Query,
+					(pError, pQuery, pRecord) =>
+					{
+						if (!pRecord)
+						{
+							return fStageComplete(this.ErrorHandler.getError('Record not found.', 404));
+						}
+						tmpRequestState.Record = pRecord;
+						return fStageComplete();
+					});
+			},
+			(fStageComplete) =>
+			{
+				return this.BehaviorInjection.runBehavior(`Delete-PreOperation`, this, pRequest, tmpRequestState, fStageComplete);
+			},
+			(fStageComplete) =>
+			{
+				// Do the delete
+				this.DAL.doDelete(tmpRequestState.Query,
+					(pError, pQuery, pCount) =>
+					{
+						// MySQL returns the number of rows deleted
+						tmpRequestState.RecordCount.Count = pCount;
+						return fStageComplete(pError);
+					});
+			},
+			(fStageComplete) =>
+			{
+				return this.BehaviorInjection.runBehavior(`Delete-PostOperation`, this, pRequest, tmpRequestState, fStageComplete);
+			},
+			(fStageComplete) =>
+			{
+				pResponse.send(tmpRequestState.RecordCount);
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Deleted ${tmpRequestState.RecordCount.Count} ${this.DAL.scope} records with ID ${tmpRequestState.IDRecord}`);
+				return fStageComplete();
+			}
+		], (pError) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		}
+	);
+};
+
+module.exports = doAPIEndpointDelete;

package/source/endpoints/delete/Meadow-Endpoint-Undelete.js

@@ -0,0 +1,108 @@
+/**
+* Meadow Endpoint - Undelete a Record
+*/
+const doAPIEndpointUndelete = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'Undelete');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+		var tmpIDRecord = 0;
+	if (typeof(pRequest.params.IDRecord) === 'string')
+	{
+		tmpIDRecord = pRequest.params.IDRecord;
+	}
+	else if (typeof(pRequest.body[this.DAL.defaultIdentifier]) === 'number')
+	{
+		tmpIDRecord = pRequest.body[this.DAL.defaultIdentifier];
+	}
+	else if (typeof(pRequest.body[this.DAL.defaultIdentifier]) === 'string')
+	{
+		tmpIDRecord = pRequest.body[this.DAL.defaultIdentifier];
+	}
+	// Although the undelete request does allow multiple undeletes, we require an identifier.
+	// TODO: Decide if we want to keep this pattern similar to Delete, or, if we want to change it to allow bulk undeletes.
+	if (tmpIDRecord < 1)
+	{
+		return fStageComplete(this.ErrorHandler.getError('Record undelete failure - a valid record ID is required.', 500));
+	}
+
+	tmpRequestState.RecordCount = {Count:0};
+
+	this.waterfall(
+		[
+			(fStageComplete) =>
+			{
+				// Validate that the schema has a deleted bit
+				var tmpSchema = this.DAL.schema;
+				var tmpHasDeletedBit = false;
+				for (let i = 0; i < tmpSchema.length; i++)
+				{
+					if (tmpSchema[i].Type == 'Deleted')
+					{
+						tmpHasDeletedBit = true;
+					}
+				}
+
+				if (!tmpHasDeletedBit)
+				{
+					return fStageComplete(this.ErrorHandler.getError('No undelete bit on record.', 500));
+				}
+
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				// Now see if the record, with this identifier, for this user, exists with the deleted bit set to 1
+				tmpRequestState.Query = this.DAL.query;
+				tmpRequestState.Query.addFilter(this.DAL.defaultIdentifier, tmpIDRecord);
+				tmpRequestState.Query.addFilter('Deleted', 1);
+				tmpRequestState.Query.setIDUser(tmpRequestState.SessionData.UserID);
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				// Load the record so we can do security checks on it
+				this.DAL.doRead(tmpRequestState.Query,
+					(pError, pQuery, pRecord) =>
+					{
+						if (!pRecord)
+						{
+							return fStageComplete(this.ErrorHandler.getError('Record not found.', 404));
+						}
+						tmpRequestState.Record = pRecord;
+						return fStageComplete();
+					});
+			},
+			(fStageComplete) =>
+			{
+				return this.BehaviorInjection.runBehavior(`Undelete-PreOperation`, this, pRequest, tmpRequestState, fStageComplete);
+			},
+			(fStageComplete) =>
+			{
+				// Do the undelete
+				this.DAL.doUndelete(tmpRequestState.Query,
+					(pError, pQuery, pCount) =>
+					{
+						// MySQL returns the number of rows deleted
+						tmpRequestState.RecordCount = {Count:pCount};
+						return fStageComplete(pError);
+					});
+			},
+			(fStageComplete) =>
+			{
+				return this.BehaviorInjection.runBehavior(`Undelete-PostOperation`, this, pRequest, tmpRequestState, fStageComplete);
+			},
+			(fStageComplete) =>
+			{
+				pResponse.send(tmpRequestState.RecordCount);
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, 'Undeleted '+tmpRequestState.RecordCount.Count+' records with ID '+tmpIDRecord+'.');
+				return fStageComplete();
+			}
+		], (pError) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		}
+	);
+};
+
+module.exports = doAPIEndpointUndelete;

package/source/endpoints/read/Meadow-Endpoint-Read.js

@@ -0,0 +1,72 @@
+/**
+* Meadow Endpoint - Read a Record
+*/
+const doAPIEndpointRead = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'Read');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	this.waterfall(
+		[
+			(fStageComplete) =>
+			{
+				tmpRequestState.Query = this.DAL.query;
+				return fStageComplete();
+			},
+			fBehaviorInjector(`Read-PreOperation`),
+			(fStageComplete) =>
+			{
+				if (!pRequest.params.IDRecord && pRequest.params.GUIDRecord)
+				{
+					// We use a custom name for this (RequestDefaultIdentifier) in case there is a query with a dot in the default identifier.
+					tmpRequestState.RecordSearchCriteria = `${this.DAL.defaultGUIdentifier} = ${pRequest.params.GUIDRecord}`;
+					tmpRequestState.Query.addFilter(this.DAL.defaultGUIdentifier, pRequest.params.GUIDRecord, '=', 'AND', 'RequestDefaultIdentifier');
+				}
+				else if (pRequest.params.IDRecord)
+				{
+					// We use a custon name for this (RequestDefaultIdentifier) in case there is a query with a dot in the default identifier.
+					tmpRequestState.RecordSearchCriteria = `${this.DAL.defaultIdentifier} = ${pRequest.params.IDRecord}`;
+					tmpRequestState.Query.addFilter(this.DAL.defaultIdentifier, pRequest.params.IDRecord, '=', 'AND', 'RequestDefaultIdentifier');
+				}
+				else
+				{
+					return fStageComplete(this.ErrorHandler.getError('No ID Provided', 400));
+				}
+				return fStageComplete();
+			},
+			fBehaviorInjector(`Read-QueryConfiguration`),
+			(fStageComplete) =>
+			{
+				try
+				{
+					this.DAL.doRead(tmpRequestState.Query, (pError, pQuery, pRecord) =>
+					{
+						if (!pRecord)
+						{
+							return fStageComplete(this.ErrorHandler.getError('Record not Found', 404));
+						}
+						tmpRequestState.Record = pRecord;
+						return fStageComplete();
+					});
+				}
+				catch (pQueryError)
+				{
+					return fStageComplete(pQueryError);
+				}
+			},
+			fBehaviorInjector(`Read-PostOperation`),
+			(fStageComplete) =>
+			{
+				pResponse.send(tmpRequestState.Record);
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Read Record Where ${tmpRequestState.RecordSearchCriteria}`);
+				return fStageComplete();
+			}
+		],
+		(pError) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		}
+	);
+};
+
+module.exports = doAPIEndpointRead;

package/source/endpoints/read/Meadow-Endpoint-ReadDistinctList.js

@@ -0,0 +1,92 @@
+/**
+* Meadow Endpoint - Read a list of Records with a specified set of columns, distinct by those columns.
+*/
+const marshalDistinctList = require('./Meadow-Marshal-DistinctList.js');
+
+const doAPIEndpointReadDistinct = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'ReadDistinct');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	tmpRequestState.DistinctColumns;
+
+	this.waterfall(
+	[
+		(fStageComplete) =>
+		{
+			tmpRequestState.Query = this.DAL.query.setDistinct(true);
+
+			let tmpCap = false;
+			let tmpBegin = false;
+			if (typeof(pRequest.params.Begin) === 'string' ||
+				typeof(pRequest.params.Begin) === 'number')
+			{
+				tmpBegin = parseInt(pRequest.params.Begin, 10);
+			}
+			if (typeof(pRequest.params.Cap) === 'string' ||
+				typeof(pRequest.params.Cap) === 'number')
+			{
+				tmpCap = parseInt(pRequest.params.Cap, 10);
+			}
+			else
+			{
+				//maximum number of records to return by default on Read queries. Override via "MeadowDefaultMaxCap" fable setting.
+				tmpCap = (this.settings['MeadowDefaultMaxCap']) || 250;
+			}
+			tmpRequestState.Query.setCap(tmpCap).setBegin(tmpBegin);
+			if (typeof(pRequest.params.Filter) === 'string')
+			{
+				// If a filter has been passed in, parse it and add the values to the query.
+				this.parseFilter(pRequest.params.Filter, tmpRequestState.Query);
+			}
+			else if (pRequest.params.Filter)
+			{
+				tmpRequestState.Query.setFilter(pRequest.params.Filter);
+			}
+			if (typeof(pRequest.params.Columns) === 'string')
+			{
+				tmpRequestState.DistinctColumns = pRequest.params.Columns.split(',');
+				if (!tmpRequestState.DistinctColumns)
+				{
+					return fStageComplete({Code:400, Message:'Columns to distinct on must be provided.'});
+				}
+				tmpRequestState.Query.setDataElements(tmpRequestState.DistinctColumns);
+			}
+			return fStageComplete();
+		},
+		fBehaviorInjector(`Reads-QueryConfiguration`),
+		(fStageComplete) =>
+		{
+			this.DAL.doReads(tmpRequestState.Query, fStageComplete);
+		},
+		(pQuery, pRecords, fStageComplete) =>
+		{
+			if (pRecords.length < 1)
+			{
+				pRecords = [];
+			}
+			tmpRequestState.Records = pRecords;
+			return fStageComplete();
+		},
+		(fStageComplete) =>
+		{
+			tmpRequestState.ResultRecords = marshalDistinctList.call(this, tmpRequestState.Records, pRequest, tmpRequestState.DistinctColumns);
+			return fStageComplete();
+		},
+		(fStageComplete) =>
+		{
+			return this.doStreamRecordArray(pResponse, tmpRequestState.ResultRecords, fStageComplete);
+		},
+		(fStageComplete) =>
+		{
+			this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Read a recordset distinct lite list with ${tmpRequestState.ResultRecords.length} results.`);
+			return fStageComplete();
+		}
+	],
+	(pError) =>
+	{
+		return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+	});
+};
+
+module.exports = doAPIEndpointReadDistinct;

package/source/endpoints/read/Meadow-Endpoint-ReadLiteList.js

@@ -0,0 +1,85 @@
+/**
+* Meadow Endpoint - Read a list of lite Records (for Drop-downs and such)
+*/
+const marshalLiteList = require('./Meadow-Marshal-LiteList.js');
+
+const doAPIEndpointReadLite = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'ReadsLite');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	this.waterfall(
+		[
+			// 1a. Get the records
+			(fStageComplete) =>
+			{
+				tmpRequestState.Query = this.DAL.query;
+				// TODO: Limit the query to the columns we need for the templated expression
+
+				var tmpCap = false;
+				var tmpBegin = false;
+				if (typeof(pRequest.params.Begin) === 'string' ||
+					typeof(pRequest.params.Begin) === 'number')
+				{
+					tmpBegin = parseInt(pRequest.params.Begin, 10);
+				}
+				if (typeof(pRequest.params.Cap) === 'string' ||
+					typeof(pRequest.params.Cap) === 'number')
+				{
+					tmpCap = parseInt(pRequest.params.Cap, 10);
+				}
+				else
+				{
+					//maximum number of records to return by default on Read queries. Override via "MeadowDefaultMaxCap" fable setting.
+					tmpCap = (this.settings['MeadowDefaultMaxCap']) || 250;
+				}
+				tmpRequestState.Query.setCap(tmpCap).setBegin(tmpBegin);
+				if (typeof(pRequest.params.Filter) === 'string')
+				{
+					// If a filter has been passed in, parse it and add the values to the query.
+					this.parseFilter(pRequest.params.Filter, tmpRequestState.Query);
+				}
+				else if (pRequest.params.Filter)
+				{
+					tmpRequestState.Query.setFilter(pRequest.params.Filter);
+				}
+
+				return fStageComplete();
+			},
+			fBehaviorInjector(`Reads-QueryConfiguration`),
+			(fStageComplete) =>
+			{
+				this.DAL.doReads(tmpRequestState.Query, fStageComplete);
+			},
+			(pQuery, pRecords, fStageComplete) =>
+			{
+				if (pRecords.length < 1)
+				{
+					pRecords = [];
+				}
+				tmpRequestState.RawRecords = pRecords;
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				tmpRequestState.Records = marshalLiteList.call(this, tmpRequestState.RawRecords, pRequest, (typeof(pRequest.params.ExtraColumns) === 'string') ? pRequest.params.ExtraColumns.split(',') : []);
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				return this.doStreamRecordArray(pResponse, tmpRequestState.Records, fNext);
+			},
+			(fStageComplete) =>
+			{
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Read a recordset lite list with ${tmpRequestState.Records.length} results`);
+				return fStageComplete();
+			}
+		],
+		(pError, pResultRecords) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		}
+	);
+};
+
+module.exports = doAPIEndpointReadLite;

package/source/endpoints/read/Meadow-Endpoint-ReadMax.js

@@ -0,0 +1,55 @@
+/**
+* Meadow Endpoint - Read the Max Value of a Column in a Set
+*/
+const doAPIEndpointReadMax = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'ReadMax');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	this.waterfall(
+		[
+			(fStageComplete) =>
+			{
+				tmpRequestState.Query = this.DAL.query;
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				tmpRequestState.ColumnName =  pRequest.params.ColumnName;
+				tmpRequestState.Query.setSort({Column:tmpRequestState.ColumnName, Direction:'Descending'});
+				tmpRequestState.Query.setCap(1);
+
+				return fStageComplete();
+			},
+			fBehaviorInjector(`ReadMax-QueryConfiguration`),
+			(fStageComplete) =>
+			{
+				this.DAL.doRead(tmpRequestState.Query, fStageComplete);
+			},
+			(pQuery, pRecord, fStageComplete) =>
+			{
+				if (!pRecord)
+				{
+					return fStageComplete(this.ErrorHandler.getError('Record not Found', 404));
+				}
+				tmpRequestState.Record = pRecord;
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				this.BehaviorInjection.runBehavior(`ReadMax-PostOperation`, this, pRequest, tmpRequestState, fStageComplete);
+			},
+			(fStageComplete) =>
+			{
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Read max record of ${this.DAL.scope} on ${tmpRequestState.ColumnName}`);
+				pResponse.send(tmpRequestState.Record);
+			}
+		],
+		(pError) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		}
+	);
+};
+
+module.exports = doAPIEndpointReadMax;

package/source/endpoints/read/Meadow-Endpoint-ReadSelectList.js

@@ -0,0 +1,89 @@
+/**
+* Meadow Endpoint - Read a select list of Records (for Drop-downs and such)
+*/
+const doAPIEndpointReadSelectList = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'ReadsBy');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	this.waterfall(
+		[
+			(fStageComplete) =>
+			{
+				tmpRequestState.Query = this.DAL.query;
+
+				var tmpCap = false;
+				var tmpBegin = false;
+				if (typeof(pRequest.params.Begin) === 'string' ||
+					typeof(pRequest.params.Begin) === 'number')
+				{
+					tmpBegin = parseInt(pRequest.params.Begin);
+				}
+				if (typeof(pRequest.params.Cap) === 'string' ||
+					typeof(pRequest.params.Cap) === 'number')
+				{
+					tmpCap = parseInt(pRequest.params.Cap);
+				}
+				else
+				{
+					tmpCap = (this.settings['MeadowDefaultMaxCap']) || 250;
+				}
+				tmpRequestState.Query.setCap(tmpCap).setBegin(tmpBegin);
+				if (typeof(pRequest.params.Filter) === 'string')
+				{
+					this.parseFilter(pRequest.params.Filter, tmpRequestState.Query);
+				}
+
+				return fStageComplete();
+			},
+			fBehaviorInjector(`Reads-QueryConfiguration`),
+			(fStageComplete) =>
+			{
+				this.DAL.doReads(tmpRequestState.Query, fStageComplete);
+			},
+			(pQuery, pRecords, fStageComplete) =>
+			{
+				if (pRecords.length < 1)
+				{
+					pRecords = [];
+				}
+
+				tmpRequestState.Records = pRecords;
+
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				tmpRequestState.SelectList = [];
+
+				for (var i = 0; i < tmpRequestState.Records.length; i++)
+				{
+					tmpRequestState.SelectList.push
+					(
+						{
+							Hash: tmpRequestState.Records[i][this.DAL.defaultIdentifier],
+							Value: this.BehaviorInjection.processTemplate('SelectList', {Record:tmpRequestState.Records[i]}, this.DAL.scope+' #<%= Record.'+this.DAL.defaultIdentifier+'%>')
+						}
+					);
+				}
+
+				return fStageComplete();
+			},
+			(fStageComplete) =>
+			{
+				return this.doStreamRecordArray(pResponse, tmpRequestState.SelectList, fStageComplete);
+			},
+			(fStageComplete) =>
+			{
+				this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, `Read a recordset lite list with ${tmpRequestState.SelectList.length} results.`);
+				return fStageComplete();
+			}
+		],
+		(pError, pResultRecords) =>
+		{
+			return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+		}
+	);
+};
+
+module.exports = doAPIEndpointReadSelectList;

package/source/endpoints/read/Meadow-Endpoint-Reads.js

@@ -0,0 +1,75 @@
+/**
+* Meadow Endpoint - Read a Set of Records
+*/
+const doAPIEndpointReads = function(pRequest, pResponse, fNext)
+{
+	let tmpRequestState = this.initializeRequestState(pRequest, 'Reads');
+	let fBehaviorInjector = (pBehaviorHash) => { return (fStageComplete) => { this.BehaviorInjection.runBehavior(pBehaviorHash, this, pRequest, tmpRequestState, fStageComplete); }; };
+
+	this.waterfall(
+	[
+		(fStageComplete) =>
+		{
+			tmpRequestState.Query = this.DAL.query;
+
+			var tmpCap = false;
+			var tmpBegin = false;
+			if (typeof(pRequest.params.Begin) === 'string' ||
+				typeof(pRequest.params.Begin) === 'number')
+			{
+				tmpBegin = parseInt(pRequest.params.Begin);
+			}
+			if (typeof(pRequest.params.Cap) === 'string' ||
+				typeof(pRequest.params.Cap) === 'number')
+			{
+				tmpCap = parseInt(pRequest.params.Cap);
+			}
+			else
+			{
+				tmpCap = (this.settings['MeadowDefaultMaxCap']) || 250;
+			}
+			tmpRequestState.Query.setCap(tmpCap).setBegin(tmpBegin);
+			if (typeof(pRequest.params.Filter) === 'string')
+			{
+				// If a filter has been passed in, parse it and add the values to the query.
+				this.parseFilter(pRequest.params.Filter, tmpRequestState.Query);
+			}
+			else if (pRequest.params.Filter)
+			{
+				tmpRequestState.Query.setFilter(pRequest.params.Filter);
+			}
+
+			return fStageComplete();
+		},
+		fBehaviorInjector(`Reads-QueryConfiguration`),
+		(fStageComplete) =>
+		{
+			this.DAL.doReads(tmpRequestState.Query, fStageComplete);
+		},
+		(pQuery, pRecords, fStageComplete) =>
+		{
+			if (!pRecords)
+			{
+				return fStageComplete(this.ErrorHandler.getError('No records found.', 404));
+			}
+			tmpRequestState.Records = pRecords;
+			return fStageComplete();
+		},
+		fBehaviorInjector(`Reads-PostOperation`),
+		(fStageComplete) =>
+		{
+			this.doStreamRecordArray(pResponse, tmpRequestState.Records, fStageComplete);
+		},
+		(fStageComplete) =>
+		{
+			this.log.requestCompletedSuccessfully(pRequest, tmpRequestState, 'Read a list of records.');
+			return fStageComplete();
+		}
+	],
+	(pError) =>
+	{
+		return this.ErrorHandler.handleErrorIfSet(pRequest, tmpRequestState, pResponse, pError, fNext);
+	});
+};
+
+module.exports = doAPIEndpointReads;