8892507304

Committed 30 Apr 2024 09:29AM UTC coverage: 31.894% (-0.04%) from 31.937%

Build # 8892507304

Build Type

Pull #9198

github

Committed by

oetherington

Commit Message

Add script to reindex content for deleted users

Pull Request Pull Request #9198: Reindex content in elastic for deleted users

Run Details

4716 of 38617 branches covered (12.21%)

Branch coverage included in aggregate %.

13 of 43 new or added lines in 7 files covered. (30.23%)

473 existing lines in 12 files now uncovered.

27511 of 62428 relevant lines covered (44.07%)

179.63 hits per line

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

15.12

/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 } 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;
  skipRecombee?: boolean;
}

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

export const useRecordPostView = (post: ViewablePost) => {
  const [increasePostViewCount] = useMutation(gql`
    mutation increasePostViewCountMutation($postId: String) {
      increasePostViewCount(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, recombeeOptions}: 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() && !recombeeOptions?.skipRecombee && !post.draft) {
          void recombeeApi.createDetailView(post._id, currentUser._id, recombeeOptions?.recommId);
        }
      }
    } catch(error) {
      console.log("recordPostView error:", error); // eslint-disable-line
    }
  }, [postsRead, setPostRead, increasePostViewCount, currentUser, recordEvent]);
  
  return { recordPostView, 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 } 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	skipRecombee?: boolean;
28	}
29
30	interface RecordPostViewArgs {
31	post: ViewablePost;
32	extraEventProperties?: Record<string,any>;
33	recombeeOptions?: RecombeeOptions;
34	}
35
36	export const useRecordPostView = (post: ViewablePost) => {	18✔
UNCOV 37	const [increasePostViewCount] = useMutation(gql`	×
38	mutation increasePostViewCountMutation($postId: String) {
39	increasePostViewCount(postId: $postId)
40	}
41	`, {
42	ignoreResults: true
43	});
44
UNCOV 45	const {recordEvent} = useNewEvents()	×
46	const currentUser = useCurrentUser();	×
UNCOV 47	const {postsRead, setPostRead} = useItemsRead();	×
UNCOV 48	const isRead = post && !!((post._id in postsRead) ? postsRead[post._id] : post.isRead)	×
49
UNCOV 50	const recordPostView = useCallback(async ({post, extraEventProperties, recombeeOptions}: RecordPostViewArgs) => {	×
UNCOV 51	try {	×
UNCOV 52	if (!post) throw new Error("Tried to record view of null post");	×
53
54	// a post id has been found & it's has not been seen yet on this client session
UNCOV 55	if (!postsRead[post._id]) {	×
56
57	// Trigger the asynchronous mutation with postId as an argument
58	// Deliberately not awaiting, because this should be fire-and-forget
UNCOV 59	await increasePostViewCount({	×
60	variables: {
61	postId: post._id
62	}
63	});
64
65	// Update the client-side read status cache
UNCOV 66	setPostRead(post._id, true);	×
67	}
68
69	// Register page-visit event
UNCOV 70	if(currentUser) {	×
UNCOV 71	let eventProperties = {	×
72	userId: currentUser._id,
73	important: false,
74	intercom: true,
75	...extraEventProperties,
76	documentId: post._id,
77	postTitle: post.title,
78	};
79
UNCOV 80	recordEvent('post-view', true, eventProperties);	×
UNCOV 81	if (recombeeEnabledSetting.get() && !recombeeOptions?.skipRecombee && !post.draft) {	×
UNCOV 82	void recombeeApi.createDetailView(post._id, currentUser._id, recombeeOptions?.recommId);	×
83	}
84	}
85	} catch(error) {
UNCOV 86	console.log("recordPostView error:", error); // eslint-disable-line	×
87	}
88	}, [postsRead, setPostRead, increasePostViewCount, currentUser, recordEvent]);
89
UNCOV 90	return { recordPostView, isRead };	×
91	}
92
93
94	export const useRecordTagView = (tag: TagFragment): {recordTagView: any, isRead: boolean} => {	18✔
UNCOV 95	const {recordEvent} = useNewEvents()	×
UNCOV 96	const currentUser = useCurrentUser();	×
97	const {tagsRead, setTagRead} = useItemsRead();	×
98	const isRead = tag && !!((tag._id in tagsRead) ? tagsRead[tag._id] : tag.isRead)	×
99
UNCOV 100	const recordTagView = useCallback(async ({tag, extraEventProperties}: {	×
101	tag: TagBasicInfo
102	extraEventProperties: AnyBecauseHard
103	}) => {
UNCOV 104	try {	×
UNCOV 105	if (!tag) throw new Error("Tried to record view of null tag");	×
106
107	// Update the client-side read status cache
UNCOV 108	if (!tagsRead[tag._id]) {	×
UNCOV 109	setTagRead(tag._id, true);	×
110	}
111
112	// Register page-visit event
UNCOV 113	if(currentUser) {	×
UNCOV 114	let eventProperties = {	×
115	userId: currentUser._id,
116	important: false,
117	intercom: true,
118	...extraEventProperties
119	};
120
121	eventProperties = {	×
122	...eventProperties,
123	documentId: tag._id,
124	tagName: tag.name,
125	};
126
UNCOV 127	recordEvent('tag-view', true, eventProperties);	×
128	}
129	} catch(error) {
130	console.log("recordTagView error:", error); // eslint-disable-line	×
131	}
132	}, [tagsRead, setTagRead, currentUser, recordEvent]);
133
134	return { recordTagView, isRead };	×
135	}
136
137	export const ItemsReadContextWrapper = ({children}: {children: React.ReactNode}) => {	18✔
UNCOV 138	const [postsRead,setPostsRead] = useState<Record<string,boolean>>({});	×
139	const [tagsRead,setTagsRead] = useState<Record<string,boolean>>({});	×
140	const providedContext = useMemo(() => ({	×
141	postsRead, tagsRead,
142
143	setPostRead: (postId: string, isRead: boolean): void => {
UNCOV 144	setPostsRead({...postsRead, [postId]: isRead});	×
145	},
146	setTagRead: (tagId: string, isRead: boolean): void => {
147	setTagsRead({...tagsRead, [tagId]: isRead});	×
148	},
149	}), [postsRead, tagsRead]);
150
UNCOV 151	return <ItemsReadContext.Provider value={providedContext}>	×
152	{children}
153	</ItemsReadContext.Provider>
154	}
155
156

ForumMagnum / ForumMagnum / 8892507304

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