Merge remote-tracking branch 'origin/staging'

Author: folland87

client/nginx.conf

@@ -32,4 +32,9 @@ server {
     proxy_set_header X-Real-IP $remote_addr;
     proxy_pass https://ec.europa.eu/info/funding-tenders/opportunities/data/topicDetails/$1.json;
   }
-}
+  location ~* ^/openalex/(.*) {
+    proxy_pass https://api.openalex.org/$1$is_args$args&api_key=$OPENALEX_API_KEY;
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_ssl_server_name on;
+  }
+}

client/public/logos/sies_logo_signature.svg

@@ -0,0 +1,83 @@
+import { AggregationArgs } from "../../types/commons";
+
+import { getOpenalexUrl } from "./config";
+
+const groupBys = [
+	"publication_year",
+	"type",
+	"authorships.countries",
+	"authorships.author.id",
+	"authorships.institutions.lineage",
+	"primary_topic.id",
+	// "keywords.id",
+	"primary_location.source.id",
+	"grants.funder",
+	// "authorships.institutions.continent",
+];
+
+export async function fetchOpenAlexAggregations({ query, filters = [] }: AggregationArgs): Promise<any> {
+  console.log("fetchOpenAlexAggregations", query, filters)
+	const urls = groupBys.map((groupBy) => {
+	if (filters.length) {
+    /* @ts-expect-error unknown */
+    const yearRange: any = filters.find((el: any) => el?.range?.year)?.range?.year
+		const [yearMin, yearMax] = [yearRange?.gte, yearRange?.lte]
+		const types = filters
+      ?.find((el) => el?.terms?.["type.keyword"])
+			?.terms["type.keyword"]
+			?.map((type: string) => `types/${type}`);
+
+		const typesFilter = types?.length > 0 ? `type:${types.join("|")}` : "";
+		const yearsFilter = (yearMin && yearMax) ? `publication_year:${parseInt(yearMin)}-${parseInt(yearMax)}` : "";
+		const finalQuery= [query, typesFilter, yearsFilter].filter(Boolean).join(",")
+		console.log("finalQuery", finalQuery)
+		return getOpenalexUrl(finalQuery, groupBy);
+	}
+	return getOpenalexUrl(query, groupBy);
+	});
+
+	const responses = await Promise.all(urls.map((url) => fetch(url)));
+	const results = await Promise.all(responses.map((res) => res.json()));
+	const [
+		publicationYear,
+		publicationType,
+		authorshipsCountries,
+		authorshipsAllAuthors,
+		authorshipsAuthorsInstitutions,
+		primaryTopic,
+		// keywords,
+		primaryLocationUrl,
+		grantsFunder,
+		// authorshipsAuthorsInstitutionsContinents,
+	] = results.map((result) => {
+		const agg = result.group_by;
+
+		return agg.map((item) => ({
+			value: item.key,
+			label: item.key_display_name,
+			count: item.count,
+		}));
+	});
+	// const frenchies = authorshipsFrenchAuthors.map((item) => item.value);
+	// const authorshipsAuthors = authorshipsAllAuthors.map((item) => {
+ //    if (frenchies.includes(item.value)) {
+	// 		return {...item, label: "🇫🇷 " + item.label};
+	// 	}
+ //    return item;
+	// });
+	const total = results?.[0]?.meta?.count;
+	return {
+		total,
+		publicationYear,
+		publicationType,
+		authorshipsCountries,
+		authorshipsAuthors: authorshipsAllAuthors,
+		// authorshipsFrenchAuthors,
+		authorshipsAuthorsInstitutions,
+		primaryTopic,
+		// keywords,
+		primaryLocationUrl,
+		grantsFunder,
+		// authorshipsAuthorsInstitutionsContinents,
+	};
+}

client/src/api/openalex/analytic-tool.ts.ts

@@ -0,0 +1,6 @@
+const VITE_OPENALEX_URL = import.meta.env.VITE_OPENALEX_URL;
+
+export const OPENALEX_URL = VITE_OPENALEX_URL || '/openalex';
+
+export const getOpenalexUrl = (query: string, groupBy: string) =>
+	`${OPENALEX_URL}/works?page=1&filter=title_and_abstract.search:${query}&group_by=${groupBy}`;

client/src/api/openalex/config.ts

@@ -0,0 +1,38 @@
+import { fillWithMissingYears } from "../utils/years";
+import { getOpenalexUrl } from "./config";
+
+const groupBysFilters = [
+	"publication_year",
+	"type",
+];
+
+export async function fetchOpenFilters({
+	query
+}: {
+	query: string;
+}): Promise<any> {
+  const urls = groupBysFilters.map((groupBy) => getOpenalexUrl(query, groupBy));
+
+	const responses = await Promise.all(urls.map((url) => fetch(url)));
+	const results = await Promise.all(responses.map((res) => res.json()));
+	const years = results?.[0]?.group_by.map((item) => ({
+		value: parseInt(item.key, 10),
+		label: parseInt(item.key_display_name, 10),
+		count: item.count,
+	}))
+	const _100Year = Math.max(...years.map((el) => el.count));
+  const byYear = years.filter((element) => element.value > 1990).map((element) => {
+    return {
+      ...element,
+      normalizedCount: element.doc_count * 100 / _100Year,
+    }
+  }).sort((a, b) => a.label - b.label).reduce(fillWithMissingYears, []) || [];
+  const byType = results?.[1]?.group_by.map((item) => ({
+    value: item.key_display_name,
+    label: item.key_display_name,
+    count: item.count,
+  }));
+  console.log("byType", byType)
+
+	return { byYear, byType }
+}