function getData() {
                                    if (dataReceivedObject !== undefined) {
                                        /** Here we are going to loop through the data object received and gather all the defined information. */
                                            if (dataReceivedObject.data !== undefined) {
                                                for (let i = 0; i < dataReceivedObject.data.length; i++) {
                                                    let thisTime
                                                    let dataArray = []
                                                    let timestampPath = pathToTimestamp.split('['|']')

                                                    // First we must control our path info to iterate through all data in the API response.
                                                    switch (timestampPath.length) {
                                                        case (1): {
                                                            SA.logger.info('This data does not have anything to loop through. Please use a different save option.')
                                                            break
                                                        }
                                                        // If two we will count up and loop through all possible responses.
                                                        case (2): {
                                                            let tPath = timestampPath[0] + i + timestampPath[1]
                                                            thisTime = eval(tPath)
                                                            timestampArray.push(thisTime)
                                                            break
                                                        }
                                                        case (4): {
                                                            // TODO handle iterating through multiple arrays in the same path
                                                            break
                                                        }
                                                    }
                                                    

                                                    /** Here we will loop through the rest of the data defined at the record properties. */
                                                    for (let j = 0; j < pathToData.length; j++) {
                                                        let thisDataP = pathToData[j]
                                                        let dataPath = thisDataP.split('['|']')
        
                                                        switch (dataPath.length) {
                                                            case (1): {
                                                                SA.logger.info('This data does not have anything to loop through. Please use a different save option.')
                                                                break
                                                            }
                                                            // If two we will count up and loop through all possible responses.
                                                            case (2): {
                                                                let dPath = dataPath[0] + i + dataPath[1]
                                                                let thisData = eval(dPath)
                                                                // Here we get the name to call the record.
                                                                let nameSplit = dataPath[1].split('.')
                                                                let recordName = nameSplit[1]
                                                                let thisRecord = {
                                                                    [recordName] : thisData
                                                                }
                                                                dataArray.push(thisData)
                                                                break
                                                            }
                                                            case (4): {
                                                                // TODO handle iterating through multiple arrays in the same path
                                                                break
                                                            }
                                                        }
                                                    }
                                                    completeRecord.set(thisTime, dataArray)
                                                }
                                            }
                                            if (dataReceivedObject.length !== undefined) {
                                                for (let i = 0; i < dataReceivedObject.length; i++) {

                                                    // Here we initialize what we need inside this loop.
                                                    let thisTime
                                                    let dataArray = []
                                                    let timestampPath = pathToTimestamp.split('['|']')
                                                    let tPath
        
                                                    // First we must control our path info to iterate through all timestamps in the API response.
                                                    // Here we gather all of our defined paths and get the timestamps at those locations.
                                                    switch (timestampPath.length) {
                                                        case (1): {
                                                            let thisObject = dataReceivedObject[i]
                                                            let singlePath = pathToTimestamp.split('.')
                                                            tPath = singlePath[1]
                                                            thisTime = thisObject[tPath]
                                                            
                                                            timestampArray.push(thisTime)
                                                            break
                                                        }
                                                        // If two we will count up and loop through all possible responses.
                                                        case (2): {
                                                            tPath = timestampPath[0] + i + timestampPath[1]
                                                            thisTime = eval(tPath)
                                                            timestampArray.push(thisTime)
                                                            break
                                                        } 
                                                        case (4): {
                                                            // TODO handle iterating through multiple arrays in the same path
                                                            break
                                                        }
                                                    }

                                                    // First we must control our path info to iterate through all data in the API response.
                                                    // Here we gather all of our defined paths and get the data at those locations.
                                                    for (let j = 0; j < pathToData.length; j++) {
                                                        let thisDataP = pathToData[j]
                                                        let dataPath = thisDataP.split('['|']')
                                                        let dPath
                                                        let thisData

                                                        switch (dataPath.length) {
                                                            case (1): {
                                                                let thisObject = dataReceivedObject[i]
                                                                let singlePath = thisDataP.split('.')
                                                                let levelPath = singlePath[1]
                                                                let thisData = thisObject[levelPath]
                                                                dataArray.push(thisData)
                                                                break
                                                            }
                                                            case (2): {
                                                                let dPath = dataPath[0] + i + dataPath[1]
                                                                thisData = eval(dPath)

                                                                // Here we get the name to call the record.
                                                                let nameSplit = dataPath[1].split('.')
                                                                let recordName = nameSplit[1]
                                                                let thisRecord = {
                                                                    [recordName] : thisData
                                                                }
                                                                dataArray.push(thisData)
                                                                break
                                                            }
                                                            case (4): {
                                                                // TODO handle iterating through multiple arrays in the same path
                                                                break
                                                            }
                                                        }
                                                    }
                                                    completeRecord.set(thisTime, dataArray)
                                                }
                                            }
                                    } else {
                                        SA.logger.error('dataReceivedObject is not defined. We have no data to save.')
                                    }
                                }
If the record is not a timestamp we will assume it is data.