11062509048

Committed 27 Sep 2024 12:44AM UTC coverage: 31.795% (-0.02%) from 31.813%

Build # 11062509048

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9811 from ForumMagnum/master

Deploy

Run Details

5073 of 41593 branches covered (12.2%)

Branch coverage included in aggregate %.

0 of 7 new or added lines in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

29566 of 67351 relevant lines covered (43.9%)

183.61 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

12.5

/packages/lesswrong/components/seasonal/petrovDay/PetrovWarningConsole.tsx

import React, { useEffect, useState } from 'react';
import { registerComponent, Components } from '@/lib/vulcan-lib';
import { gql, useQuery } from '@apollo/client';
import { useMulti } from '@/lib/crud/withMulti';
import { useCreate } from '@/lib/crud/withCreate';

const styles = (theme: ThemeType) => ({
  root: {

  },
  minutesRemaining: {
    fontSize: '.9rem',
    color: theme.palette.grey[600]
  },
  reportButton: {
    border: theme.palette.border.answerBorder,
    borderRadius: 6,
    margin: 10,
    padding: '10px 20px',
    fontSize: '1rem',
    cursor: 'pointer',
    '&:hover': {
      backgroundColor: theme.palette.grey[200]
    }
  }
});

const STARTING_MINUTE = 50

export const inWarningWindow = (currentMinute: number) => {
  return currentMinute >= STARTING_MINUTE || currentMinute < 17
}

export const PetrovWarningConsole = ({classes, currentUser, side}: {
  classes: ClassesType<typeof styles>,
  currentUser: UsersCurrent,
  side: 'east' | 'west'
}) => {
  const { PetrovWorldmapWrapper, PastWarnings } = Components;

  const { results: petrovDayActions = [], refetch: refetchPetrovDayActions } = useMulti({
    collectionName: 'PetrovDayActions',
    fragmentName: 'PetrovDayActionInfo',
    terms: {
      view: 'warningConsole',
      side: side,
      limit: 200
    },
    skip: !currentUser
  })
  const [lastReported, setLastReported] = useState<string | null>(null)

  const pastWarnings = side === 'east'
    ? petrovDayActions.filter(({actionType}) => actionType === 'eastPetrovAllClear' || actionType === 'eastPetrovNukesIncoming')
    : petrovDayActions.filter(({actionType}) => actionType === 'westPetrovAllClear' || actionType === 'westPetrovNukesIncoming');

  const latestWarning = pastWarnings.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())[0]?.createdAt || lastReported

  const canSendNewReport = true

  const currentMinute = new Date().getMinutes();
  const reportWindow = inWarningWindow(currentMinute)
  const minutesRemaining = Math.abs(currentMinute - STARTING_MINUTE)

  const { data, refetch: refetchCount } = useQuery(gql`
    query petrovDay2024Resolvers {
      PetrovDay2024CheckNumberOfIncoming {
        count
      }
    }
  `, {
    ssr: true,
    variables: {
      side
    }
  });

  const count = data?.PetrovDay2024CheckNumberOfIncoming?.count?.toLocaleString()

  const { create: createPetrovDayAction, loading: createPetrovDayActionLoading } = useCreate({
    collectionName: 'PetrovDayActions',
    fragmentName: 'PetrovDayActionInfo'
  })

  const handleReport = async (incoming: boolean) => {
    if (!canSendNewReport || !reportWindow) return
    const reportActionType = incoming ? (side === 'east' ? 'eastPetrovNukesIncoming' : 'westPetrovNukesIncoming') : (side === 'east' ? 'eastPetrovAllClear' : 'westPetrovAllClear')
    await createPetrovDayAction({  
      data: {
        userId: currentUser._id,
        actionType: reportActionType,
      }
    }) 
    refetchPetrovDayActions()
    setLastReported(new Date().toISOString())
  }

  useEffect(() => {
    const interval = setInterval(() => {
      if (currentUser) {
        void refetchCount();
        void refetchPetrovDayActions();
      }
    }, 30000);
    return () => clearInterval(interval);
  }, [refetchCount, refetchPetrovDayActions, currentUser]);

  if (inWarningWindow(currentMinute)) {
    return <PetrovWorldmapWrapper>
      <h1>{count} detected missiles</h1>
      {createPetrovDayActionLoading && <div>Loading...</div>}
      {canSendNewReport && !createPetrovDayActionLoading && <div>
        <button className={classes.reportButton} onClick={() => handleReport(false)}>Report "All Clear"</button>
        <button className={classes.reportButton} onClick={() => handleReport(true)}>Report INCOMING NUKES</button>
      </div>}
      <PastWarnings petrovDayActions={petrovDayActions} side={side} />
    </PetrovWorldmapWrapper>;
  } else {
    return <PetrovWorldmapWrapper>
      <h2>Scanning...</h2>
      <div className={classes.minutesRemaining}>{minutesRemaining} minutes until next scan complete</div>
      <PastWarnings petrovDayActions={petrovDayActions} side={side} />
    </PetrovWorldmapWrapper>;
  }
}

const PetrovWarningConsoleComponent = registerComponent('PetrovWarningConsole', PetrovWarningConsole, {styles});

declare global {
  interface ComponentTypes {
    PetrovWarningConsole: typeof PetrovWarningConsoleComponent
  }
}

