Kirjoita hakukenttään julkaisun nimi, asiasana, hankkeen nimi
tai esimerkiksi organisaation nimi.
+
Hakutulosten rajaaminen onnistuu haun jälkeen hakunäkymässä.
+
Haku kohdistuu julkaisuihin, tutkijoihin, hankkeisiin, aineistoihin, rahoitushakuihin,
infrastruktuureihin ja organisaatioihin.
diff --git a/src/app/portal/components/search-bar/search-bar.component.ts b/src/app/portal/components/search-bar/search-bar.component.ts
index 6e9a7619e..7fd5ac400 100644
--- a/src/app/portal/components/search-bar/search-bar.component.ts
+++ b/src/app/portal/components/search-bar/search-bar.component.ts
@@ -201,17 +201,18 @@ export class SearchBarComponent implements OnInit, AfterViewInit, OnDestroy {
this.setCompletionWidth();
}
- fireAutoSuggest() {
- this.autoSuggestSub = this.queryField.valueChanges
- .pipe(debounceTime(1000), distinctUntilChanged())
+ fireAutoSuggest() { // TODO: Dense code warning; IS THIS DIFFERENT FROM NORMAL SEARCHES?
+ this.autoSuggestSub = this.queryField.valueChanges.pipe(debounceTime(1000), distinctUntilChanged())
.subscribe((result) => {
this.keyManager = new ActiveDescendantKeyManager(this.items)
.withWrap()
.withTypeAhead();
this.currentInput = result;
+
if (result.length > 2) {
this.topData = [];
this.otherData = [];
+
this.autoSuggestResponseSub = this.autosuggestService
.search(result)
.pipe(map((response) => [response]))
@@ -219,17 +220,18 @@ export class SearchBarComponent implements OnInit, AfterViewInit, OnDestroy {
// Sort indices with highest doc count
const arr = [];
this.autoSuggestResponse = response;
- const source =
- this.autoSuggestResponse[0].aggregations._index.buckets;
+ const source = this.autoSuggestResponse[0].aggregations._index.buckets;
+
Object.keys(source)
.sort((a, b) => source[b].doc_count - source[a].doc_count)
.forEach((key) => {
- arr.push({
+ arr.push({ // TODO: arr side-effect
index: key,
source: source[key],
translation: this.translations[key],
});
});
+
// Show hits for top 2 indices with most results
this.topData = arr.slice(0, 2);
// List other indices, filter out indices with no results
diff --git a/src/app/portal/pipes/limit.pipe.ts b/src/app/portal/pipes/limit.pipe.ts
new file mode 100644
index 000000000..6d193d56b
--- /dev/null
+++ b/src/app/portal/pipes/limit.pipe.ts
@@ -0,0 +1,20 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+ name: 'limit',
+ standalone: true
+})
+export class LimitPipe implements PipeTransform {
+ transform(value: any[], limit: number, enabled = true): any[] {
+ // Async pipes return nulls
+ if (value == null) {
+ return [];
+ }
+
+ if (enabled) {
+ return value.slice(0, limit);
+ } else {
+ return value;
+ }
+ }
+}
diff --git a/src/app/portal/portal-routing.module.ts b/src/app/portal/portal-routing.module.ts
index 6e93cfbaf..ec32aebdd 100644
--- a/src/app/portal/portal-routing.module.ts
+++ b/src/app/portal/portal-routing.module.ts
@@ -34,6 +34,7 @@ import { SingleDatasetComponent } from './components/single/single-dataset/singl
import { SingleFundingCallComponent } from './components/single/single-funding-call/single-funding-call.component';
import { SingleIndicatorComponent } from './components/science-politics/open-science-and-research-indicators/single-indicator/single-indicator.component';
import { SinglePersonComponent } from './components/single/single-person/single-person.component';
+import { Publications2Component } from '@portal/components/results/publications2/publications2.component';
// import { TkiReportsComponent } from "@portal/components/science-politics/tki-reports/tki-reports.component";
const routes: Routes = [
@@ -98,6 +99,10 @@ const routes: Routes = [
redirectTo: 'results/publications',
pathMatch: 'full',
},
+ {
+ path: 'results/publications2',
+ component: Publications2Component,
+ },
{
path: 'results/:tab',
component: ResultsComponent,
diff --git a/src/app/portal/portal.module.ts b/src/app/portal/portal.module.ts
index fd4c8a5cf..941a00f0c 100644
--- a/src/app/portal/portal.module.ts
+++ b/src/app/portal/portal.module.ts
@@ -166,6 +166,7 @@ import { CheckEmptyFieldsPipe } from './pipes/check-empty-fields.pipe';
import { PersonGroupComponent } from './components/single/single-person/person-group/person-group.component';
import { PersonGroupAdditionalComponent } from './components/single/single-person/person-group-additional/person-group-additional.component';
import { FooterComponent } from '../layout/footer/footer.component';
+import { SearchBar2Component } from '@portal/search-bar2/search-bar2.component';
import { FixExternalUrlPipe } from '@portal/pipes/fix-external-url.pipe';
@NgModule({
@@ -289,6 +290,7 @@ import { FixExternalUrlPipe } from '@portal/pipes/fix-external-url.pipe';
MatTableModule,
MatSortModule,
FooterComponent,
+ SearchBar2Component,
FixExternalUrlPipe
],
exports: [DatasetAuthorComponent, FiltersComponent],
diff --git a/src/app/portal/search-bar2/search-bar2.component.html b/src/app/portal/search-bar2/search-bar2.component.html
new file mode 100644
index 000000000..fbfc672b0
--- /dev/null
+++ b/src/app/portal/search-bar2/search-bar2.component.html
@@ -0,0 +1,36 @@
+
+
+
+
+
+
+
+
+ Hae
+
+
+
+
+ Hakuohje
+
+
+
+
diff --git a/src/app/portal/search-bar2/search-bar2.component.scss b/src/app/portal/search-bar2/search-bar2.component.scss
new file mode 100644
index 000000000..8d0a524de
--- /dev/null
+++ b/src/app/portal/search-bar2/search-bar2.component.scss
@@ -0,0 +1,112 @@
+.search-input {
+ width: 510px;
+ height: 55px;
+
+ border-top-right-radius: 4px;
+ border-bottom-right-radius: 4px;
+ border-width: 0;
+
+ font-size: 25px;
+
+ padding: 1px 44px 1px 16px;
+}
+
+input[placeholder] {
+ text-overflow: ellipsis;
+ white-space: nowrap;
+ overflow: hidden;
+}
+
+::placeholder {
+ font-size: 17px;
+ font-style: normal;
+}
+
+/*! CSS Used from: Embedded */
+*, *:before, *:after {
+ box-sizing: border-box;
+}
+
+body:not(.user-tabbing) *:focus {
+ outline: none;
+}
+
+*, *:before, *:after {
+ box-sizing: inherit;
+}
+
+/*! CSS Used from: https://tiedejatutkimus.fi/fi/styles.cdbf57794ce87ed1.css */
+*, *:before, *:after {
+ box-sizing: border-box;
+}
+
+input {
+ margin: 0;
+ font-family: inherit;
+ font-size: inherit;
+ line-height: inherit;
+}
+
+[type=search] {
+ outline-offset: -2px;
+ -webkit-appearance: textfield;
+}
+
+.row > * {
+ flex-shrink: 0;
+ width: 100%;
+ max-width: 100%;
+ padding-right: calc(var(--bs-gutter-x) * .5);
+ padding-left: calc(var(--bs-gutter-x) * .5);
+ margin-top: var(--bs-gutter-y);
+}
+
+.col-10 {
+ flex: 0 0 auto;
+ width: 83.33333333%;
+}
+
+@media (min-width: 576px) {
+ .col-sm-12 {
+ flex: 0 0 auto;
+ width: 100%;
+ }
+}
+
+body:not(.user-tabbing) input:focus, body:not(.user-tabbing) *:focus {
+ outline: none;
+}
+
+*, *:before, *:after {
+ box-sizing: inherit;
+}
+
+body app-search-bar .search-input input {
+ color: #495057 !important;
+}
+
+/*! CSS Used from: Embedded */
+app-search-bar input#searchInput {
+ border-top-right-radius: .25rem !important;
+ border-bottom-right-radius: .25rem !important;
+}
+
+app-search-bar .search-input input {
+ text-overflow: ellipsis;
+ white-space: nowrap;
+ overflow: hidden;
+ border: none;
+ padding-right: 2.75rem;
+}
+
+app-search-bar input {
+ z-index: 102;
+}
+
+
+
+@media (max-width: 768px) {
+ app-search-bar input#searchInput {
+ border-radius: .25rem !important;
+ }
+}
diff --git a/src/app/portal/search-bar2/search-bar2.component.ts b/src/app/portal/search-bar2/search-bar2.component.ts
new file mode 100644
index 000000000..10fe119c5
--- /dev/null
+++ b/src/app/portal/search-bar2/search-bar2.component.ts
@@ -0,0 +1,29 @@
+import { Component, EventEmitter, inject, Input, Output } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { MatRippleModule } from '@angular/material/core';
+import { FormsModule } from '@angular/forms';
+import { ActivatedRoute, Router } from '@angular/router';
+
+@Component({
+ selector: 'app-search-bar2',
+ standalone: true,
+ imports: [CommonModule, MatRippleModule, FormsModule],
+ templateUrl: './search-bar2.component.html',
+ styleUrls: ['./search-bar2.component.scss']
+})
+export class SearchBar2Component {
+ route = inject(ActivatedRoute);
+ router = inject(Router)
+
+ // two-way "value" binding that's a string; basically text input
+ @Input() value = "";
+ @Output() valueChange = new EventEmitter
();
+
+ // search is pressed output
+ @Output() search = new EventEmitter();
+
+ // instruction button is pressed output
+ @Output() instructions = new EventEmitter();
+
+ public keywords = this.route.snapshot.queryParams.q ?? "";
+}
diff --git a/src/app/portal/services/publication2.service.ts b/src/app/portal/services/publication2.service.ts
new file mode 100644
index 000000000..f9b721026
--- /dev/null
+++ b/src/app/portal/services/publication2.service.ts
@@ -0,0 +1,1226 @@
+import { inject, Injectable, LOCALE_ID, OnInit, SecurityContext } from '@angular/core';
+// import { object, Output, parse, string } from 'valibot';
+import { BehaviorSubject, forkJoin, Observable, of, shareReplay } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { map, switchMap, take, tap } from 'rxjs/operators';
+import { ActivatedRoute } from '@angular/router';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+
+import { locale } from "../../../environments/locale";
+const path = suffixer(locale);
+
+/*const PublicationSearchSchema = object({
+ publicationId: string(),
+ title: string(),
+});*/
+
+type TODO = any;
+type PublicationSearch = TODO; // Output;
+
+// function that validates API response into a PublicationSearch
+function parsePublicationSearch(data: TODO): PublicationSearch {
+ return data;
+ // return parse(PublicationSearchSchema, data);
+}
+
+// export interface HighlightedPublication {
+export type HighlightedPublication = {
+ id: string;
+ publicationName: SafeHtml;
+ authorsText: SafeHtml;
+ publisherName: SafeHtml;
+ publicationYear: SafeHtml;
+
+ badges: {
+ doi?: string;
+ peerReviewed?: boolean;
+ openAccess?: string;
+ };
+}
+
+type CachedPublicationSearch = {
+ keywords: string,
+ publicationSearch: PublicationSearch,
+}
+
+export type SearchParams = {
+ q?: string[],
+ page?: string[],
+ size?: string[],
+ sort?: string[],
+
+ year?: string[],
+ organization?: string[],
+
+ language?: string[],
+ format?: string[],
+ audience?: string[],
+ peerReviewed?: string[],
+
+ // new terms
+ parentPublicationType?: string[],
+ international?: string[],
+ articleType?: string[],
+ jufo?: string[],
+
+ // placeholders
+ publicationTypeCode?: string[],
+ publicationStatusCode?: string[],
+
+ fieldsOfScience?: string[],
+
+ openAccess?: string[],
+ publisherOpenAccessCode?: string[],
+ selfArchivedCode?: string[],
+}
+
+@Injectable({
+ providedIn: 'root'
+})
+export class Publication2Service {
+ http = inject(HttpClient);
+ sanitizer = inject(DomSanitizer);
+ locale = inject(LOCALE_ID);
+
+ searchUrl = 'https://researchfi-api-qa.rahtiapp.fi/portalapi/publication/_search?'
+
+ searchParams = new BehaviorSubject({});
+
+ searchResults$: Observable = this.searchParams.pipe(
+ switchMap(searchParams => this.searchPublications(searchParams)),
+ tap((data) => console.log("searchPublications", data)),
+ shareReplay({ bufferSize: 1, refCount: true })
+ );
+
+ resultsTotal$ = this.searchResults$.pipe(
+ map((data) => data.hits.total.value)
+ );
+
+ publicationSearch$: Observable = this.searchResults$.pipe(
+ map((data) => parsePublicationSearch(data)),
+ map((publicationSearch: PublicationSearch) => this.createHighlightedPublications(publicationSearch))
+ );
+
+ publicationAggregations$ = this.searchResults$.pipe(
+ map((data) => data.aggregations)
+ );
+
+ getSearch() {
+ return this.publicationSearch$;
+ }
+
+ getTotal() {
+ return this.resultsTotal$;
+ }
+
+ getAggregations() {
+ return this.publicationAggregations$;
+ }
+
+ updateSearchTerms(searchParams: SearchParams): void {
+ this.searchParams.next(searchParams);
+ }
+
+ private searchPublications(searchParams: SearchParams): Observable {
+ const q = searchParams.q?.[0] ?? "";
+ const page = parseInt(searchParams.page?.[0] ?? "1");
+ const size = parseInt(searchParams.size?.[0] ?? "10");
+ const from = (page - 1) * size;
+
+ // Settings for highlighting in ElasticSearch
+ const largeHighlight = { fragment_size: 200, number_of_fragments: 15 };
+
+ return this.http.post(this.searchUrl, {
+ from: from,
+ size: size,
+ track_total_hits: true,
+ sort: [
+ ...sortingTerms(searchParams)
+ ],
+ query: {
+ bool: {
+ must: {
+ ...matchingTerms(searchParams)
+ },
+ filter: {
+ bool: {
+ must: [
+ ...filteringTerms(searchParams),
+ ]
+ }
+ }
+ },
+ },
+ highlight: {
+ fields: {
+ publicationName: { ...largeHighlight },
+ authorsText: { ...largeHighlight, type: "plain" },
+ publisherName: { ...largeHighlight }
+ },
+ pre_tags: [""],
+ post_tags: [" "]
+ },
+ aggregations: {
+ ...aggregationTerms(searchParams),
+ }
+ });
+ }
+
+ // sort column?
+ // sort=foo OR fooDesc
+
+ createHighlightedPublications(searchData: PublicationSearch): HighlightedPublication[] {
+ return searchData.hits.hits.map((hit: any/*ES doc for Publication*/) => this.createHighlightedPublication(hit));
+ }
+
+ createHighlightedPublication(searchData: any/*ES doc for Publication*/): HighlightedPublication {
+ const source = searchData._source;
+ const highlight = searchData.highlight;
+
+ /*const badgesExist = {
+ doi: source.doi != null || source.doiHandle != null,
+ peerReviewed: source.peerReviewed?.id === 1 ?? false,
+ openAccess: source.openAccess === 1
+ }*/
+
+ // badges are keys values with strings to strings
+
+
+ const badges: {
+ doi?: string;
+ peerReviewed?: boolean;
+ openAccess?: string;
+ } = {};
+
+ badges.doi = source.doi;
+ badges.openAccess = source.doiHandle;
+ badges.peerReviewed = source.peerReviewed[0].id === "1";
+
+ const publicationName = highlight?.publicationName?.join() ?? source.publicationName ?? '';
+ const authorsText = highlight?.authorsText?.join() ?? source.authorsText ?? '';
+ const publisherName = highlight?.publisherName?.join() ?? source.publisherName ?? '';
+ const publicationYear = highlight?.publicationYear?.join() ?? source.publicationYear ?? '';
+
+ return {
+ id: searchData._id,
+ publicationName: this.sanitizer.sanitize(SecurityContext.HTML, publicationName),
+ authorsText: this.sanitizer.sanitize(SecurityContext.HTML, authorsText),
+ publisherName: this.sanitizer.sanitize(SecurityContext.HTML, publisherName),
+ publicationYear: this.sanitizer.sanitize(SecurityContext.HTML, publicationYear),
+
+ badges: badges
+ };
+ }
+
+ getOrganizationNames(): Observable> {
+ const organizationNamesBySector = (sectorId: number) => ({
+ 'size': 0,
+ 'aggs': {
+ 'filtered_authors': {
+ 'nested': {
+ 'path': 'author'
+ },
+ 'aggs': {
+ 'single_sector': {
+ 'filter': {
+ 'term': {
+ 'author.sectorId': `${sectorId}`
+ }
+ },
+ 'aggs': {
+ 'organizations': {
+ 'nested': {
+ 'path': 'author.organization'
+ },
+ 'aggs': {
+ 'composite_orgs': {
+ 'composite': {
+ 'size': 65536,
+ 'sources': [
+ { 'id': { 'terms': { 'field': 'author.organization.organizationId.keyword' } } },
+ { 'name': { 'terms': { 'field': path`author.organization.OrganizationNameFi.keyword` } } } // TODO path template needed
+ ]
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ });
+
+ const sectorIds = [1, 2, 3, 4, /*5,*/ 6];
+
+ const responses$ = sectorIds.map((sectorId) => {
+ return this.http.post(this.searchUrl, organizationNamesBySector(sectorId)).pipe(
+ map((res) => getOrganizationNameBuckets(res).map((bucket) => [bucket.key.id, {name: bucket.key.name, sectorId}])),
+ );
+ });
+
+ return forkJoin(responses$)
+ .pipe(map(responses => responses.flat()))
+ .pipe(map(pairs => Object.fromEntries(pairs)))
+ .pipe(shareReplay({ bufferSize: 1, refCount: true }));
+ }
+
+ getLanguageCodeNames(): Observable> {
+ const body = {
+ 'size': 0,
+ 'aggs': {
+ 'composite_pairs': {
+ 'composite': {
+ 'size': 1000,
+ 'sources': [
+ { 'id': { 'terms': { 'field': 'languages.languageCode.keyword' } } },
+ { 'nameFiLanguage': { 'terms': { 'field': path`languages.languageFi.keyword` } } } // TODO: does the key need to be localized? // TODO remove "fi" ?
+ ]
+ }
+ }
+ }
+ };
+
+ type LanguageAggregation = {
+ aggregations: {
+ composite_pairs: {
+ buckets: Array<{
+ key: {
+ id: string;
+ nameFiLanguage: string;
+ };
+ doc_count: number;
+ }>;
+ };
+ };
+ };
+
+ const response$ = this.http.post(this.searchUrl, body);
+
+ return response$.pipe(
+ map((res) => res.aggregations.composite_pairs.buckets.map((bucket) => [bucket.key.id, bucket.key.nameFiLanguage])), // TODO localized path needed
+ map(pairs => Object.fromEntries(pairs)),
+ shareReplay({ bufferSize: 1, refCount: true })
+ );
+ }
+
+ getPublicationFormatNames(): Observable> {
+ const body = {
+ 'size': 0,
+ 'aggs': {
+ 'composite_pairs': {
+ 'composite': {
+ 'size': 1000,
+ 'sources': [
+ { 'id': { 'terms': { 'field': 'publicationFormat.id.keyword' } } },
+ { 'nameFiFormat': { 'terms': { 'field': path`publicationFormat.nameFiPublicationFormat.keyword` } } } // TODO Does the key need to be localized? // TODO remove "fi" ?
+ ]
+ }
+ }
+ }
+ };
+
+ type PublicationFormatAggregation = {
+ aggregations: {
+ composite_pairs: {
+ buckets: Array<{
+ key: {
+ id: string;
+ nameFiFormat: string;
+ };
+ doc_count: number;
+ }>;
+ };
+ };
+ };
+
+ const response$ = this.http.post(this.searchUrl, body);
+
+ return response$.pipe(
+ map((res) => res.aggregations.composite_pairs.buckets.map((bucket) => [bucket.key.id, bucket.key.nameFiFormat])), // TODO localized path needed
+ map(pairs => Object.fromEntries(pairs)),
+ shareReplay({ bufferSize: 1, refCount: true })
+ );
+ }
+
+ getPublicationAudienceNames(): Observable> {
+ const body = {
+ 'size': 0,
+ 'aggs': {
+ 'composite_pairs': {
+ 'composite': {
+ 'size': 1000,
+ 'sources': [
+ { 'id': { 'terms': { 'field': 'publicationAudience.id.keyword' } } },
+ { 'nameFiAudience': { 'terms': { 'field': path`publicationAudience.nameFiPublicationAudience.keyword` } } } // TODO Does the key need to be localized? // TODO remove "fi" ?
+ ]
+ }
+ }
+ }
+ };
+
+ type PublicationAudienceAggregation = {
+ aggregations: {
+ composite_pairs: {
+ buckets: Array<{
+ key: {
+ id: string;
+ nameFiAudience: string;
+ };
+ doc_count: number;
+ }>;
+ };
+ };
+ };
+
+ const response$ = this.http.post(this.searchUrl, body);
+
+ return response$.pipe(
+ map((res) => res.aggregations.composite_pairs.buckets.map((bucket) => [bucket.key.id, bucket.key.nameFiAudience])), // TODO localized path needed
+ map(pairs => Object.fromEntries(pairs)),
+ shareReplay({ bufferSize: 1, refCount: true })
+ );
+ }
+
+ getParentPublicationTypeNames(): Observable> {
+ const body = {
+ "size": 0,
+ "aggs": {
+ "composite_pairs": {
+ "composite": {
+ "size": 1000,
+ "sources": [
+ { "id": { "terms": { "field": "parentPublicationType.id.keyword" } } },
+ { "nameFiParentPublicationType": { "terms": { "field": path`parentPublicationType.nameFiParentPublicationType.keyword` } } } // TODO Does the key need to be localized? // TODO remove "fi" ?
+ ]
+ }
+ }
+ }
+ }
+
+ type ParentPublicationTypeAggregation = {
+ aggregations: {
+ composite_pairs: {
+ buckets: Array<{
+ key: {
+ id: string;
+ nameFiParentPublicationType: string;
+ };
+ doc_count: number;
+ }>;
+ };
+ };
+ };
+
+ const response$ = this.http.post(this.searchUrl, body);
+
+ return response$.pipe(
+ map((res) => res.aggregations.composite_pairs.buckets.map((bucket) => [bucket.key.id, bucket.key.nameFiParentPublicationType])), // TODO localized path needed
+ map(pairs => Object.fromEntries(pairs)),
+ shareReplay({ bufferSize: 1, refCount: true })
+ );
+ }
+
+ getPeerReviewedNames(): Observable> {
+ return of({
+ "0": $localize`:@@notPeerReviewed:Ei-vertaisarvioitu`, // TODO does not exist in localization file
+ "1": $localize`:@@peerReviewed:Vertaisarvioitu`
+ });
+ }
+
+ getInternationalPublicationNames(): Observable> {
+ return of({
+ "0": $localize`:@@domesticPublication:Kotimainen julkaisu`,
+ "1": $localize`:@@internationalPublication:Kansainvälinen julkaisu`
+ });
+ }
+
+ getArticleTypeCodeNames(): Observable> {
+ return of({
+ "0": $localize`:@@journal:Lehti`,
+ "1": $localize`:@@researchBook:Kokoomateos`,
+ "2": $localize`:@@Conference:Konferenssi`,
+ "3": $localize`:@@onlinePlatform:Verkkoalusta`
+ });
+ }
+
+ getFieldsOfScienceNames(): Observable> {
+ const body = {
+ "size": 0,
+ "aggs": {
+ "fieldsOfScience_nested": {
+ "nested": {
+ "path": "fieldsOfScience"
+ },
+ "aggs": {
+ "composite_field_of_science": {
+ "composite": {
+ "size": 65536,
+ "sources": [
+ {
+ "id": {
+ "terms": {
+ "field": "fieldsOfScience.fieldIdScience"
+ }
+ }
+ },
+ {
+ "name": {
+ "terms": {
+ 'field': path`fieldsOfScience.nameFiScience.keyword` // TODO localized path needed
+ }
+ }
+ }
+ ]
+ }
+ }
+ }
+ }
+ }
+ };
+
+ type FieldsOfScienceAggregation = {
+ aggregations: {
+ fieldsOfScience_nested: {
+ composite_field_of_science: {
+ buckets: Array<{
+ key: {
+ id: string;
+ name: string;
+ };
+ doc_count: number;
+ }>;
+ };
+ };
+ };
+ };
+
+ const response$ = this.http.post(this.searchUrl, body);
+
+ return response$.pipe(
+ map((res) => res.aggregations.fieldsOfScience_nested.composite_field_of_science.buckets.map((bucket) => [bucket.key.id, bucket.key.name])),
+ map(pairs => Object.fromEntries(pairs)),
+ shareReplay({ bufferSize: 1, refCount: true })
+ );
+ }
+
+ getPublicationTypeCodeNames(): Observable> {
+ const labels = [
+ { value: `A`, name: $localize`:@@publicationClassA:Vertaisarvioidut tieteelliset artikkelit` },
+ { value: `A1`, name: $localize`:@@publicationClassA1:Alkuperäisartikkeli tieteellisessä aikakauslehdessä` },
+ { value: `A2`, name: $localize`:@@publicationClassA2:Katsausartikkeli tieteellisessä aikakauslehdessä` },
+ { value: `A3`, name: $localize`:@@publicationClassA3:Kirjan tai muun kokoomateoksen osa` },
+ { value: `A4`, name: $localize`:@@publicationClassA4:Artikkeli konferenssijulkaisussa` },
+ { value: `B`, name: $localize`:@@publicationClassB:Vertaisarvioimattomat tieteelliset kirjoitukset` },
+ { value: `B1`, name: $localize`:@@publicationClassB1:Kirjoitus tieteellisessä aikakausilehdessä` },
+ { value: `B2`, name: $localize`:@@publicationClassB2:Kirjan tai muun kokoomateoksen osa` },
+ { value: `B3`, name: $localize`:@@publicationClassB3:Vertaisarvioimaton artikkeli konferenssijulkaisussa` },
+ { value: `C`, name: $localize`:@@publicationClassC:Tieteelliset kirjat` },
+ { value: `C1`, name: $localize`:@@publicationClassC1:Kustannettu tieteellinen erillisteos` },
+ { value: `C2`, name: $localize`:@@publicationClassC2:Toimitettu kirja, kokoomateos, konferenssijulkaisu tai lehden erikoisnumero` },
+ { value: `D`, name: $localize`:@@publicationClassD:Ammattiyhteisölle suunnatut julkaisut` },
+ { value: `D1`, name: $localize`:@@publicationClassD1:Artikkeli ammattilehdessä` },
+ { value: `D2`, name: $localize`:@@publicationClassD2:Artikkeli ammatillisessa kokoomateoksessa` },
+ { value: `D3`, name: $localize`:@@publicationClassD3:Artikkeli ammatillisessa konferenssijulkaisussa` },
+ { value: `D4`, name: $localize`:@@publicationClassD4:Julkaistu kehittämis- tai tutkimusraportti taikka -selvitys` },
+ { value: `D5`, name: $localize`:@@publicationClassD5:Ammatillinen kirja` },
+ { value: `D6`, name: $localize`:@@publicationClassD6:Toimitettu ammatillinen teos` },
+ { value: `E`, name: $localize`:@@publicationClassE:Suurelle yleisölle suunnatut julkaisut` },
+ { value: `E1`, name: $localize`:@@publicationClassE1:Yleistajuinen artikkeli, sanomalehtiartikkeli` },
+ { value: `E2`, name: $localize`:@@publicationClassE2:Yleistajuinen monografia` },
+ { value: `E3`, name: $localize`:@@publicationClassE3:Toimitettu yleistajuinen teos` },
+ { value: `F`, name: $localize`:@@publicationClassF:Julkinen taiteellinen ja taideteollinen toiminta` },
+ { value: `F1`, name: $localize`:@@publicationClassF1:Itsenäinen teos tai esitys` },
+ { value: `F2`, name: $localize`:@@publicationClassF2:Taiteellisen teoksen tai esityksen osatoteutus` },
+ { value: `F3`, name: $localize`:@@publicationClassF3:Ei-taiteellisen julkaisun taiteellinen osa` },
+ { value: `G`, name: $localize`:@@publicationClassG:Opinnäytteet` },
+ { value: `G1`, name: $localize`:@@publicationClassG1:Ammattikorkeakoulututkinnon opinnäytetyö, kandidaatintyö` },
+ { value: `G2`, name: $localize`:@@publicationClassG2:Pro gradu, diplomityö, ylempi amk-opinnäytetyö` },
+ { value: `G3`, name: $localize`:@@publicationClassG3:Lisensiaatintyö` },
+ { value: `G4`, name: $localize`:@@publicationClassG4:Monografiaväitöskirja` },
+ { value: `G5`, name: $localize`:@@publicationClassG5:Artikkeliväitöskirja` },
+ { value: `H`, name: $localize`:@@publicationClassH:Patentit ja keksintöilmoitukset` },
+ { value: `H1`, name: $localize`:@@publicationClassH1:Myönnetty patentti` },
+ { value: `H2`, name: $localize`:@@publicationClassH2:Keksintöilmoitus` },
+ { value: `I`, name: $localize`:@@publicationClassI:Audiovisuaaliset julkaisut ja tieto- ja viestintätekniset sovellukset` },
+ { value: `I1`, name: $localize`:@@publicationClassI1:Audiovisuaaliset julkaisut` },
+ { value: `I2`, name: $localize`:@@publicationClassI2:Tieto- ja viestintätekniset sovellukset` }
+ ];
+
+ // Turn into key value object
+ const lookup = labels.reduce((acc, label) => {
+ acc[label.value] = label.name;
+ return acc;
+ });
+
+ return of({
+ ...lookup
+ });
+ }
+
+ getOpenAccessNames(): Observable> {
+ return of({
+ "0": $localize`:@@publication2.openAccess.No:Ei avoin`,
+ "1": $localize`:@@publication2.openAccess.Yes:Avoimesti saatavilla`,
+ "9": $localize`:@@publication2.openAccess.Unknown:Ei tietoa`
+ });
+ }
+
+ getPublisherOpenAccessNames(): Observable> {
+ return of({
+ "1": $localize`:@@publication2.publisherOpenAccess.fullyOpen:Kokonaan avoin julkaisukanava`,
+ "2": $localize`:@@publication2.publisherOpenAccess.partiallyOpen:Osittain avoin julkaisukanava`,
+ "3": $localize`:@@publication2.publisherOpenAccess.delayedOpen:Viivästetysti avoin julkaisukanava`,
+ "0": $localize`:@@publication2.publisherOpenAccess.Unspecified:Ei vastausta`,
+ // "9": $localize`:@@publication2.publisherOpenAccess.Unknown:Ei tietoa`
+ });
+ }
+
+ getSelfArchivedCodeNames(): Observable> {
+ return of({
+ "1": $localize`:@@publication2.selfArchived.Yes:Rinnakkaistallennettu`,
+ "0": $localize`:@@publication2.selfArchived.No:Ei rinnakkaistallennettu`,
+ " ": $localize`:@@publication2.selfArchived.Unknown:Ei tietoa`
+ });
+
+ }
+}
+
+function escapeLastQuoteIfOdd(inputString: string): string {
+ // Count the number of quotation marks in the string
+ const quoteCount = (inputString.match(/"/g) || []).length;
+
+ // If the count is odd, escape the last quotation mark
+ if (quoteCount % 2 !== 0) {
+ const lastQuoteIndex = inputString.lastIndexOf('"');
+ // Replace the last quotation mark with an escaped version
+ inputString = inputString.substring(0, lastQuoteIndex) + '\\"' + inputString.substring(lastQuoteIndex + 1);
+ }
+
+ return inputString;
+}
+
+function matchingTerms(searchParams: SearchParams) {
+ let q = (searchParams.q ?? [""])[0];
+ q = escapeLastQuoteIfOdd(q);
+
+ if (q === "") {
+ return {
+ match_all: {}
+ };
+ }
+
+ return {
+ query_string: {
+ query: q,
+ fields: ["publicationName", "authorsText", "publisherName"],
+ default_operator: "OR"
+ }
+ };
+}
+
+function termsForYear(searchParams: SearchParams) {
+ if (searchParams.year) {
+ return [{
+ terms: {
+ "publicationYear": searchParams.year
+ }
+ }];
+ }
+ return [];
+}
+
+function termsForTypeCode(searchParams: SearchParams) {
+ if (searchParams.publicationTypeCode) {
+ return [{
+ terms: {
+ "publicationTypeCode.keyword": searchParams.publicationTypeCode
+ }
+ }];
+ }
+ return [];
+}
+
+function termsForStatusCode(searchParams: SearchParams) {
+ if (searchParams.publicationStatusCode) {
+ return [{
+ terms: {
+ "publicationStatusCode.keyword": searchParams.publicationStatusCode
+ }
+ }];
+ }
+ return [];
+}
+
+function termsForLanguageCode(searchParams: SearchParams) {
+ if (searchParams.language) {
+ return [{
+ terms: {
+ "languages.languageCode.keyword": searchParams.language
+ }
+ }];
+ }
+ return [];
+}
+
+function termsForPublicationFormat(searchParams: SearchParams) {
+ if (searchParams.format) {
+ return [{
+ terms: {
+ "publicationFormat.id.keyword": searchParams.format
+ }
+ }];
+ }
+ return [];
+}
+
+function termsForPublicationAudience(searchParams: SearchParams) {
+ if (searchParams.audience) {
+ return [{
+ terms: {
+ "publicationAudience.id.keyword": searchParams.audience
+ }
+ }];
+ }
+ return [];
+}
+
+function termsForPeerReviewed(searchParams: SearchParams) {
+ if (searchParams.peerReviewed) {
+ return [{
+ terms: {
+ "peerReviewed.id.keyword": searchParams.peerReviewed
+ }
+ }];
+ }
+ return [];
+}
+
+function termsForParentPublicationType(searchParams: SearchParams) {
+ if (searchParams.parentPublicationType) {
+ return [{
+ terms: {
+ "parentPublicationType.id.keyword": searchParams.parentPublicationType
+ }
+ }];
+ }
+ return [];
+}
+
+function termsForInternationalPublication(searchParams: SearchParams) {
+ if (searchParams.international) {
+ return [{
+ terms: {
+ "internationalPublication": searchParams.international
+ }
+ }];
+ }
+ return [];
+}
+
+function termsForArticleTypeCode(searchParams: SearchParams) {
+ if (searchParams.articleType) {
+ return [{
+ terms: {
+ "articleTypeCode": searchParams.articleType
+ }
+ }];
+ }
+ return [];
+}
+
+function termsForJufoClassCode(searchParams: SearchParams) {
+ if (searchParams.jufo) {
+ return [{
+ terms: {
+ "jufoClassCode.keyword": searchParams.jufo
+ }
+ }];
+ }
+ return [];
+}
+
+function generateAggregationStep(name: SearchParamKey, lookup: Record) {
+ const fieldPath = lookup[name].fieldPath;
+
+ const fieldName = lookup[name].fieldName; // TODO: "fieldName" is just redundant
+ const topLevelPath = `top_level_${fieldName}`; // TODO: Use the established SearchParamKey and arbitary fieldPath
+ const middleLevelPath = `filtered_except_${fieldName}`; //
+ const bottomLevelPath = `all_${fieldName}`; //
+
+ function getAdditions(searchParams: SearchParams) {
+ const global = searchParams[name] != null
+
+ if (global) {
+ // console.log("global", name);
+
+ return {
+ [topLevelPath]: {
+ global: {},
+ aggregations: {
+ [middleLevelPath]: {
+ filter: {
+ bool: {
+ must: [
+ ...additionFilterTerms(name, searchParams)
+ ]
+ }
+ },
+ aggregations: {
+ [bottomLevelPath]: {
+ terms: {
+ field: fieldPath,
+ size: 100
+ }
+ }
+ }
+ }
+ }
+ }
+ };
+ } else {
+ // console.log("local", name);
+
+ return {
+ [topLevelPath]: {
+ filter: {
+ bool: {
+ must: [
+ ...additionFilterTerms(name, searchParams)
+ ]
+ }
+ },
+ aggregations: {
+ [bottomLevelPath]: {
+ terms: {
+ field: fieldPath,
+ size: 100
+ }
+ }
+ }
+ }
+ };
+ }
+ }
+
+ function getBuckets(aggregations: any) {
+ if (aggregations == null) {
+ return [];
+ }
+
+ if (aggregations[topLevelPath]?.[middleLevelPath]?.[bottomLevelPath]?.buckets) {
+ return aggregations[topLevelPath][middleLevelPath][bottomLevelPath].buckets;
+ }
+ else if (aggregations[topLevelPath]?.[bottomLevelPath]?.buckets) {
+ return aggregations[topLevelPath][bottomLevelPath].buckets;
+ } else {
+ return [];
+ }
+ }
+
+ return [getAdditions, getBuckets];
+}
+
+type SearchParamKey = Exclude;
+
+const lookup: Record = {
+ year: {fieldName: "publicationYear", fieldPath: "publicationYear"},
+ language: {fieldName: "languages", fieldPath: "languages.languageCode.keyword"},
+ format: {fieldName: "publicationFormat", fieldPath: "publicationFormat.id.keyword"},
+ audience: {fieldName: "publicationAudience", fieldPath: "publicationAudience.id.keyword"},
+ peerReviewed: {fieldName: "peerReviewed", fieldPath: "peerReviewed.id.keyword"},
+ parentPublicationType: {fieldName: "parentPublicationType", fieldPath: "parentPublicationType.id.keyword"},
+ international: {fieldName: "internationalPublication", fieldPath: "internationalPublication"},
+ articleType: {fieldName: "articleTypeCode", fieldPath: "articleTypeCode"},
+ jufo: {fieldName: "jufoClassCode", fieldPath: "jufoClassCode.keyword"},
+ publicationTypeCode: {fieldName: "publicationTypeCode", fieldPath: "publicationTypeCode.keyword"},
+ publicationStatusCode: {fieldName: "publicationStatusCode", fieldPath: "publicationStatusCode.keyword"},
+ fieldsOfScience: {fieldName: "fieldsOfScience", fieldPath: "fieldsOfScience.fieldIdScience"},
+ openAccess: {fieldName: "openAccess", fieldPath: "openAccess"},
+ publisherOpenAccessCode: {fieldName: "publisherOpenAccessCode", fieldPath: "publisherOpenAccessCode"},
+ selfArchivedCode: {fieldName: "selfArchivedCode", fieldPath: "selfArchivedCode.keyword"},
+ organization: {fieldName: "organization", fieldPath: "author.organization.organizationId.keyword"},
+}
+
+const [additionsFromYear, getYearAdditions] = generateAggregationStep("year", lookup);
+export { getYearAdditions };
+
+const [additionsFromLanguageCode, getLanguageCodeAdditions] = generateAggregationStep("language", lookup);
+export { getLanguageCodeAdditions };
+
+const [additionsFromPublicationFormat, getPublicationFormatAdditions] = generateAggregationStep("format", lookup);
+export { getPublicationFormatAdditions };
+
+const [additionsFromPublicationAudience, getPublicationAudienceAdditions] = generateAggregationStep("audience", lookup);
+export { getPublicationAudienceAdditions };
+
+const [additionsFromPeerReviewed, getPeerReviewedAdditions] = generateAggregationStep("peerReviewed", lookup);
+export { getPeerReviewedAdditions };
+
+const [additionsFromParentPublicationType, getParentPublicationTypeAdditions] = generateAggregationStep("parentPublicationType", lookup);
+export { getParentPublicationTypeAdditions };
+
+const [additionsFromInternationalPublication, getPublisherInternationalityAdditions] = generateAggregationStep("international", lookup);
+export { getPublisherInternationalityAdditions };
+
+const [additionsFromArticleTypeCode, getArticleTypeCodeAdditions] = generateAggregationStep("articleType", lookup);
+export { getArticleTypeCodeAdditions };
+
+const [additionsFromJufoClassCode, getJufoClassCodeAdditions] = generateAggregationStep("jufo", lookup);
+export { getJufoClassCodeAdditions };
+
+function suffixer(locale) {
+ const capitalized = locale.charAt(0).toUpperCase() + locale.slice(1).toLowerCase();
+ return strings => strings[0].replace(/(Fi|Sv|En)(?=[\.A-Z]|$)/g, capitalized);
+}
+
+function termsForOrganization(searchParams: SearchParams) {
+ if (searchParams.organization && searchParams.organization.length > 0) {
+ return [{
+ "nested": {
+ "path": "author",
+ "query": {
+ "bool": {
+ "must": [
+ {
+ "terms": {
+ "author.organization.organizationId.keyword": searchParams.organization
+ }
+ }
+ ]
+ }
+ }
+ }
+ }];
+ }
+ return [];
+}
+
+function termsForFieldsOfScience(searchParams: SearchParams) {
+ if (searchParams.fieldsOfScience && searchParams.fieldsOfScience.length > 0) {
+ return [{
+ "nested": {
+ "path": "fieldsOfScience",
+ "query": {
+ "bool": {
+ "must": [
+ {
+ "terms": {
+ "fieldsOfScience.fieldIdScience": searchParams.fieldsOfScience
+ }
+ }
+ ]
+ }
+ }
+ }
+ }];
+ }
+ return [];
+}
+
+function termsForPublicationTypeCode(searchParams: SearchParams) {
+ if (searchParams.publicationTypeCode) {
+ return [{
+ terms: {
+ "publicationTypeCode.keyword": searchParams.publicationTypeCode
+ }
+ }];
+ }
+ return [];
+}
+
+function termsForOpenAccess(searchParams: SearchParams) {
+ if (searchParams.openAccess) {
+ return [{
+ terms: {
+ "openAccess": searchParams.openAccess
+ }
+ }];
+ }
+ return [];
+}
+
+const [additionsFromOpenAccess, getOpenAccessAdditions] = generateAggregationStep("openAccess", lookup);
+export { getOpenAccessAdditions };
+
+function termsForPublisherOpenAccessCode(searchParams: SearchParams) {
+ if (searchParams.publisherOpenAccessCode) {
+ return [{
+ terms: {
+ "publisherOpenAccessCode": searchParams.publisherOpenAccessCode
+ }
+ }];
+ }
+ return [];
+}
+
+const [additionsFromPublisherOpenAccessCode, getPublisherOpenAccessCodeAdditions] = generateAggregationStep("publisherOpenAccessCode", lookup);
+export { getPublisherOpenAccessCodeAdditions };
+
+function termsForSelfArchivedCode(searchParams: SearchParams) {
+ if (searchParams.selfArchivedCode) {
+ return [{
+ terms: {
+ "selfArchivedCode.keyword": searchParams.selfArchivedCode
+ }
+ }];
+ }
+ return [];
+}
+
+const [additionsFromSelfArchivedCode, getSelfArchivedCodeAdditions] = generateAggregationStep("selfArchivedCode", lookup);
+export { getSelfArchivedCodeAdditions };
+
+const [additionsFromPublicationTypeCode, getPublicationTypeCodeAdditions] = generateAggregationStep("publicationTypeCode", lookup);
+export { getPublicationTypeCodeAdditions };
+
+type OrgsAggsResponse = {
+ aggregations: {
+ filtered_authors: {
+ single_sector: {
+ organizations: {
+ composite_orgs: {
+ buckets: Array<{
+ key: {
+ id: string;
+ name: string;
+ };
+ doc_count: number;
+ }>;
+ };
+ };
+ };
+ };
+ };
+};
+
+function filteringTerms(searchParams: SearchParams) {
+ return [
+ ...termsForYear(searchParams),
+ ...termsForTypeCode(searchParams),
+ ...termsForStatusCode(searchParams),
+ ...termsForOrganization(searchParams),
+ ...termsForLanguageCode(searchParams),
+ ...termsForPublicationFormat(searchParams),
+ ...termsForPublicationAudience(searchParams),
+ ...termsForPeerReviewed(searchParams),
+ ...termsForParentPublicationType(searchParams),
+ ...termsForInternationalPublication(searchParams),
+ ...termsForArticleTypeCode(searchParams),
+ ...termsForJufoClassCode(searchParams),
+ ...termsForFieldsOfScience(searchParams),
+ ...termsForPublicationTypeCode(searchParams),
+ ...termsForOpenAccess(searchParams),
+ ...termsForPublisherOpenAccessCode(searchParams),
+ ...termsForSelfArchivedCode(searchParams),
+ ];
+}
+
+function aggregationTerms(searchParams: SearchParams) {
+ return {
+ ...additionsFromYear(searchParams),
+ ...additionsFromOrganization(searchParams),
+ ...additionsFromLanguageCode(searchParams),
+ ...additionsFromPublicationFormat(searchParams),
+ ...additionsFromPublicationAudience(searchParams),
+ ...additionsFromPeerReviewed(searchParams),
+ ...additionsFromParentPublicationType(searchParams),
+ ...additionsFromInternationalPublication(searchParams),
+ ...additionsFromArticleTypeCode(searchParams),
+ ...additionsFromJufoClassCode(searchParams),
+ ...additionsFromFieldsOfScience(searchParams),
+ ...additionsFromPublicationTypeCode(searchParams),
+ ...additionsFromOpenAccess(searchParams),
+ ...additionsFromPublisherOpenAccessCode(searchParams),
+ ...additionsFromSelfArchivedCode(searchParams),
+ };
+}
+
+function additionFilterTerms(excluded: SearchParamKey, searchParams: SearchParams) {
+ return [
+ matchingTerms(searchParams),
+ ...(excluded === "year" ? [] : termsForYear(searchParams)),
+ ...(excluded === "publicationStatusCode" ? [] : termsForStatusCode(searchParams)),
+ ...(excluded === "organization" ? [] : termsForOrganization(searchParams)),
+ ...(excluded === "language" ? [] : termsForLanguageCode(searchParams)),
+ ...(excluded === "format" ? [] : termsForPublicationFormat(searchParams)),
+ ...(excluded === "audience" ? [] : termsForPublicationAudience(searchParams)),
+ ...(excluded === "peerReviewed" ? [] : termsForPeerReviewed(searchParams)),
+ ...(excluded === "parentPublicationType" ? [] : termsForParentPublicationType(searchParams)),
+ ...(excluded === "international" ? [] : termsForInternationalPublication(searchParams)),
+ ...(excluded === "articleType" ? [] : termsForArticleTypeCode(searchParams)),
+ ...(excluded === "jufo" ? [] : termsForJufoClassCode(searchParams)),
+ ...(excluded === "fieldsOfScience" ? [] : termsForFieldsOfScience(searchParams)),
+ ...(excluded === "publicationTypeCode" ? [] : termsForPublicationTypeCode(searchParams)),
+ ...(excluded === "openAccess" ? [] : termsForOpenAccess(searchParams)),
+ ...(excluded === "publisherOpenAccessCode" ? [] : termsForPublisherOpenAccessCode(searchParams)),
+ ...(excluded === "selfArchivedCode" ? [] : termsForSelfArchivedCode(searchParams)),
+ ];
+}
+
+function sortingTerms(searchParams: SearchParams) {
+ let sortedField = "publicationYear";
+ let direction = "desc";
+
+ const textFields = ["publicationName", "authorsText", "publisherName"];
+
+ if (searchParams.sort != null) {
+ const value = searchParams.sort.pop();
+
+ sortedField = value.replace(/Desc$/, "");
+ direction = value.endsWith("Desc") ? "desc" : "asc";
+
+ if (textFields.includes(sortedField)) {
+ sortedField += ".keyword";
+ }
+ }
+
+ return [
+ { [sortedField]: { "order": direction } },
+ "_score"
+ ];
+}
+
+function getOrganizationNameBuckets(response: OrgsAggsResponse) {
+ return response.aggregations.filtered_authors.single_sector.organizations.composite_orgs.buckets;
+}
+
+function additionsFromOrganization(searchParams: SearchParams, global = false) {
+ if (global)
+ return {
+ "all_data_except_organizationId": {
+ "global": {},
+ "aggregations": {
+ "filtered_except_organizationId": {
+ "filter": {
+ "bool": {
+ "must": [
+ ...additionFilterTerms("organization", searchParams),
+ ]
+ }
+ },
+ "aggregations": {
+ "organization_nested": {
+ "nested": {
+ "path": "author"
+ },
+ "aggregations": {
+ "all_organizationIds": {
+ "terms": {
+ "field": "author.organization.organizationId.keyword",
+ "size": 250,
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ };
+
+ else
+ return {
+ "all_data_except_organizationId": {
+ "filter": {
+ "bool": {
+ "must": [
+ ...additionFilterTerms("organization", searchParams),
+ ]
+ }
+ },
+ "aggregations": {
+ "organization_nested": {
+ "nested": {
+ "path": "author"
+ },
+ "aggregations": {
+ "all_organizationIds": {
+ "terms": {
+ "field": "author.organization.organizationId.keyword",
+ "size": 250,
+ }
+ }
+ }
+ }
+ }
+ }
+ };
+}
+
+export function getOrganizationAdditions(aggregations: /*OrganizationAggregation*/ any, global = false) {
+ if (global)
+ return aggregations.all_data_except_organizationId?.filtered_except_organizationId.organization_nested.all_organizationIds.buckets ?? [];
+ else
+ return aggregations.all_data_except_organizationId.organization_nested.all_organizationIds.buckets ?? [];
+}
+
+function additionsFromFieldsOfScience(searchParams: SearchParams, global = false) {
+ if (global)
+ return {
+ "all_data_except_fieldsOfScience": {
+ "global": {},
+ "aggregations": {
+ "filtered_except_fieldsOfScience": {
+ "filter": {
+ "bool": {
+ "must": [
+ ...additionFilterTerms("fieldsOfScience", searchParams),
+ ]
+ }
+ },
+ "aggregations": {
+ "fieldsOfScience_nested": {
+ "nested": {
+ "path": "fieldsOfScience"
+ },
+ "aggregations": {
+ "all_fieldsOfScience": {
+ "terms": {
+ "field": "fieldsOfScience.fieldIdScience",
+ "size": 1000,
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ };
+
+ else
+ return {
+ "all_data_except_fieldsOfScience": {
+ "filter": {
+ "bool": {
+ "must": [
+ ...additionFilterTerms("fieldsOfScience", searchParams),
+ ]
+ }
+ },
+ "aggregations": {
+ "fieldsOfScience_nested": {
+ "nested": {
+ "path": "fieldsOfScience"
+ },
+ "aggregations": {
+ "all_fieldsOfScience": {
+ "terms": {
+ "field": "fieldsOfScience.fieldIdScience",
+ "size": 1000,
+ }
+ }
+ }
+ }
+ }
+ }
+ };
+}
+
+export function getFieldsOfScienceAdditions(aggregations: any, global = false) {
+ if (global)
+ return aggregations.all_data_except_fieldsOfScience?.filtered_except_fieldsOfScience.fieldsOfScience_nested.all_fieldsOfScience.buckets ?? [];
+ else
+ return aggregations.all_data_except_fieldsOfScience.fieldsOfScience_nested.all_fieldsOfScience.buckets ?? [];
+}
diff --git a/src/app/shared/components/column-sorter/column-sorter.component.html b/src/app/shared/components/column-sorter/column-sorter.component.html
new file mode 100644
index 000000000..793fea2d0
--- /dev/null
+++ b/src/app/shared/components/column-sorter/column-sorter.component.html
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
diff --git a/src/app/shared/components/column-sorter/column-sorter.component.scss b/src/app/shared/components/column-sorter/column-sorter.component.scss
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/app/shared/components/column-sorter/column-sorter.component.ts b/src/app/shared/components/column-sorter/column-sorter.component.ts
new file mode 100644
index 000000000..5ab1ba7c4
--- /dev/null
+++ b/src/app/shared/components/column-sorter/column-sorter.component.ts
@@ -0,0 +1,29 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { NgIf, NgSwitch, NgSwitchCase } from '@angular/common';
+
+@Component({
+ selector: 'app-column-sorter',
+ templateUrl: './column-sorter.component.html',
+ styleUrls: ['./column-sorter.component.scss'],
+ imports: [
+ NgSwitch, NgSwitchCase, NgIf
+ ],
+ standalone: true
+})
+export class ColumnSorterComponent {
+ @Input() name: string;
+ @Input() value: string;
+
+ /*@Input() direction: number;
+ @Output() directionChange = new EventEmitter();
+
+ toggleSort() {
+ if (this.direction === 0) {
+ this.directionChange.emit(1);
+ } else if (this.direction === 1) {
+ this.directionChange.emit(-1);
+ } else {
+ this.directionChange.emit(0);
+ }
+ }*/
+}
diff --git a/src/app/shared/components/pagination/pagination.component.ts b/src/app/shared/components/pagination/pagination.component.ts
index 465ee9a72..486a1a131 100644
--- a/src/app/shared/components/pagination/pagination.component.ts
+++ b/src/app/shared/components/pagination/pagination.component.ts
@@ -5,9 +5,9 @@
// :author: CSC - IT Center for Science Ltd., Espoo Finland servicedesk@csc.fi
// :license: MIT
-import { Component, Input, OnInit } from '@angular/core';
+import { Component, Input, OnChanges } from '@angular/core';
import { ActivatedRoute, Router } from '@angular/router';
-import { Observable } from 'rxjs';
+import { BehaviorSubject, combineLatest, Observable } from 'rxjs';
import {
faAngleDoubleLeft,
faAngleDoubleRight,
@@ -23,30 +23,36 @@ import { map } from 'rxjs/operators';
templateUrl: './pagination.component.html',
styleUrls: ['./pagination.component.scss'],
})
-export class PaginationComponent implements OnInit {
- @Input() page: number = 1;
- @Input() pageSize: number = 10;
- @Input() total: any;
+export class PaginationComponent implements OnChanges {
+ @Input() page = 1;
+ @Input() pageSize = 10;
+ @Input() total = 0;
- fromPage: number; // Used for HTML rendering
+ changed$ = new BehaviorSubject(null);
- ngOnInit(): void {
+ fromPage = (this.page - 1) * this.pageSize;
+
+ ngOnChanges() {
this.fromPage = (this.page - 1) * this.pageSize;
+ this.changed$.next();
}
- pages$: Observable = this.breakpointObserver.observe('(min-width: 1200px)').pipe(
- map(result => generatePages(this.page, result.matches ? 9 : 5, this.total, this.pageSize))
+ pages$: Observable = combineLatest([
+ this.breakpointObserver.observe('(min-width: 1200px)'),
+ this.changed$,
+ ]).pipe(
+ map(([result]) => generatePages(this.page, result.matches ? 9 : 5, this.total, this.pageSize))
);
order$ = this.breakpointObserver.observe('(min-width: 768px)').pipe(
map(result => result.matches)
);
+ previous = $localize`:@@previous:Edellinen`;
+ next = $localize`:@@next:Seuraava`;
previousPage = $localize`:@@previousPage:Edellinen sivu`;
nextPage = $localize`:@@nextPage:Seuraava sivu`;
tooManyResultstext = $localize`:@@tooManyResultsNavigationDisabled:Liikaa tuloksia. Haun loppuun navigoiminen estetty.`;
- previous = $localize`:@@previous:Edellinen`;
- next = $localize`:@@next:Seuraava`;
faAngleRight = faAngleRight;
faAngleLeft = faAngleLeft;
@@ -99,8 +105,8 @@ function generatePages(currentPage: number, range: 5 | 9, results: number, pageS
output = [i-4, i-3, i-2, i-1, i, i+1, i+2, i+3, i+4];
}
- let min = Math.min(...output);
- let max = Math.max(...output);
+ const min = Math.min(...output);
+ const max = Math.max(...output);
if (min < 1) {
const increment = 1 - output[0];
diff --git a/src/app/shared/pipes/first-digit.pipe.ts b/src/app/shared/pipes/first-digit.pipe.ts
new file mode 100644
index 000000000..629c18b00
--- /dev/null
+++ b/src/app/shared/pipes/first-digit.pipe.ts
@@ -0,0 +1,12 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+ name: 'firstDigit',
+ standalone: true
+})
+export class FirstDigitPipe implements PipeTransform {
+ transform(value: number): number {
+ const firstDigit = Math.abs(value).toString()[0];
+ return parseInt(firstDigit);
+ }
+}
diff --git a/src/app/shared/pipes/first-letter.pipe.ts b/src/app/shared/pipes/first-letter.pipe.ts
new file mode 100644
index 000000000..15240c59f
--- /dev/null
+++ b/src/app/shared/pipes/first-letter.pipe.ts
@@ -0,0 +1,11 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+ name: 'firstLetter',
+ standalone: true
+})
+export class FirstLetterPipe implements PipeTransform {
+ transform(value: string): string {
+ return value[0];
+ }
+}
diff --git a/src/environments/locale.en.ts b/src/environments/locale.en.ts
new file mode 100644
index 000000000..a1f375fae
--- /dev/null
+++ b/src/environments/locale.en.ts
@@ -0,0 +1 @@
+export const locale = "en";
diff --git a/src/environments/locale.sv.ts b/src/environments/locale.sv.ts
new file mode 100644
index 000000000..8d8ad389c
--- /dev/null
+++ b/src/environments/locale.sv.ts
@@ -0,0 +1 @@
+export const locale = "sv";
diff --git a/src/environments/locale.ts b/src/environments/locale.ts
new file mode 100644
index 000000000..bd6bfcf3c
--- /dev/null
+++ b/src/environments/locale.ts
@@ -0,0 +1,2 @@
+// Intended to be used outside of Angular's Dependency Injection system.
+export const locale = "fi";
diff --git a/src/i18n/messages.en.xlf b/src/i18n/messages.en.xlf
index b1ee06746..4a5cb3781 100644
--- a/src/i18n/messages.en.xlf
+++ b/src/i18n/messages.en.xlf
@@ -570,6 +570,10 @@
50
+
+ Ei-vertaisarvioitu
+ Non Peer-Reviewed
+
Avoin saatavuus
Open access
@@ -6475,6 +6479,289 @@
Tieto- ja viestintätekniset sovellukset
ICT applications
+
+
+ Yliopisto
+ University
+
+
+
+ Ammattikorkeakoulu
+ University of Applied Sciences
+
+
+
+ Tutkimuslaitos
+ Research institute
+
+
+
+ Yliopistollisen sairaalan erityisvastuualue
+ University Hospital
+
+
+
+ Muu
+ Other
+
+
+
+ Kotimainen
+ Domestic
+
+
+
+ Kansainvälinen
+ International
+
+
+
+
+
+ Avoimesti saatavilla:
+ Open access:
+
+
+
+ Julkaisu on avoimesti saatavilla kustantajan palvelussa.
+ The publication is openly available in the publisher's service.
+
+
+
+ Ei avoin:
+ Not open:
+
+
+
+ Julkaisu ei ole avoimesti saatavilla kustantajan palvelussa.
+ The publication is not openly available in the publisher's service.
+
+
+
+ Ei tietoa:
+ Unknown:
+
+
+
+ Tietoa ei ole raportoitu.
+ No information has been reported.
+
+
+
+
+
+ Kokonaan avoin julkaisukanava:
+ Fully open publication channel:
+
+
+
+ Julkaisukanavan kaikki julkaisut ovat pysyvästi avoimesti saatavilla.
+ All publications are permanently openly available.
+
+
+
+ Osittain avoin julkaisukanava:
+ Partially open publication channel:
+
+
+
+ Julkaisukanavassa vain osa julkaisuista on pysyvästi avoimesti saatavilla.
+ Only some of the publications are permanently openly available.
+
+
+
+ Viivästetysti avoin julkaisukanava:
+ Delayed open publication channel:
+
+
+
+ Julkaisukanavan tieteelliset artikkelit avataan kustantajan määrittelemän viiveajan jälkeen.
+ Scientific articles are opened after a delay time defined by the publisher.
+
+
+
+ Ei vastausta:
+ No response:
+
+
+
+ Julkaisukanava ei ole kokonaan, osittain tai viivästetysti avoin.
+ The publication channel is not fully, partially, or delayed open.
+
+
+
+ Ei tietoa:
+ Unknown:
+
+
+
+ Tietoa ei ole raportoitu.
+ No information has been reported.
+
+
+
+
+
+ Rinnakkaistallennettu:
+ Self-archived:
+
+
+
+ Julkaisu on tallennettu organisaatio- tai tieteenalakohtaiseen julkaisuarkistoon joko välittömästi tai kustantajan määrittämän kohtuullisen embargoajan jälkeen.
+ The publication has been published in a publication archive specific to an organization or field of science either immediately or after a reasonable embargo period set by the publisher.
+
+
+
+
+
+ Avoimesti saatavilla
+ Open access
+
+
+
+ Ei avoin
+ Not open
+
+
+
+ Ei tietoa
+ Unknown
+
+
+
+ Kokonaan avoin julkaisukanava
+ Fully open publication channel
+
+
+
+ Osittain avoin julkaisukanava
+ Partially open publication channel
+
+
+
+ Viivästetysti avoin julkaisukanava
+ Delayed open publication channel
+
+
+
+ Ei vastausta
+ No answer
+
+
+
+ Ei tietoa
+ No information
+
+
+
+ Rinnakkaistallennettu
+ Self-archived
+
+
+
+ Ei rinnakkaistallennettu
+ Not self-archived
+
+
+
+ Ei tietoa
+ Unknown
+
+
+
+
+ Rinnakkaistallenne
+ Self-archived
+
+
+
+
+
+ Uuteen hakuun
+ To new search
+
+
+
+ Testaa haun uudistettua betaversiota. Betaversio toimii vain julkaisujen hakuun. Tiedot vastaavat nykyisen sivuston sisältöä julkaisujen osalta.
+ Test the beta version of the improved search. The improved search only works in publications. The information corresponds to the content of the current site for publications.
+
+
+
+ Nykyiseen versioon
+ Back to the current version
+
+
+
+ Olet haun uudistetussa betaversiossa. Voit palata takaisin koko sivustolle.
+ You are in the improved beta version of the search. You can go back to the whole site.
+
+
+
+ Testaa uudistetun haun betaversiota. Uudistettua hakua on toistaiseksi mahdollista testata ainoastaan julkaisutietojen hakemisessa.
+ Test the beta version of the improved search function. The new search can currently only be tested in publication information retrieval.
+
+
+
+ Kirjoita hakukenttään esimerkiksi julkaisun tai tekijän nimi, tai julkaisuun liittyvä asiasana.
+ Write in the search field, for example, the name of the publication or author, or a keyword related to the publication.
+
+
+
+ Haku käyttää sanojen välissä oletuksena OR-hakuoperaattioria. Halutessasi voit käyttää myös AND- ja NOT- hakuoperaattoireita. Esimerkiksi haku Innovation AND gamification NOT games etsii julkaisuja, joissa esiintyvät yhtä aikaa sanat "innovation" ja "gamification", mutta joissa ei ole mukana sanaa "games". Huomioithan, että AND, NOT ja OR -hakuoperaattorit tulee kirjoittaa hakukenttään isoilla kirjaimilla.
+ The search uses the OR search operator by default between words. If you wish, you can also use the AND and NOT search operators. For example, the search Innovation AND gamification NOT games search for publications that simultaneously contain the words “innovation” and “gamification”, but do not include the word “games”. Please note that the AND, NOT, and OR search operators must be written in capital letters in the search field.
+
+
+
+ Sulkemalla haussa esiintyvät sanat lainausmerkeillä fraasiksi voit etsiä osumia jotka ovat täsmälleen samassa muodossa. Esimerkiksi fraasihaku "Innovations in gamifications" etsii julkaisuja, joissa esiintyy juuri tämä lause. Voit myös yhdistää useampia fraasihakuja AND-, OR- tai NOT-hakuoperaattoreilla.
+ By enclosing the phrases appearing in the search in quotation marks, you can search for matches exactly in the same form. For example, the phrase search "Innovations in gamifications" searches for publications that contain exactly this sentence. You can also combine several phrase searches with AND, OR, or NOT search operators.
+
+
+
+ Voit hakea kohdistetusti joitakin metatietoja suoraan hakukentässä käyttämällä niille erikseen määriteltyjä komentoja. Haussa on käytettävä fraasihakua. Toistaiseksi haku on mahdollista kohdistaa seuraaviin metatietoihin:
+ You can also search for some metadata directly in the search field using commands defined separately for them. Phrase search must be used in the search. At the moment, the search can be targeted at the following metadata:
+
+
+
+ DOI, kirjoita hakukenttään doi:"haettava tunnus", esimerkiksi doi:"100100100"
+ DOI, write in the search field doi:"searched identifier", for example, doi:"100100100"
+
+
+
+ ISSN, kirjoita hakukenttään issn:"haettava tunnnus", esimerkiksi issn:"1234-1234"
+ ISSN, write in the search field issn:"searched identifier", for example, issn:"1234-1234"
+
+
+
+ ISBN, kirjoita hakukenttään isbn:"haettava tunnus", esimerkiksi isbn:"123-0-456-12345-1"
+ ISBN, write in the search field isbn:"searched identifier", for example, isbn:"123-0-456-12345-1"
+
+
+
+ JUFO-tunnus, kirjoita hakukenttään jufoCode:"haettava tunnus", esimerkiksi jufoCode:"12345"
+ JUFO code, write in the search field jufoCode:"searched identifier", for example, jufoCode:"12345"
+
+
+
+ Huomioithan, että kohdistetussa haussa metatietokentät tulee kirjoittaa pienillä kirjaimilla.
+ Please note that metadata fields must be written in lowercase in targeted search.
+
+
+
+
+ Mitä julkaisutietoja palvelu sisältää?
+ What publication information is included in the service?
+
+
+
+ tulosta
+ results
+
+
+
+ sivu
+ page
+
+