9506711534

Committed 13 Jun 2024 09:02PM UTC coverage: 31.845% (-0.006%) from 31.851%

Build # 9506711534

Build Type

Pull #9399

github

Committed by

b0b3rt

Commit Message

clarify comment and cleanup

Pull Request Pull Request #9399: update readstatus lastUpdated when users interact with comments in subscribed feed

Run Details

4816 of 39409 branches covered (12.22%)

Branch coverage included in aggregate %.

1 of 18 new or added lines in 4 files covered. (5.56%)

2 existing lines in 2 files now uncovered.

27993 of 63618 relevant lines covered (44.0%)

179.95 hits per line

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

11.61

/packages/lesswrong/components/hooks/useRecordPostView.tsx

import React, { useContext, useCallback, useState, useMemo } from 'react';
import { useMutation, gql } from '@apollo/client';
import { useCurrentUser } from '../common/withUser';
import { useNewEvents } from '../../lib/events/withNewEvents';
import { hookToHoc } from '../../lib/hocUtils';
import { recombeeApi } from '../../lib/recombee/client';
import { recombeeEnabledSetting, vertexEnabledSetting } from '../../lib/publicSettings';

export type ItemsReadContextType = {
  postsRead: Record<string,boolean>,
  setPostRead: (postId: string, isRead: boolean) => void,
  tagsRead: Record<string,boolean>,
  setTagRead: (tagId: string, isRead: boolean) => void,
};
const ItemsReadContext = React.createContext<ItemsReadContextType|null>(null);
export const useItemsRead = (): ItemsReadContextType => {
  const context = useContext(ItemsReadContext);
  if (!context) throw new Error("useItemsRead called but not a descedent of Layout");
  return context;
}
export const withItemsRead = hookToHoc(useItemsRead);

type ViewablePost = Pick<PostsBase, "_id" | "isRead" | "title" | "draft">;

interface RecombeeOptions {
  recommId?: string;
}

interface VertexOptions {
  attributionId?: string;
}

export interface RecommendationOptions {
  skip?: boolean;
  recombeeOptions?: RecombeeOptions;
  vertexOptions?: VertexOptions;
}

interface RecordPostViewArgs {
  post: ViewablePost;
  extraEventProperties?: Record<string,any>;
  recommendationOptions?: RecommendationOptions
}

