15066626824

Committed 16 May 2025 10:41AM UTC coverage: 37.574% (-0.02%) from 37.594%

Build # 15066626824

Build Type

Pull #1517

github

Committed by

web-flow

Commit Message

Merge e05a1c169 into 607ffe7f9

Pull Request Pull Request #1517: Mise à jour vers react-router@7

Run Details

549 of 776 branches covered (70.75%)

Branch coverage included in aggregate %.

13 of 373 new or added lines in 28 files covered. (3.49%)

5 existing lines in 4 files now uncovered.

5319 of 14841 relevant lines covered (35.84%)

2.56 hits per line

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

52.07

/front/src/hooks/article.js

import { useSelector } from 'react-redux'

import { toEntries } from '../helpers/bibtex.js'
import { executeQuery } from '../helpers/graphQL.js'
import useFetchData, {
  useConditionalFetchData,
  useMutateData,
} from './graphql.js'

import {
  addTags,
  deleteArticle,
  duplicateArticle,
  getArticleTags,
  removeTags,
  renameArticle,
  getArticleWorkingCopy,
  getEditableArticle,
  updateWorkingVersion,
  updateZoteroLinkMutation,
} from '../components/Article.graphql'
import {
  createVersion,
  getArticleVersion,
  getArticleVersions,
  renameVersion,
} from './Versions.graphql'

export function useArticleTagActions({ articleId }) {
  const sessionToken = useSelector((state) => state.sessionToken)
  const { data, mutate, error, isLoading } = useFetchData(
    { query: getArticleTags, variables: { articleId } },
    {
      revalidateOnFocus: false,
      revalidateOnReconnect: false,
    }
  )
  const add = async (tagId) => {
    const result = await executeQuery({
      query: addTags,
      variables: {
        articleId,
        tags: [tagId],
      },
      sessionToken,
      type: 'mutation',
    })
    const tags = result.article.addTags
    mutate(
      {
        article: {
          tags,
        },
      },
      { revalidate: false }
    )
    return tags
  }
  const remove = async (tagId) => {
    const result = await executeQuery({
      query: removeTags,
      variables: {
        articleId,
        tags: [tagId],
      },
      sessionToken,
      type: 'mutation',
    })
    const tags = result.article.removeTags
    mutate(
      {
        article: {
          tags,
        },
      },
      { revalidate: false }
    )
    return tags
  }

  return {
    tags: data?.article?.tags || [],
    isLoading,
    error,
    add,
    remove,
  }
}

export function useArticleActions({ articleId }) {
  const sessionToken = useSelector((state) => state.sessionToken)
  const activeUser = useSelector((state) => state.activeUser)
  const copy = async (toUserId) => {
    return await executeQuery({
      query: duplicateArticle,
      variables: {
        user: null,
        to: toUserId,
        articleId,
      },
      sessionToken,
      type: 'mutation',
    })
  }
  const duplicate = async () => {
    return await executeQuery({
      query: duplicateArticle,
      variables: {
        user: activeUser._id,
        to: activeUser._id,
        articleId,
      },
      sessionToken,
      type: 'mutation',
    })
  }
  const rename = async (title) => {
    return await executeQuery({
      query: renameArticle,
      variables: { user: activeUser._id, articleId, title },
      sessionToken,
      type: 'mutation',
    })
  }
  const remove = async () => {
    return await executeQuery({
      query: deleteArticle,
      variables: { articleId },
    })
  }

  return {
    copy,
    duplicate,
    rename,
    remove,
  }
}

export function useArticleWorkingCopy({ articleId }) {
  const sessionToken = useSelector((state) => state.sessionToken)
  const activeUser = useSelector((state) => state.activeUser)
  const { data, error, mutate, isLoading } = useFetchData(
    { query: getArticleWorkingCopy, variables: { articleId } },
    {
      revalidateOnFocus: false,
      revalidateOnReconnect: false,
    }
  )

  const updateMetadata = async (metadata) => {
    await executeQuery({
      sessionToken,
      query: updateWorkingVersion,
      variables: {
        userId: activeUser._id,
        articleId: articleId,
        content: { metadata },
      },
      type: 'mutate',
    })
    await mutate(
      async (data) => {
        return {
          article: {
            ...data.article,
            workingVersion: {
              ...data.workingVersion,
              metadata: metadata,
            },
          },
        }
      },
      { revalidate: false }
    )
  }

  return {
    article: data?.article,
    updateMetadata,
    isLoading,
    error,
  }
}

export function useEditableArticle({ articleId, versionId }) {
  const sessionToken = useSelector((state) => state.sessionToken)
  const activeUser = useSelector((state) => state.activeUser)
  const hasVersion = typeof versionId === 'string'
  const { data, mutate, error, isLoading } = useFetchData(
    {
      query: getEditableArticle,
      variables: {
        article: articleId,
        hasVersion,
        version: versionId ?? '',
      },
    },
    {
      revalidateOnFocus: false,
      revalidateOnReconnect: false,
      fallbackData: {
        article: {},
      },
    }
  )

  const updateBibliography = async (bib) => {
    await executeQuery({
      sessionToken,
      query: updateWorkingVersion,
      variables: {
        userId: activeUser._id,
        articleId: articleId,
        content: { bib },
      },
      type: 'mutate',
    })
    await mutate(
      async (data) => {
        if (hasVersion) {
          return {
            article: {
              ...data.article,
              version: {
                ...data.version,
                bib,
              },
            },
          }
        } else {
          return {
            article: {
              ...data.article,
              workingVersion: {
                ...data.workingVersion,
                bib,
              },
            },
          }
        }
      },
      { revalidate: false }
    )
  }

  const updateZoteroLink = async (url) => {
    await executeQuery({
      sessionToken,
      query: updateZoteroLinkMutation,
      variables: {
        articleId: articleId,
        url,
      },
      type: 'mutate',
    })
    await mutate(
      async (data) => {
        return {
          article: {
            ...data.article,
            zoteroLink: url,
          },
        }
      },
      { revalidate: false }
    )
  }

  const bibtext = hasVersion
    ? (data?.article?.version?.bib ?? '')
    : (data?.article?.workingVersion?.bib ?? '')

  const entries = toEntries(bibtext)

  return {
    article: data?.article,
    updateBibliography,
    updateZoteroLink,
    bibliography: {
      bibtext,
      entries,
    },
    isLoading,
    error,
  }
}

export function useArticleVersions({ articleId }) {
  const { data, error, isLoading } = useFetchData(
    { query: getArticleVersions, variables: { article: articleId } },
    {
      revalidateOnFocus: false,
      revalidateOnReconnect: false,
    }
  )

  return {
    error,
    isLoading,
    article: data?.article,
  }
}

export function useArticleVersion({ versionId }) {
  const { data, error, isLoading } = useConditionalFetchData(
    versionId ? { query: getArticleVersion, variables: { versionId } } : null,
    {
      revalidateOnFocus: false,
      revalidateOnReconnect: false,
      fallbackData: {
        version: {}
      }
    }
  )

  return {
    error,
    isLoading,
    version: data?.version,
  }
}

export function useArticleVersionActions({ articleId }) {
  const sessionToken = useSelector((state) => state.sessionToken)
  const activeUser = useSelector((state) => state.activeUser)
  const { mutate } = useMutateData({
    query: getArticleVersions,
    variables: { article: articleId },
  })
  const create = async (version) => {
    const response = await executeQuery({
      query: createVersion,
      variables: {
        userId: activeUser._id,
        articleId,
        major: version.major,
        message: version.description,
      },
      sessionToken,
      type: 'mutation',
    })
    await mutate(async (data) => ({
      article: {
        ...data?.article,
        versions: response.article.createVersion.versions,
      },
    }))
  }
  const updateDescription = async ({ versionId, description }) => {
    await executeQuery({
      query: renameVersion,
      variables: {
        version: versionId,
        name: description,
      },
      sessionToken,
      type: 'mutation',
    })
    await mutate(async (data) => ({
      article: {
        ...data?.article,
        versions: data.article.versions.map((v) => {
          if (v._id === versionId) {
            return {
              ...v,
              message: description,
            }
          }
          return v
        }),
      },
    }))
  }

  return {
    create,
    updateDescription,
  }
}

1	import { useSelector } from 'react-redux'	1✔
2
3	import { toEntries } from '../helpers/bibtex.js'	1✔
4	import { executeQuery } from '../helpers/graphQL.js'	1✔
5	import useFetchData, {	1✔
6	useConditionalFetchData,
7	useMutateData,
8	} from './graphql.js'
9
10	import {	1✔
11	addTags,
12	deleteArticle,
13	duplicateArticle,
14	getArticleTags,
15	removeTags,
16	renameArticle,
17	getArticleWorkingCopy,
18	getEditableArticle,
19	updateWorkingVersion,
20	updateZoteroLinkMutation,
21	} from '../components/Article.graphql'
22	import {	1✔
23	createVersion,
24	getArticleVersion,
25	getArticleVersions,
26	renameVersion,
27	} from './Versions.graphql'
28
29	export function useArticleTagActions({ articleId }) {	1✔
30	const sessionToken = useSelector((state) => state.sessionToken)	6✔
31	const { data, mutate, error, isLoading } = useFetchData(	6✔
32	{ query: getArticleTags, variables: { articleId } },	6✔
33	{	6✔
34	revalidateOnFocus: false,	6✔
35	revalidateOnReconnect: false,	6✔
36	}	6✔
37	)	6✔
38	const add = async (tagId) => {	6✔
39	const result = await executeQuery({	1✔
40	query: addTags,	1✔
41	variables: {	1✔
42	articleId,	1✔
43	tags: [tagId],	1✔
44	},	1✔
45	sessionToken,	1✔
46	type: 'mutation',	1✔
47	})	1✔
48	const tags = result.article.addTags	1✔
49	mutate(	1✔
50	{	1✔
51	article: {	1✔
52	tags,	1✔
53	},	1✔
54	},	1✔
55	{ revalidate: false }	1✔
56	)	1✔
57	return tags	1✔
58	}	1✔
59	const remove = async (tagId) => {	6✔
60	const result = await executeQuery({	1✔
61	query: removeTags,	1✔
62	variables: {	1✔
63	articleId,	1✔
64	tags: [tagId],	1✔
65	},	1✔
66	sessionToken,	1✔
67	type: 'mutation',	1✔
68	})	1✔
69	const tags = result.article.removeTags	1✔
70	mutate(	1✔
71	{	1✔
72	article: {	1✔
73	tags,	1✔
74	},	1✔
75	},	1✔
76	{ revalidate: false }	1✔
77	)	1✔
78	return tags	1✔
79	}	1✔
80
81	return {	6✔
82	tags: data?.article?.tags \|\| [],	6✔
83	isLoading,	6✔
84	error,	6✔
85	add,	6✔
86	remove,	6✔
87	}	6✔
88	}	6✔
89
90	export function useArticleActions({ articleId }) {	1✔
91	const sessionToken = useSelector((state) => state.sessionToken)	4✔
92	const activeUser = useSelector((state) => state.activeUser)	4✔
93	const copy = async (toUserId) => {	4✔
94	return await executeQuery({	1✔
95	query: duplicateArticle,	1✔
96	variables: {	1✔
97	user: null,	1✔
98	to: toUserId,	1✔
99	articleId,	1✔
100	},	1✔
101	sessionToken,	1✔
102	type: 'mutation',	1✔
103	})	1✔
104	}	1✔
105	const duplicate = async () => {	4✔
106	return await executeQuery({	1✔
107	query: duplicateArticle,	1✔
108	variables: {	1✔
109	user: activeUser._id,	1✔
110	to: activeUser._id,	1✔
111	articleId,	1✔
112	},	1✔
113	sessionToken,	1✔
114	type: 'mutation',	1✔
115	})	1✔
116	}	1✔
117	const rename = async (title) => {	4✔
118	return await executeQuery({	1✔
119	query: renameArticle,	1✔
120	variables: { user: activeUser._id, articleId, title },	1✔
121	sessionToken,	1✔
122	type: 'mutation',	1✔
123	})	1✔
124	}	1✔
125	const remove = async () => {	4✔
126	return await executeQuery({	1✔
127	query: deleteArticle,	1✔
128	variables: { articleId },	1✔
129	})	1✔
130	}	1✔
131
132	return {	4✔
133	copy,	4✔
134	duplicate,	4✔
135	rename,	4✔
136	remove,	4✔
137	}	4✔
138	}	4✔
139
140	export function useArticleWorkingCopy({ articleId }) {	1✔
141	const sessionToken = useSelector((state) => state.sessionToken)	×
142	const activeUser = useSelector((state) => state.activeUser)	×
143	const { data, error, mutate, isLoading } = useFetchData(	×
144	{ query: getArticleWorkingCopy, variables: { articleId } },	×
145	{	×
146	revalidateOnFocus: false,	×
147	revalidateOnReconnect: false,	×
148	}	×
149	)	×
150
151	const updateMetadata = async (metadata) => {	×
152	await executeQuery({	×
153	sessionToken,	×
154	query: updateWorkingVersion,	×
155	variables: {	×
156	userId: activeUser._id,	×
157	articleId: articleId,	×
158	content: { metadata },	×
159	},	×
160	type: 'mutate',	×
161	})	×
162	await mutate(	×
163	async (data) => {	×
164	return {	×
165	article: {	×
166	...data.article,	×
167	workingVersion: {	×
168	...data.workingVersion,	×
169	metadata: metadata,	×
170	},	×
171	},	×
172	}	×
173	},	×
174	{ revalidate: false }	×
175	)	×
176	}	×
177
178	return {	×
179	article: data?.article,	×
180	updateMetadata,	×
181	isLoading,	×
182	error,	×
183	}	×
184	}	×
185
186	export function useEditableArticle({ articleId, versionId }) {	1✔
187	const sessionToken = useSelector((state) => state.sessionToken)	×
188	const activeUser = useSelector((state) => state.activeUser)	×
189	const hasVersion = typeof versionId === 'string'	×
190	const { data, mutate, error, isLoading } = useFetchData(	×
191	{	×
192	query: getEditableArticle,	×
193	variables: {	×
194	article: articleId,	×
195	hasVersion,	×
196	version: versionId ?? '',	×
197	},	×
198	},	×
199	{	×
200	revalidateOnFocus: false,	×
201	revalidateOnReconnect: false,	×
202	fallbackData: {	×
203	article: {},	×
204	},	×
205	}	×
206	)	×
207
208	const updateBibliography = async (bib) => {	×
209	await executeQuery({	×
210	sessionToken,	×
211	query: updateWorkingVersion,	×
212	variables: {	×
213	userId: activeUser._id,	×
214	articleId: articleId,	×
215	content: { bib },	×
216	},	×
217	type: 'mutate',	×
218	})	×
219	await mutate(	×
220	async (data) => {	×
221	if (hasVersion) {	×
222	return {	×
223	article: {	×
224	...data.article,	×
225	version: {	×
226	...data.version,	×
227	bib,	×
228	},	×
229	},	×
230	}	×
231	} else {	×
232	return {	×
233	article: {	×
234	...data.article,	×
235	workingVersion: {	×
236	...data.workingVersion,	×
237	bib,	×
238	},	×
239	},	×
240	}	×
241	}	×
242	},	×
243	{ revalidate: false }	×
244	)	×
245	}	×
246
247	const updateZoteroLink = async (url) => {	×
248	await executeQuery({	×
249	sessionToken,	×
250	query: updateZoteroLinkMutation,	×
251	variables: {	×
252	articleId: articleId,	×
253	url,	×
254	},	×
255	type: 'mutate',	×
256	})	×
257	await mutate(	×
258	async (data) => {	×
259	return {	×
260	article: {	×
261	...data.article,	×
262	zoteroLink: url,	×
263	},	×
264	}	×
265	},	×
266	{ revalidate: false }	×
267	)	×
268	}	×
269
270	const bibtext = hasVersion	×
271	? (data?.article?.version?.bib ?? '')	×
272	: (data?.article?.workingVersion?.bib ?? '')	×
273
274	const entries = toEntries(bibtext)	×
275
276	return {	×
277	article: data?.article,	×
278	updateBibliography,	×
279	updateZoteroLink,	×
280	bibliography: {	×
281	bibtext,	×
282	entries,	×
283	},	×
284	isLoading,	×
285	error,	×
286	}	×
287	}	×
288
289	export function useArticleVersions({ articleId }) {	1✔
290	const { data, error, isLoading } = useFetchData(	×
291	{ query: getArticleVersions, variables: { article: articleId } },	×
292	{	×
293	revalidateOnFocus: false,	×
294	revalidateOnReconnect: false,	×
295	}	×
296	)	×
297
298	return {	×
299	error,	×
300	isLoading,	×
301	article: data?.article,	×
302	}	×
303	}	×
304
305	export function useArticleVersion({ versionId }) {	1✔
306	const { data, error, isLoading } = useConditionalFetchData(	×
307	versionId ? { query: getArticleVersion, variables: { versionId } } : null,	×
308	{	×
309	revalidateOnFocus: false,	×
310	revalidateOnReconnect: false,	×
NEW 311	fallbackData: {	×
NEW 312	version: {}	×
NEW 313	}	×
314	}	×
315	)	×
316
317	return {	×
318	error,	×
319	isLoading,	×
320	version: data?.version,	×
321	}	×
322	}	×
323
324	export function useArticleVersionActions({ articleId }) {	1✔
325	const sessionToken = useSelector((state) => state.sessionToken)	2✔
326	const activeUser = useSelector((state) => state.activeUser)	2✔
327	const { mutate } = useMutateData({	2✔
328	query: getArticleVersions,	2✔
329	variables: { article: articleId },	2✔
330	})	2✔
331	const create = async (version) => {	2✔
332	const response = await executeQuery({	1✔
333	query: createVersion,	1✔
334	variables: {	1✔
335	userId: activeUser._id,	1✔
336	articleId,	1✔
337	major: version.major,	1✔
338	message: version.description,	1✔
339	},	1✔
340	sessionToken,	1✔
341	type: 'mutation',	1✔
342	})	1✔
343	await mutate(async (data) => ({	1✔
344	article: {	1✔
345	...data?.article,	1!
346	versions: response.article.createVersion.versions,	1✔
347	},	1✔
348	}))	1✔
349	}	1✔
350	const updateDescription = async ({ versionId, description }) => {	2✔
351	await executeQuery({	1✔
352	query: renameVersion,	1✔
353	variables: {	1✔
354	version: versionId,	1✔
355	name: description,	1✔
356	},	1✔
357	sessionToken,	1✔
358	type: 'mutation',	1✔
359	})	1✔
360	await mutate(async (data) => ({	1✔
361	article: {	1✔
362	...data?.article,	1✔
363	versions: data.article.versions.map((v) => {	1✔
364	if (v._id === versionId) {	2!
365	return {	×
366	...v,	×
367	message: description,	×
368	}	×
369	}	×
370	return v	2✔
371	}),	1✔
372	},	1✔
373	}))	1✔
374	}	1✔
375
376	return {	2✔
377	create,	2✔
378	updateDescription,	2✔
379	}	2✔
380	}	2✔

EcrituresNumeriques / stylo / 15066626824

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