use last CAN signal as timestamp for pagination

src/components/Cars/CANSignals/index.jsx

@@ -5,6 +5,11 @@ import {
   TableCell,
   TableHead,
   TableRow,
+  Box,
+  FormControl,
+  InputLabel,
+  Select,
+  MenuItem,
 } from "@material-ui/core";
 
 import {
@@ -13,7 +18,7 @@ import {
 } from "../../Contexts/CANSignalsContext";
 
 const Main = ({ vin }) => {
-  const { signals, setVIN, duration } = useCANSignalContext();
+  const { signals, setVIN, queryDate, delays, delayIndex, setDelayIndex } = useCANSignalContext();
 
   useEffect(() => {
     setVIN(vin);
@@ -27,7 +32,11 @@ const Main = ({ vin }) => {
 
   return (
     <>
-      (Received within the last {duration} seconds)
+      <Box sx={{ display: "flex", alignItems: "baseline", gap: "8px" }}>
+        <span>Searching every</span>
+        <DelayController delays={delays} delayIndex={delayIndex} setDelayIndex={setDelayIndex} />
+        <span>seconds for signals sent after {queryDate}.</span>
+      </Box>
       <Table>
         <TableHead>
           <TableRow>
@@ -56,4 +65,33 @@ const CANSignals = (props) => (
   </CANSignalProvider>
 );
 
+const DelayController = ({
+  delays,
+  delayIndex,
+  setDelayIndex
+}) => {
+  const label = "Delay";
+  const handleChange = (event) => {
+    setDelayIndex(event.target.value);
+  }
+
+  return (
+    <FormControl variant="standard" sx={{ m: 1, minWidth: 120 }}>
+      <InputLabel id="can-signal-delay">{label}</InputLabel>
+      <Select
+        labelId="can-signal-delay"
+        onChange={handleChange}
+        value={delayIndex}
+        label={label}
+      >
+        {delays.map((delay, i) => {
+          return (
+            <MenuItem value={i} selected={i === delayIndex} key={delay}>{delay / 1000}</MenuItem>
+          );
+        })}
+      </Select>
+    </FormControl>
+  )
+}
+
 export default CANSignals;

src/components/Contexts/CANSignalsContext.jsx

@@ -27,48 +27,42 @@ const transformSignals = (signals) =>
 
 export const CANSignalProvider = ({ token, children }) => {
   // auto scale polling if not getting response
-  const durations = [10000, 30000, 60000, 120000];
   const delays = [500, 1500, 3000, 6000];
+  const [delayIndex, setDelayIndex] = useState(2);
   const [vin, setVIN] = useState(null);
   const [signals, setSignals] = useState([]);
-  const [delayIndex, setDelayIndex] = useState(0);
+  const [utc, setUtc] = useState(undefined);
 
   useInterval(
     () => {
       getCANSignals()
     }, vin ? delays[delayIndex] : null
-  )
+  );
 
   const getCANSignals = async () => {
     try {
       if (!vin) return;
 
-      const date = new Date();
-      date.setUTCSeconds(date.getUTCSeconds() - durations[delayIndex]);
-
       const result = await api.getCANSignals(vin, {
-        after_utc: date,
+        after_utc: utc,
       }, token);
-      if (result.error)
+
+      if (result.error) {
         throw new Error(`Get CAN signals error. ${result.message}`);
+      }
+
+      const mostRecentTimestamp = result.data?.[0]?.timestamp;
+      if (mostRecentTimestamp) {
+        setUtc(new Date(mostRecentTimestamp).getTime() - 50); // apply slight offset to ensure last CAN Signals sent before sleep are returned.
+      } else {
+        setUtc(new Date().getTime());
+      }
 
       const items = transformSignals(result.data);
 
       if (items.length > 0) {
-        setDelayIndex((index) => {
-          if (index === 0) {
-            return 0;
-          }
-          return index -= 1;
-        });
         setSignals(items);
       } else {
-        setDelayIndex((index) => {
-          if (index < delays.length - 1) {
-            return index += 1;
-          }
-          return index;
-        });
         setSignals([BlankSignal("No signals")]);
       }
     } catch (e) {
@@ -79,9 +73,12 @@ export const CANSignalProvider = ({ token, children }) => {
   return (
     <CANSignalContext.Provider
       value={{
-        duration: durations[delayIndex] / 1000,
+        queryDate: new Date(utc).toLocaleTimeString(),
         signals,
         setVIN,
+        delays,
+        delayIndex,
+        setDelayIndex,
       }}
     >
       {children}

src/components/Contexts/CANSignalsContext.test.jsx

@@ -8,7 +8,7 @@ import {
   waitFor,
   act,
 } from "@testing-library/react";
-import {CANSignalProvider, useCANSignalContext} from "./CANSignalsContext";
+import { CANSignalProvider, useCANSignalContext } from "./CANSignalsContext";
 
 const checkSignalsResults = (filters) => {
   expect(screen.getByTestId("signals").innerHTML).toEqual(filters);
@@ -19,14 +19,15 @@ describe("CANSignalsContext", () => {
     beforeEach(() => {
       jest.useFakeTimers("setInterval");
       const TestComp = () => {
-        const { signals, setVIN } = useCANSignalContext();
+        const { signals, setVIN, setDelayIndex } = useCANSignalContext();
+        setDelayIndex(0);
 
         return (
           <>
             <div data-testid="signals">{JSON.stringify(signals)}</div>
             <button
               data-testid="getSignals"
-              onClick={()=>{setVIN("TESTVIN1234567890")}}
+              onClick={() => { setVIN("TESTVIN1234567890") }}
             />
           </>
         );
@@ -54,12 +55,12 @@ describe("CANSignalsContext", () => {
         await waitFor(() =>
           expect(screen.getByTestId("signals").innerHTML).toBe("[]")
         );
-        jest.advanceTimersByTime(501);
+        jest.advanceTimersByTime(3001);
       })
 
       await waitFor(() => {
         return expect(screen.getByTestId("signals").innerHTML).not.toBe("[]");
-      } );
+      });
 
       checkSignalsResults(JSON.stringify(expectedSignalsData));
     });