export const useRecordPostView = (post: ViewablePost) => {
  const [increasePostViewCount] = useMutation(gql`
    mutation increasePostViewCountMutation($postId: String) {
      increasePostViewCount(postId: $postId)
    }
  `, {
    ignoreResults: true
  });

  const [sendVertexViewItemEvent] = useMutation(gql`
    mutation sendVertexViewItemEventMutation($postId: String!, $attributionId: String) {
      sendVertexViewItemEvent(postId: $postId, attributionId: $attributionId)
    }
  `, {
    ignoreResults: true
  });

  const [markPostCommentsRead] = useMutation(gql`
    mutation markPostCommentsRead($postId: String!) {
      markPostCommentsRead(postId: $postId)
    }
  `, {
    ignoreResults: true
  });
  
  const {recordEvent} = useNewEvents()
  const currentUser = useCurrentUser();
  const {postsRead, setPostRead} = useItemsRead();
  const isRead = post && !!((post._id in postsRead) ? postsRead[post._id] : post.isRead)
  
  const recordPostView = useCallback(async ({post, extraEventProperties, recommendationOptions}: RecordPostViewArgs) => {
    try {
      if (!post) throw new Error("Tried to record view of null post");
      
      // a post id has been found & it's has not been seen yet on this client session
      if (!postsRead[post._id]) {

        // Trigger the asynchronous mutation with postId as an argument
        // Deliberately not awaiting, because this should be fire-and-forget
        await increasePostViewCount({
          variables: {
            postId: post._id
          }
        });

        // Update the client-side read status cache
        setPostRead(post._id, true);
      }

      // Register page-visit event
      if(currentUser) {
        let eventProperties = {
          userId: currentUser._id,
          important: false,
          intercom: true,
          ...extraEventProperties,
          documentId: post._id,
          postTitle: post.title,
        };
        
        recordEvent('post-view', true, eventProperties);
        if (recombeeEnabledSetting.get() && !recommendationOptions?.skip && !post.draft) {
          void recombeeApi.createDetailView(post._id, currentUser._id, recommendationOptions?.recombeeOptions?.recommId);
        }

        if (vertexEnabledSetting.get() && !recommendationOptions?.skip && !post.draft) {
          void sendVertexViewItemEvent({
            variables: {
              postId: post._id,
              attributionId: recommendationOptions?.vertexOptions?.attributionId
            }
          })
        }
      }
    } catch(error) {
      console.log("recordPostView error:", error); // eslint-disable-line
    }
  }, [postsRead, setPostRead, increasePostViewCount, sendVertexViewItemEvent, currentUser, recordEvent]);

  const recordPostCommentsView = ({ post }: Pick<RecordPostViewArgs, 'post'>) => {
    if (currentUser) {
      if (!postsRead[post._id]) {
        // Update the client-side read status cache.
        // Set the value to true even if technically we might be saving isRead: false on the server, if the post hasn't been read before, to get the correct UI update.
        setPostRead(post._id, true);

        // Calling `setPostRead` above ensures we only send an update to server the first time this is triggered.
        // Otherwise it becomes much more likely that someone else posts a comment after the first time we send this,
        // but then we send it again because e.g. the user clicked on another comment (from the initial render).
        void markPostCommentsRead({
          variables: { postId: post._id }
        });
      }
    }
  };
  
  return { recordPostView, recordPostCommentsView, isRead };
}


export const useRecordTagView = (tag: TagFragment): {recordTagView: any, isRead: boolean} => {
  const {recordEvent} = useNewEvents()
  const currentUser = useCurrentUser();
  const {tagsRead, setTagRead} = useItemsRead();
  const isRead = tag && !!((tag._id in tagsRead) ? tagsRead[tag._id] : tag.isRead)
  
  const recordTagView = useCallback(async ({tag, extraEventProperties}: {
    tag: TagBasicInfo
    extraEventProperties: AnyBecauseHard
  }) => {
    try {
      if (!tag) throw new Error("Tried to record view of null tag");
      
      // Update the client-side read status cache
      if (!tagsRead[tag._id]) {
        setTagRead(tag._id, true);
      }

      // Register page-visit event
      if(currentUser) {
        let eventProperties = {
          userId: currentUser._id,
          important: false,
          intercom: true,
          ...extraEventProperties
        };

        eventProperties = {
          ...eventProperties,
          documentId: tag._id,
          tagName: tag.name,
        };
        
        recordEvent('tag-view', true, eventProperties);
      }
    } catch(error) {
      console.log("recordTagView error:", error); // eslint-disable-line
    }
  }, [tagsRead, setTagRead, currentUser, recordEvent]);
  
  return { recordTagView, isRead };
}

export const ItemsReadContextWrapper = ({children}: {children: React.ReactNode}) => {
  const [postsRead,setPostsRead] = useState<Record<string,boolean>>({});
  const [tagsRead,setTagsRead] = useState<Record<string,boolean>>({});
  const providedContext = useMemo(() => ({
    postsRead, tagsRead,
    
    setPostRead: (postId: string, isRead: boolean): void => {
      setPostsRead({...postsRead, [postId]: isRead});
    },
    setTagRead: (tagId: string, isRead: boolean): void => {
      setTagsRead({...tagsRead, [tagId]: isRead});
    },
  }), [postsRead, tagsRead]);
  
  return <ItemsReadContext.Provider value={providedContext}>
    {children}
  </ItemsReadContext.Provider>
}