1	import React, { useEffect, useState } from 'react';	57✔
2	import { registerComponent, Components } from '@/lib/vulcan-lib';	19✔
3	import { gql, useQuery } from '@apollo/client';	19✔
4	import { useMulti } from '@/lib/crud/withMulti';	19✔
5	import { useCreate } from '@/lib/crud/withCreate';	19✔
6
7	const styles = (theme: ThemeType) => ({	19✔
8	root: {
9
10	},
11	minutesRemaining: {
12	fontSize: '.9rem',
13	color: theme.palette.grey[600]
14	},
15	reportButton: {
16	border: theme.palette.border.answerBorder,
17	borderRadius: 6,
18	margin: 10,
19	padding: '10px 20px',
20	fontSize: '1rem',
21	cursor: 'pointer',
22	'&:hover': {
23	backgroundColor: theme.palette.grey[200]
24	}
25	}
26	});
27
28	const STARTING_MINUTE = 50	19✔
29
30	export const inWarningWindow = (currentMinute: number) => {	19✔
NEW 31	return currentMinute >= STARTING_MINUTE \|\| currentMinute < 17	×
32	}
33
34	export const PetrovWarningConsole = ({classes, currentUser, side}: {	19✔
35	classes: ClassesType<typeof styles>,
36	currentUser: UsersCurrent,
37	side: 'east' \| 'west'
38	}) => {
39	const { PetrovWorldmapWrapper, PastWarnings } = Components;	×
40
41	const { results: petrovDayActions = [], refetch: refetchPetrovDayActions } = useMulti({	×
42	collectionName: 'PetrovDayActions',
43	fragmentName: 'PetrovDayActionInfo',
44	terms: {
45	view: 'warningConsole',
46	side: side,
47	limit: 200
48	},
49	skip: !currentUser
50	})
51	const [lastReported, setLastReported] = useState<string \| null>(null)	×
52
53	const pastWarnings = side === 'east'	×
54	? petrovDayActions.filter(({actionType}) => actionType === 'eastPetrovAllClear' \|\| actionType === 'eastPetrovNukesIncoming')	×
55	: petrovDayActions.filter(({actionType}) => actionType === 'westPetrovAllClear' \|\| actionType === 'westPetrovNukesIncoming');	×
56
57	const latestWarning = pastWarnings.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())[0]?.createdAt \|\| lastReported	×
58
NEW 59	const canSendNewReport = true	×
60
61	const currentMinute = new Date().getMinutes();	×
62	const reportWindow = inWarningWindow(currentMinute)	×
63	const minutesRemaining = Math.abs(currentMinute - STARTING_MINUTE)	×
64
65	const { data, refetch: refetchCount } = useQuery(gql`	×
66	query petrovDay2024Resolvers {
67	PetrovDay2024CheckNumberOfIncoming {
68	count
69	}
70	}
71	`, {
72	ssr: true,
73	variables: {
74	side
75	}
76	});
77
78	const count = data?.PetrovDay2024CheckNumberOfIncoming?.count?.toLocaleString()	×
79
NEW 80	const { create: createPetrovDayAction, loading: createPetrovDayActionLoading } = useCreate({	×
81	collectionName: 'PetrovDayActions',
82	fragmentName: 'PetrovDayActionInfo'
83	})
84
NEW 85	const handleReport = async (incoming: boolean) => {	×
86	if (!canSendNewReport \|\| !reportWindow) return	×
87	const reportActionType = incoming ? (side === 'east' ? 'eastPetrovNukesIncoming' : 'westPetrovNukesIncoming') : (side === 'east' ? 'eastPetrovAllClear' : 'westPetrovAllClear')	×
NEW 88	await createPetrovDayAction({	×
89	data: {
90	userId: currentUser._id,
91	actionType: reportActionType,
92	}
93	})
NEW 94	refetchPetrovDayActions()	×
UNCOV 95	setLastReported(new Date().toISOString())	×
96	}
97
98	useEffect(() => {	×
99	const interval = setInterval(() => {	×
100	if (currentUser) {	×
101	void refetchCount();	×
102	void refetchPetrovDayActions();	×
103	}
104	}, 30000);
105	return () => clearInterval(interval);	×
106	}, [refetchCount, refetchPetrovDayActions, currentUser]);
107
NEW 108	if (inWarningWindow(currentMinute)) {	×
109	return <PetrovWorldmapWrapper>	×
110	<h1>{count} detected missiles</h1>
111	{createPetrovDayActionLoading && <div>Loading...</div>}	×
112	{canSendNewReport && !createPetrovDayActionLoading && <div>	×
113	<button className={classes.reportButton} onClick={() => handleReport(false)}>Report "All Clear"</button>	×
114	<button className={classes.reportButton} onClick={() => handleReport(true)}>Report INCOMING NUKES</button>	×
115	</div>}
116	<PastWarnings petrovDayActions={petrovDayActions} side={side} />
117	</PetrovWorldmapWrapper>;
118	} else {
119	return <PetrovWorldmapWrapper>	×
120	<h2>Scanning...</h2>
121	<div className={classes.minutesRemaining}>{minutesRemaining} minutes until next scan complete</div>
122	<PastWarnings petrovDayActions={petrovDayActions} side={side} />
123	</PetrovWorldmapWrapper>;
124	}
125	}
126
127	const PetrovWarningConsoleComponent = registerComponent('PetrovWarningConsole', PetrovWarningConsole, {styles});	19✔
128
129	declare global {
130	interface ComponentTypes {
131	PetrovWarningConsole: typeof PetrovWarningConsoleComponent
132	}
133	}

ForumMagnum / ForumMagnum / 11062509048

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous