Merge commit '79f9c693853b697d37ec8b5e87453063a8625dbe' into staging

client/src/api/trends/_utils/variation.ts

@@ -1,9 +1,8 @@
-export default function variation(count, max_year) {
-  const startValue = count?.[max_year - 1] || 0
-  const endValue = count?.[max_year] || 0
+export default function variation(count, sum, minYear, maxYear) {
+  const currentVolume = count?.[maxYear] || 0
+  const averageVolume = (sum - currentVolume) / (maxYear - minYear - 1)
 
-  if (!startValue && !endValue) return 0
-  if (!startValue) return Infinity
+  const variation = currentVolume >= averageVolume ? currentVolume / averageVolume : -averageVolume / currentVolume
 
-  return (endValue - startValue) / startValue
+  return variation
 }

client/src/api/trends/publications.ts

@@ -1,13 +1,21 @@
 import { postHeaders, publicationsIndex } from "../../config/api"
 import { ElasticAggregation, ElasticBucket, ElasticBuckets } from "../../types/commons"
-import { TrendsArgs } from "../../types/trends"
+import { TrendsArgs, TrendsRanking } from "../../types/trends"
 import { FIELDS } from "../publications/_utils/constants"
 import { CONFIG } from "./config"
 import { citationsTrends, publicationsTrends } from "./trends"
 
 type TrendsAggregation = Array<ElasticBucket & { model: ElasticAggregation }>
 
-export async function getPublicationsTrends({ cursor, model, query, years, filters, normalized }: TrendsArgs) {
+export async function getPublicationsTrends({
+  page,
+  model,
+  query,
+  years,
+  filters,
+  normalized,
+  includes,
+}: TrendsArgs): Promise<TrendsRanking> {
   const body: any = {
     size: 0,
     query: {
@@ -30,6 +38,7 @@ export async function getPublicationsTrends({ cursor, model, query, years, filte
           model: { terms: { field: CONFIG[model].field, size: 60000 / years.length } },
         },
       },
+      count: { value_count: { field: "id.keyword" } },
     },
   }
 
@@ -47,18 +56,27 @@ export async function getPublicationsTrends({ cursor, model, query, years, filte
   }
 
   const json = await res.json()
+  const count: number = json?.aggregations?.count?.value || 0
   const aggregation: TrendsAggregation = json?.aggregations?.["years"]?.buckets
 
   if (!aggregation?.length) {
     console.error(`Elasticsearch error: no aggregation found for years ${years[0]}-${years[years.length - 1]}`)
     return null
   }
 
-  const trends = publicationsTrends(aggregation, cursor, years, normalized)
-  return trends
+  const trends = publicationsTrends(aggregation, page, years, normalized, includes)
+  return { ...trends, sourceCount: count }
 }
 
-export async function getCitationsTrends({ cursor, model, query, years, filters, normalized }: TrendsArgs) {
+export async function getCitationsTrends({
+  page,
+  model,
+  query,
+  years,
+  filters,
+  normalized,
+  includes,
+}: TrendsArgs): Promise<TrendsRanking> {
   const body: any = {
     size: 0,
     query: {
@@ -84,6 +102,7 @@ export async function getCitationsTrends({ cursor, model, query, years, filters,
           ),
         },
       },
+      count: { value_count: { field: "id.keyword" } },
     },
   }
 
@@ -101,13 +120,14 @@ export async function getCitationsTrends({ cursor, model, query, years, filters,
   }
 
   const json = await res.json()
+  const count: number = json?.aggregations?.count?.value || 0
   const aggregation: ElasticBuckets = json?.aggregations?.model?.buckets
 
   if (!aggregation?.length) {
     console.error(`Elasticsearch error: no aggregation found for years ${years[0]}-${years[years.length - 1]}`)
     return null
   }
 
-  const trends = citationsTrends(aggregation, cursor, years, normalized)
-  return trends
+  const trends = citationsTrends(aggregation, page, years, normalized, includes)
+  return { ...trends, sourceCount: count }
 }

client/src/api/trends/trends.ts

@@ -3,14 +3,15 @@ import { linearRegressionSlope } from "./_utils/regression"
 import variation from "./_utils/variation"
 
 const EXCLUDE_WORDS = [""]
-const PAGE_ITEMS = 10
+const ITEMS_PER_PAGE = 25
 
 type TrendsAggregation = Array<ElasticBucket & { [x: string]: ElasticAggregation }>
 
-function computeTrends(data: Array<any>, cursor: number, years: Array<number>, normalized: boolean) {
+function computeTrends(data: Array<any>, page: number, years: Array<number>, normalized: boolean, includes: string) {
   const maxYear = years[years.length - 1]
-  const minItems = (cursor || 0) * PAGE_ITEMS
-  const maxItems = ((cursor || 0) + 1) * PAGE_ITEMS
+  const minYear = years[0]
+  const minItems = (page - 1) * ITEMS_PER_PAGE
+  const maxItems = page * ITEMS_PER_PAGE
 
   // Filter items
   const items = data.filter(({ label }) => !EXCLUDE_WORDS.includes(label))
@@ -22,42 +23,36 @@ function computeTrends(data: Array<any>, cursor: number, years: Array<number>, n
     item.norm_slope = slope / item.sum
     item.intercept = intercept
     item.r2 = r2
-    item.diff = variation(item.count, maxYear)
+    item.variation = variation(item.count, item.sum, minYear, maxYear)
   })
 
   // Sort items by volume max year
   const sortedItems = items.sort((a, b) => (b?.count?.[maxYear] || 0) - (a?.count?.[maxYear] || 0))
 
+  // Filter labels
+  const filteredItems = sortedItems.filter(({ label }: { label: string }) => label.toLowerCase().includes(includes))
+
   // Compute top items
-  const topCount = sortedItems.slice(minItems, maxItems)
-  // const topDiff = sortedItems
-  //   .slice()
-  //   .sort((a, b) => b.diff - a.diff)
-  //   .slice(0, MAX_ITEMS)
-  // const botDiff = sortedItems
-  //   .slice()
-  //   .sort((a, b) => (b?.count?.[min_year - 1] || 0) - (a?.count?.[maxYear - 1] || 0))
-  //   .sort((a, b) => a.diff - b.diff)
-  //   .slice(0, MAX_ITEMS)
-  const topSlope = sortedItems
+  const topCount = filteredItems.slice(minItems, maxItems)
+  const topSlope = filteredItems
     .slice()
     .sort((a, b) => (normalized ? b.norm_slope - a.norm_slope : b.slope - a.slope))
     .slice(minItems, maxItems)
-  const botSlope = sortedItems
+  const botSlope = filteredItems
     .slice()
     .sort((a, b) => (normalized ? a.norm_slope - b.norm_slope : a.slope - b.slope))
     .slice(minItems, maxItems)
 
   const trends = {
-    views: {
+    ranking: {
       "count-top": topCount,
-      // "diff-top": topDiff,
-      // "diff-bot": botDiff,
       "trend-top": topSlope,
       "trend-bot": botSlope,
     },
-    nextCursor: maxItems < sortedItems.length ? cursor + 1 : undefined,
-    total: sortedItems.length,
+    searchTotal: sortedItems.length,
+    searchPages: Math.ceil(sortedItems.length / ITEMS_PER_PAGE),
+    filteredTotal: filteredItems.length,
+    filteredPages: Math.ceil(filteredItems.length / ITEMS_PER_PAGE),
   }
 
   return trends
@@ -67,7 +62,8 @@ export function publicationsTrends(
   aggregation: TrendsAggregation,
   cursor: number,
   years: Array<number>,
-  normalized: boolean
+  normalized: boolean,
+  includes: string
 ) {
   // Items count by year
   const _items: Record<string, Record<string, any>> = aggregation.reduce((acc, bucket) => {
@@ -86,11 +82,17 @@ export function publicationsTrends(
   }, {})
   const items = Object.values(_items)
 
-  const trends = computeTrends(items, cursor, years, normalized)
+  const trends = computeTrends(items, cursor, years, normalized, includes)
   return trends
 }
 
-export function citationsTrends(aggregation: ElasticBuckets, cursor: number, years: Array<number>, normalized: boolean) {
+export function citationsTrends(
+  aggregation: ElasticBuckets,
+  cursor: number,
+  years: Array<number>,
+  normalized: boolean,
+  includes: string
+) {
   // Items citations count by year
   const _items: Record<string, Record<string, any>> = aggregation.reduce((acc, item) => {
     years.forEach((year) => {
@@ -109,6 +111,6 @@ export function citationsTrends(aggregation: ElasticBuckets, cursor: number, yea
   }, {})
   const items = Object.values(_items)
 
-  const trends = computeTrends(items, cursor, years, normalized)
+  const trends = computeTrends(items, cursor, years, normalized, includes)
   return trends
 }

client/src/pages/trends/components/info/index.tsx

@@ -0,0 +1,19 @@
+import { Container, Text } from "@dataesr/dsfr-plus"
+import useTrends from "../../hooks/useTrends"
+import { useIntl } from "react-intl"
+
+export default function TrendsViewInfo() {
+  const intl = useIntl()
+  const { trends } = useTrends()
+
+  const topicsCount = trends?.searchTotal || 0
+  const publicationsCount = trends?.sourceCount || 0
+
+  return (
+    <Container>
+      <Text className="fr-mb-1w">
+        {intl.formatMessage({ id: "trends.ranking.info.text" }, { topics: topicsCount, publications: publicationsCount })}
+      </Text>
+    </Container>
+  )
+}