MaDgiK-CITE
/
argos
13
0
Fork 0
Code Issues Pull Requests Projects Releases 3 Wiki Activity

fix external references enums

This commit is contained in:
amentis 2023-10-20 17:44:41 +03:00
parent a94cce47e8
commit 0bd3ff6898
10 changed files with 89 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
dmp-backend/core/src/main/java/eu/eudat/commons/enums/ExternalReferencesType.java
View File

@ -1,8 +1,10 @@
package eu.eudat.commons.enums;
import eu.eudat.data.converters.enums.DatabaseEnum;
import java.util.Map;
public enum ExternalReferencesType {
public enum ExternalReferencesType implements DatabaseEnum<Short> {
Taxonomies((short) 0),
Licenses((short) 1),
Publications((short) 2),
@ -12,13 +14,13 @@ public enum ExternalReferencesType {
Registries((short) 6),
Services((short) 7),
Project((short) 8),
Founder((short) 8),
Datasets((short) 9),
Organizations((short) 10),
Grants((short) 11),
Prefillings((short) 12),
Funder((short) 9),
Datasets((short) 10),
Organizations((short) 11),
Grants((short) 12),
Validators((short) 13),
Researcher((short) 14);
Researcher((short) 14),
Prefillings((short) 15);
private final Short value;
ExternalReferencesType(Short value) {
@ -29,9 +31,9 @@ public enum ExternalReferencesType {
return value;
}
private static final Map<Short, IsActive> map = EnumUtils.getEnumValueMap(IsActive.class);
private static final Map<Short, ExternalReferencesType> map = EnumUtils.getEnumValueMap(ExternalReferencesType.class);
public static IsActive of(Short i) {
public static ExternalReferencesType of(Short i) {
return map.get(i);
}
}

7
dmp-backend/web/src/main/java/eu/eudat/controllers/v2/ExternalReferencesController.java
View File

@ -70,14 +70,15 @@ public class ExternalReferencesController extends BaseController {
@GetMapping(path = {"data-repo/{externalType}"}, produces = "application/json")
public @ResponseBody ResponseEntity<ResponseItem<List<ExternalReference>>> listExternalReferecnes(@RequestParam(value = "externalType") ExternalReferencesType externalType,
@GetMapping(path = {"{externalType}"}, produces = "application/json")
public @ResponseBody ResponseEntity<ResponseItem<List<ExternalReference>>> listExternalReferecnes(@PathVariable(value = "externalType") int externalType,
@RequestParam(value = "query", required = false) String query,
@RequestParam(value = "type", required = false) String type
) throws HugeResultSet, NoURLFound, InvalidApplicationException {
this.authorizationService.authorizeForce(Permission.AuthenticatedRole);
ExternalReferencesType externalReferencesType = ExternalReferencesType.of((short) externalType);
List<ExternalReference> externalReferences = this.externalReferencesService.getExternalReference(externalType, query, type);
List<ExternalReference> externalReferences = this.externalReferencesService.getExternalReference(externalReferencesType, query, type);
return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem<List<ExternalReference>>().status(ApiMessageCode.NO_MESSAGE).payload(externalReferences));
}

12
dmp-backend/web/src/main/java/eu/eudat/controllers/v2/ValidationController.java → dmp-backend/web/src/main/java/eu/eudat/controllers/v2/ExternalValidationController.java
View File

@ -5,7 +5,7 @@ import eu.eudat.controllers.BaseController;
import eu.eudat.logic.proxy.config.exceptions.HugeResultSet;
import eu.eudat.logic.proxy.config.exceptions.NoURLFound;
import eu.eudat.logic.services.ApiContext;
import eu.eudat.logic.services.ValidationService;
import eu.eudat.logic.services.ExternalValidationService;
import eu.eudat.models.data.helpers.responses.ResponseItem;
import eu.eudat.types.ApiMessageCode;
import gr.cite.commons.web.authz.service.AuthorizationService;
@ -17,15 +17,15 @@ import org.springframework.web.bind.annotation.*;
@RestController
@CrossOrigin
@RequestMapping(path = {"api/validation"})
public class ValidationController extends BaseController {
public class ExternalValidationController extends BaseController {
private ValidationService validationService;
private ExternalValidationService externalValidationService;
private final AuthorizationService authorizationService;
@Autowired
public ValidationController(ApiContext apiContext, ValidationService validationService, AuthorizationService authorizationService) {
public ExternalValidationController(ApiContext apiContext, ExternalValidationService externalValidationService, AuthorizationService authorizationService) {
super(apiContext);
this.validationService = validationService;
this.externalValidationService = externalValidationService;
this.authorizationService = authorizationService;
}
@ -36,7 +36,7 @@ public class ValidationController extends BaseController {
) throws HugeResultSet, NoURLFound {
this.authorizationService.authorizeForce(Permission.AuthenticatedRole);
Boolean isValid = this.validationService.validateIdentifier(query, type);
Boolean isValid = this.externalValidationService.validateIdentifier(query, type);
return ResponseEntity.status(HttpStatus.OK).body(new ResponseItem<Boolean>().payload(isValid).status(ApiMessageCode.NO_MESSAGE));
}
}

2
dmp-backend/web/src/main/java/eu/eudat/logic/proxy/fetching/RemoteFetcher.java
View File

@ -73,7 +73,7 @@ public class RemoteFetcher {
case Grants: return configLoader.getExternalUrls().getGrants();
case Organizations: return configLoader.getExternalUrls().getOrganisations();
case Datasets: return configLoader.getExternalUrls().getDatasets();
case Founder: return configLoader.getExternalUrls().getFunders();
case Funder: return configLoader.getExternalUrls().getFunders();
case Project: return configLoader.getExternalUrls().getProjects();
case Researcher: return configLoader.getExternalUrls().getResearchers();
case Validators: return configLoader.getExternalUrls().getValidations();

4
dmp-backend/web/src/main/java/eu/eudat/logic/services/ValidationService.java → dmp-backend/web/src/main/java/eu/eudat/logic/services/ExternalValidationService.java
View File

@ -9,13 +9,13 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class ValidationService {
public class ExternalValidationService {
private RemoteFetcher remoteFetcher;
private final UserScope userScope;
@Autowired
public ValidationService(RemoteFetcher remoteFetcher, UserScope userScope) {
public ExternalValidationService(RemoteFetcher remoteFetcher, UserScope userScope) {
super();
this.remoteFetcher = remoteFetcher;
this.userScope = userScope;

2
dmp-backend/web/src/main/java/eu/eudat/logic/services/externalreferences/ExternalReferencesService.java
View File

@ -25,7 +25,7 @@ import java.util.Map;
import java.util.stream.Collectors;
@org.springframework.stereotype.Service
public class ExternalReferencesService {//implements ExternalReferencesService{
public class ExternalReferencesService {
private final ApiContext apiContext;
private final UserScope userScope;

18
dmp-frontend/src/app/core/common/enum/external-references-type.ts Normal file
View File

@ -0,0 +1,18 @@
export enum ExternalReferencesType {
Taxonomies = 0,
Licenses = 1,
Publications = 2,
Journals = 3,
PubRepositories = 4,
DataRepositories = 5,
Registries = 6,
Services = 7,
Project = 8,
Funder = 9,
Datasets = 10,
Organizations = 11,
Grants = 12,
Validators = 13,
Researcher = 14,
Prefillings = 15
}

19
dmp-frontend/src/app/core/model/external-reference/external-reference.ts Normal file
View File

@ -0,0 +1,19 @@
export interface ExternalReference {
id: string;
name: string;
abbreviation: string;
pid: string;
originalId: string;
key: string;
pidTypeField: string;
uri: string;
description: string;
source: string;
count: string;
path: string;
host: string;
types: string;
firstName: string;
lastName: string;
tag: string;
}

10
dmp-frontend/src/app/core/services/external-sources/external-sources.service.ts
View File

@ -14,7 +14,8 @@ import { BaseHttpService } from '../http/base-http.service';
import { ConfigurationService } from '../configuration/configuration.service';
import { LicenseCriteria } from '@app/core/query/license/license-criteria';
import {PublicationCriteria} from "@app/core/query/publication/publication-criteria";
import { ExternalReference } from '@app/core/model/external-reference/external-reference';
import { ExternalReferencesType } from '@app/core/common/enum/external-references-type';
@Injectable()
export class ExternalSourcesService {
@ -58,6 +59,13 @@ export class ExternalSourcesService {
return this.http.get<ExternalSourceItemModel[]>(this.actionUrl + 'licenses' + '?query=' + requestItem.criteria.like + '&type=' + requestItem.criteria.type, { headers: this.headers });
}
public listExternal(externalType: ExternalReferencesType, query: string, type: string): Observable<ExternalReference[]> {
const url = this.configurationService.server + `external-references/${externalType}`;
const options = { params: { query: query, type: type } };
return this.http.get<ExternalReference[]>(url, options);
}
public searchDatasetTags(requestItem: RequestItem<TagCriteria>): Observable<ExternalSourceItemModel[]> {
// return Observable.of([
// { id: '1', name: 'Tag 1', description: '' },

34
dmp-frontend/src/app/ui/misc/dataset-description-form/components/form-field/form-field.component.ts
View File

@ -48,6 +48,8 @@ import {MatDialog} from "@angular/material/dialog";
import {HttpError} from "@common/modules/errors/error-handling/http-error-handling.service";
import {HttpErrorResponse} from "@angular/common/http";
import * as FileSaver from "file-saver";
import { ExternalReference } from '@app/core/model/external-reference/external-reference';
import { ExternalReferencesType } from '@app/core/common/enum/external-references-type';
@Component({
selector: 'app-form-field',
@ -470,63 +472,63 @@ export class FormFieldComponent extends BaseComponent implements OnInit {
return this.externalSourcesService.searchDatasetSExternalDatasetservice(requestItem);
}
searchDatasetExternalDataRepositories(query: string): Observable<ExternalSourceItemModel[]> {
searchDatasetExternalDataRepositories(query: string): Observable<ExternalReference[]> {
const requestItem: RequestItem<DataRepositoryCriteria> = new RequestItem();
requestItem.criteria = new DataRepositoryCriteria();
requestItem.criteria.like = query;
requestItem.criteria.type = '';
return this.externalSourcesService.searchDatasetRepository(requestItem);
return this.externalSourcesService.listExternal(ExternalReferencesType.DataRepositories, requestItem.criteria.like, requestItem.criteria.type);
}
searchDatasetExternalPubRepositories(query: string): Observable<ExternalSourceItemModel[]> {
searchDatasetExternalPubRepositories(query: string): Observable<ExternalReference[]> {
const requestItem: RequestItem<DataRepositoryCriteria> = new RequestItem();
requestItem.criteria = new DataRepositoryCriteria();
requestItem.criteria.like = query;
requestItem.criteria.type = '';
return this.externalSourcesService.searchPublicationRepository(requestItem);
return this.externalSourcesService.listExternal(ExternalReferencesType.PubRepositories, requestItem.criteria.like, requestItem.criteria.type);
}
searchDatasetExternalJournalRepositories(query: string): Observable<ExternalSourceItemModel[]> {
searchDatasetExternalJournalRepositories(query: string): Observable<ExternalReference[]> {
const requestItem: RequestItem<DataRepositoryCriteria> = new RequestItem();
requestItem.criteria = new DataRepositoryCriteria();
requestItem.criteria.like = query;
requestItem.criteria.type = '';
return this.externalSourcesService.searchJournals(requestItem);
return this.externalSourcesService.listExternal(ExternalReferencesType.Journals, requestItem.criteria.like, requestItem.criteria.type);
}
searchDatasetExternalTaxonomies(query: string): Observable<ExternalSourceItemModel[]> {
searchDatasetExternalTaxonomies(query: string): Observable<ExternalReference[]> {
const requestItem: RequestItem<TaxonomyCriteria> = new RequestItem();
requestItem.criteria = new TaxonomyCriteria();
requestItem.criteria.like = query;
requestItem.criteria.type = '';
return this.externalSourcesService.searchTaxonomies(requestItem);
return this.externalSourcesService.listExternal(ExternalReferencesType.Taxonomies, requestItem.criteria.like, requestItem.criteria.type);
}
searchDatasetExternalLicences(query: string): Observable<ExternalSourceItemModel[]> {
searchDatasetExternalLicences(query: string): Observable<ExternalReference[]> {
const requestItem: RequestItem<LicenseCriteria> = new RequestItem();
requestItem.criteria = new LicenseCriteria();
requestItem.criteria.like = query;
requestItem.criteria.type = '';
return this.externalSourcesService.searchLicense(requestItem);
return this.externalSourcesService.listExternal(ExternalReferencesType.Licenses, requestItem.criteria.like, requestItem.criteria.type);
}
searchDatasetExternalPublications(query: string): Observable<ExternalSourceItemModel[]> {
searchDatasetExternalPublications(query: string): Observable<ExternalReference[]> {
const requestItem: RequestItem<PublicationCriteria> = new RequestItem();
requestItem.criteria = new PublicationCriteria();
requestItem.criteria.like = query;
requestItem.criteria.type = '';
return this.externalSourcesService.searchPublications(requestItem);
return this.externalSourcesService.listExternal(ExternalReferencesType.Publications, requestItem.criteria.like, requestItem.criteria.type);
}
searchDatasetExternalRegistries(query: string): Observable<ExternalSourceItemModel[]> {
searchDatasetExternalRegistries(query: string): Observable<ExternalReference[]> {
const requestItem: RequestItem<RegistryCriteria> = new RequestItem();
requestItem.criteria = new RegistryCriteria();
requestItem.criteria.like = query;
requestItem.criteria.type = '';
return this.externalSourcesService.searchDatasetRegistry(requestItem);
return this.externalSourcesService.listExternal(ExternalReferencesType.Registries, requestItem.criteria.like, requestItem.criteria.type);
}
searchDatasetExternalServices(query: string): Observable<ExternalSourceItemModel[]> {
searchDatasetExternalServices(query: string): Observable<ExternalReference[]> {
const requestItem: RequestItem<ServiceCriteria> = new RequestItem();
requestItem.criteria = new ServiceCriteria();
requestItem.criteria.like = query;
requestItem.criteria.type = '';
return this.externalSourcesService.searchDatasetService(requestItem);
return this.externalSourcesService.listExternal(ExternalReferencesType.Services, requestItem.criteria.like, requestItem.criteria.type);
}
searchDatasetTags(query: string): Observable<ExternalSourceItemModel[]> {