1	import React, { useContext, useCallback, useState, useMemo } from 'react';	54✔
2	import { useMutation, gql } from '@apollo/client';	18✔
3	import { useCurrentUser } from '../common/withUser';	18✔
4	import { useNewEvents } from '../../lib/events/withNewEvents';	18✔
5	import { hookToHoc } from '../../lib/hocUtils';	18✔
6	import { recombeeApi } from '../../lib/recombee/client';	18✔
7	import { recombeeEnabledSetting, vertexEnabledSetting } from '../../lib/publicSettings';	18✔
8
9	export type ItemsReadContextType = {
10	postsRead: Record<string,boolean>,
11	setPostRead: (postId: string, isRead: boolean) => void,
12	tagsRead: Record<string,boolean>,
13	setTagRead: (tagId: string, isRead: boolean) => void,
14	};
15	const ItemsReadContext = React.createContext<ItemsReadContextType\|null>(null);	18✔
16	export const useItemsRead = (): ItemsReadContextType => {	18✔
17	const context = useContext(ItemsReadContext);	×
18	if (!context) throw new Error("useItemsRead called but not a descedent of Layout");	×
19	return context;	×
20	}
21	export const withItemsRead = hookToHoc(useItemsRead);	18✔
22
23	type ViewablePost = Pick<PostsBase, "_id" \| "isRead" \| "title" \| "draft">;
24
25	interface RecombeeOptions {
26	recommId?: string;
27	}
28
29	interface VertexOptions {
30	attributionId?: string;
31	}
32
33	export interface RecommendationOptions {
34	skip?: boolean;
35	recombeeOptions?: RecombeeOptions;
36	vertexOptions?: VertexOptions;
37	}
38
39	interface RecordPostViewArgs {
40	post: ViewablePost;
41	extraEventProperties?: Record<string,any>;
42	recommendationOptions?: RecommendationOptions
43	}
44
45	export const useRecordPostView = (post: ViewablePost) => {	18✔
46	const [increasePostViewCount] = useMutation(gql`	×
47	mutation increasePostViewCountMutation($postId: String) {
48	increasePostViewCount(postId: $postId)
49	}
50	`, {
51	ignoreResults: true
52	});
53
54	const [sendVertexViewItemEvent] = useMutation(gql`	×
55	mutation sendVertexViewItemEventMutation($postId: String!, $attributionId: String) {
56	sendVertexViewItemEvent(postId: $postId, attributionId: $attributionId)
57	}
58	`, {
59	ignoreResults: true
60	});
61
NEW 62	const [markPostCommentsRead] = useMutation(gql`	×
63	mutation markPostCommentsRead($postId: String!) {
64	markPostCommentsRead(postId: $postId)
65	}
66	`, {
67	ignoreResults: true
68	});
69
70	const {recordEvent} = useNewEvents()	×
71	const currentUser = useCurrentUser();	×
72	const {postsRead, setPostRead} = useItemsRead();	×
73	const isRead = post && !!((post._id in postsRead) ? postsRead[post._id] : post.isRead)	×
74
75	const recordPostView = useCallback(async ({post, extraEventProperties, recommendationOptions}: RecordPostViewArgs) => {	×
76	try {	×
77	if (!post) throw new Error("Tried to record view of null post");	×
78
79	// a post id has been found & it's has not been seen yet on this client session
80	if (!postsRead[post._id]) {	×
81
82	// Trigger the asynchronous mutation with postId as an argument
83	// Deliberately not awaiting, because this should be fire-and-forget
84	await increasePostViewCount({	×
85	variables: {
86	postId: post._id
87	}
88	});
89
90	// Update the client-side read status cache
91	setPostRead(post._id, true);	×
92	}
93
94	// Register page-visit event
95	if(currentUser) {	×
96	let eventProperties = {	×
97	userId: currentUser._id,
98	important: false,
99	intercom: true,
100	...extraEventProperties,
101	documentId: post._id,
102	postTitle: post.title,
103	};
104
105	recordEvent('post-view', true, eventProperties);	×
106	if (recombeeEnabledSetting.get() && !recommendationOptions?.skip && !post.draft) {	×
107	void recombeeApi.createDetailView(post._id, currentUser._id, recommendationOptions?.recombeeOptions?.recommId);	×
108	}
109
110	if (vertexEnabledSetting.get() && !recommendationOptions?.skip && !post.draft) {	×
111	void sendVertexViewItemEvent({	×
112	variables: {
113	postId: post._id,
114	attributionId: recommendationOptions?.vertexOptions?.attributionId	×
115	}
116	})
117	}
118	}
119	} catch(error) {
120	console.log("recordPostView error:", error); // eslint-disable-line	×
121	}
122	}, [postsRead, setPostRead, increasePostViewCount, sendVertexViewItemEvent, currentUser, recordEvent]);
123
NEW 124	const recordPostCommentsView = ({ post }: Pick<RecordPostViewArgs, 'post'>) => {	×
NEW 125	if (currentUser) {	×
NEW 126	if (!postsRead[post._id]) {	×
127	// Update the client-side read status cache.
128	// Set the value to true even if technically we might be saving isRead: false on the server, if the post hasn't been read before, to get the correct UI update.
NEW 129	setPostRead(post._id, true);	×
130
131	// Calling `setPostRead` above ensures we only send an update to server the first time this is triggered.
132	// Otherwise it becomes much more likely that someone else posts a comment after the first time we send this,
133	// but then we send it again because e.g. the user clicked on another comment (from the initial render).
NEW 134	void markPostCommentsRead({	×
135	variables: { postId: post._id }
136	});
137	}
138	}
139	};
140
NEW 141	return { recordPostView, recordPostCommentsView, isRead };	×
142	}
143
144
145	export const useRecordTagView = (tag: TagFragment): {recordTagView: any, isRead: boolean} => {	18✔
146	const {recordEvent} = useNewEvents()	×
147	const currentUser = useCurrentUser();	×
148	const {tagsRead, setTagRead} = useItemsRead();	×
149	const isRead = tag && !!((tag._id in tagsRead) ? tagsRead[tag._id] : tag.isRead)	×
150
151	const recordTagView = useCallback(async ({tag, extraEventProperties}: {	×
152	tag: TagBasicInfo
153	extraEventProperties: AnyBecauseHard
154	}) => {
155	try {	×
156	if (!tag) throw new Error("Tried to record view of null tag");	×
157
158	// Update the client-side read status cache
159	if (!tagsRead[tag._id]) {	×
160	setTagRead(tag._id, true);	×
161	}
162
163	// Register page-visit event
164	if(currentUser) {	×
165	let eventProperties = {	×
166	userId: currentUser._id,
167	important: false,
168	intercom: true,
169	...extraEventProperties
170	};
171
172	eventProperties = {	×
173	...eventProperties,
174	documentId: tag._id,
175	tagName: tag.name,
176	};
177
178	recordEvent('tag-view', true, eventProperties);	×
179	}
180	} catch(error) {
181	console.log("recordTagView error:", error); // eslint-disable-line	×
182	}
183	}, [tagsRead, setTagRead, currentUser, recordEvent]);
184
185	return { recordTagView, isRead };	×
186	}
187
188	export const ItemsReadContextWrapper = ({children}: {children: React.ReactNode}) => {	18✔
189	const [postsRead,setPostsRead] = useState<Record<string,boolean>>({});	×
190	const [tagsRead,setTagsRead] = useState<Record<string,boolean>>({});	×
191	const providedContext = useMemo(() => ({	×
192	postsRead, tagsRead,
193
194	setPostRead: (postId: string, isRead: boolean): void => {
195	setPostsRead({...postsRead, [postId]: isRead});	×
196	},
197	setTagRead: (tagId: string, isRead: boolean): void => {
198	setTagsRead({...tagsRead, [tagId]: isRead});	×
199	},
200	}), [postsRead, tagsRead]);
201
202	return <ItemsReadContext.Provider value={providedContext}>	×
203	{children}
204	</ItemsReadContext.Provider>
205	}
206
207

ForumMagnum / ForumMagnum / 9506711534

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