AoU-Admin/src/main/java/ch/unige/aou/controller/admin/ExternalDataController.java

@@ -26,8 +26,9 @@ import ch.unige.aou.rest.AouActionName;
 import ch.unige.aou.rest.UrlPath;
 import ch.unige.aou.service.metadata.imports.ArxivImportService;
 import ch.unige.aou.service.metadata.imports.DoiCrossrefImportService;
-import ch.unige.aou.service.rest.JournalTitleRemoteService;
 import ch.unige.aou.service.metadata.imports.PmidImportService;
+import ch.unige.aou.service.rest.JournalTitleRemoteService;
+import ch.unige.aou.service.rest.RomeoService;
 import ch.unige.aou.service.rest.UnigePersonSearch;
 
 @UserPermissions
@@ -41,14 +42,17 @@ public class ExternalDataController {
   private ArxivImportService arxivImportService;
   private JournalTitleRemoteService journalTitleService;
   private PmidImportService pmidImportService;
+  private RomeoService romeoService;
 
   public ExternalDataController(UnigePersonSearch unigePersonSearch, DoiCrossrefImportService doiCrossrefImportService,
-          ArxivImportService arxivImportService, JournalTitleRemoteService journalTitleService, PmidImportService pmidImportService) {
+          ArxivImportService arxivImportService, JournalTitleRemoteService journalTitleService, PmidImportService pmidImportService,
+          RomeoService romeoService) {
     this.unigePersonSearch = unigePersonSearch;
     this.doiCrossrefImportService = doiCrossrefImportService;
     this.arxivImportService = arxivImportService;
     this.journalTitleService = journalTitleService;
     this.pmidImportService = pmidImportService;
+    this.romeoService = romeoService;
   }
 
   @GetMapping(AouActionName.SEARCH_UNIGE_PERSON)
@@ -108,8 +112,8 @@ public class ExternalDataController {
 
   @GetMapping(AouActionName.GET_JOURNAL_TITLES)
   public HttpEntity<Collection<JournalTitleDTO>> getJournalTitlesByISSN(@RequestParam(required = false) String issn,
-                                                                        @RequestParam(required = false) String title,
-                                                                        Pageable page) {
+          @RequestParam(required = false) String title,
+          Pageable page) {
     if (!StringTool.isNullOrEmpty(title)) {
       SearchDTO search = new SearchDTO();
       search.setPage(page.getPageNumber());
@@ -123,4 +127,16 @@ public class ExternalDataController {
       return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
     }
   }
+
+  @GetMapping(AouActionName.GET_ROMEO_INFOS)
+  public HttpEntity<String> getRomeoByIssn(@RequestParam String issn) {
+    if (!StringTool.isNullOrEmpty(issn)) {
+      String romeoInfos = this.romeoService.getInfosByIssn(issn);
+      final HttpHeaders headers = new HttpHeaders();
+      headers.setContentType(MediaType.APPLICATION_JSON);
+      return new ResponseEntity<>(romeoInfos, headers, HttpStatus.OK);
+    }
+
+    return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+  }
 }

AoU-Admin/src/main/java/ch/unige/aou/controller/admin/PublicationController.java

@@ -71,6 +71,9 @@ import ch.unige.aou.service.metadata.imports.ArxivImportService;
 import ch.unige.aou.service.metadata.imports.DoiCrossrefImportService;
 import ch.unige.aou.service.metadata.imports.EuropePmcImportService;
 import ch.unige.aou.service.metadata.imports.UnpaywallImportService;
+import ch.unige.aou.specification.PublicationContributorSpecification;
+import ch.unige.aou.specification.PublicationSpecification;
+import ch.unige.aou.specification.UserSpecification;
 
 @UserPermissions
 @RestController
@@ -150,11 +153,18 @@ public class PublicationController extends AouResourceController<Publication> {
 
   @GetMapping(AouActionName.LIST_MY_PUBLICATIONS)
   public HttpEntity<Collection<Publication>> listMyPublications(@ModelAttribute Publication search, Pageable pageable) {
+    return listMyPublications(null, search, pageable);
+  }
+
+  @GetMapping(path = AouActionName.LIST_MY_PUBLICATIONS, params = "fullName")
+  public HttpEntity<Collection<Publication>> listMyPublications(@RequestParam String fullName, @ModelAttribute Publication search,
+          Pageable pageable) {
     Person creator = this.personService.getLinkedPerson(SecurityContextHolder.getContext().getAuthentication());
     String cnIndividu = this.personService.getCnIndividuLinkedPerson();
 
     if (creator != null && !StringTool.isNullOrEmpty(creator.getResId())) {
-      Page<Publication> listItem = ((PublicationService) this.itemService).findMyPublications(search, creator.getResId(), cnIndividu, pageable);
+      Page<Publication> listItem = ((PublicationService) this.itemService)
+              .findMyPublications(search, creator.getResId(), cnIndividu, pageable, fullName);
       this.setRessourceLinks(listItem);
       final Collection<Publication> collection = this.setCollectionLinks(listItem, pageable);
       return new ResponseEntity<>(collection, HttpStatus.OK);
@@ -359,7 +369,7 @@ public class PublicationController extends AouResourceController<Publication> {
     } else if (publication.getImportSource().equals(Publication.ImportSource.DOI)) {
       this.doiCrossrefImportService.createDocumentFileFromCrossrefMetadata(publication);
       this.unpaywallImportService.createDocumentFileFromUnpaywall(publication);
-    } else if(publication.getImportSource().equals(Publication.ImportSource.PMID)) {
+    } else if (publication.getImportSource().equals(Publication.ImportSource.PMID)) {
       //check if there is pmcid, if so import files from (Europe)PMC
       String pmicId = ((PublicationService) this.itemService).getPmcIdFromPublicationMetadata(publication);
       if (!StringTool.isNullOrEmpty(pmicId)) {

AoU-Common/src/main/java/ch/unige/aou/config/AouProperties.java

@@ -241,10 +241,12 @@ public class AouProperties {
     private int maxPreservationPolicyRetentionPeriodInYears = 100;
 
     //need to specify the same order for an specific type of format for metadata and frontend
-    private String[] metadataDateFormat = {"yyyy-MM-dd", "yyyy-MM", "yyyy"};
-    private String[] metadataOutputDateFormat = {"yyyy-MM-dd", "yyyy-MM", "yyyy"};
-    private String[] frontendEnterDateFormat = {"d.M.yyyy", "M.yyyy","yyyy"}; // format in which a date can be entered on frontend (1 digit allowed for day and month)
-    private String[] frontendOutputDateFormat = {"dd.MM.yyyy", "MM.yyyy", "yyyy"}; // format to which a date is given back to frontend (2 digits for day and month)
+    private String[] metadataDateFormat = { "yyyy-MM-dd", "yyyy-MM", "yyyy" };
+    private String[] metadataOutputDateFormat = { "yyyy-MM-dd", "yyyy-MM", "yyyy" };
+    private String[] frontendEnterDateFormat = { "d.M.yyyy", "M.yyyy",
+            "yyyy" }; // format in which a date can be entered on frontend (1 digit allowed for day and month)
+    private String[] frontendOutputDateFormat = { "dd.MM.yyyy", "MM.yyyy",
+            "yyyy" }; // format to which a date is given back to frontend (2 digits for day and month)
 
     private String emailTemplatePath;
     private String submissionPortalHomepage = "https://archive-ouverte.unige.ch"; // used in emails templates to build links to the portal
@@ -1340,7 +1342,7 @@ public class AouProperties {
     private SupplementaryFiles supplementaryFiles = new SupplementaryFiles();
 
     public SupplementaryFiles getSupplementaryFiles() {
-      return supplementaryFiles;
+      return this.supplementaryFiles;
     }
 
     public void setSupplementaryFiles(SupplementaryFiles supplementaryFiles) {
@@ -1380,10 +1382,10 @@ public class AouProperties {
     }
   }
 
-
   public static class Search {
     private Person person = new Person();
     private Journal journal = new Journal();
+    private Romeo romeo = new Romeo();
 
     public Person getPerson() {
       return this.person;
@@ -1400,6 +1402,14 @@ public class AouProperties {
     public void setJournal(Journal journal) {
       this.journal = journal;
     }
+
+    public Romeo getRomeo() {
+      return this.romeo;
+    }
+
+    public void setRomeo(Romeo romeo) {
+      this.romeo = romeo;
+    }
   }
 
   public static class Person {
@@ -1453,6 +1463,27 @@ public class AouProperties {
     }
   }
 
+  public static class Romeo {
+    private String url = "https://v2.sherpa.ac.uk/cgi/retrieve";
+    private String apiKey;
+
+    public String getUrl() {
+      return this.url;
+    }
+
+    public void setUrl(String url) {
+      this.url = url;
+    }
+
+    public String getApiKey() {
+      return this.apiKey;
+    }
+
+    public void setApiKey(String apiKey) {
+      this.apiKey = apiKey;
+    }
+  }
+
   public static class Orcid {
     private String clientId = "";
     private String clientSecret = "";

AoU-Common/src/main/resources/locale/messages_aou.properties

@@ -60,6 +60,8 @@ deposit.error.container.identifiers.invalid_urn=The value is not a valid URN
 deposit.error.structure.invalid_code=This Structure code doesn't exit
 deposit.error.researchGroup.invalid_code=This research group code doesn't exit
 deposit.error.contributors.appears_more_than_once=This contributor appears more than once
+deposit.error.contributors.missing_author_in_contributors=Missing author for this subtype of publication:''{0}''
+deposit.error.contributors.missing_director_in_contributors=Missing director for this subtype of publication:''{0}''
 deposit.error.field_cannot_be_empty=This field cannot be empty
 deposit.error.field_invalid_value=This value is not valid
 deposit.error.date.invalid_date=This date is not a valid date

AoU-IntegrationTests/src/test/java/ch/unige/aou/test/admin/DepositMetadataValidationV2IT.java

@@ -256,6 +256,98 @@ class DepositMetadataValidationV2IT extends PublicationIT {
     assertTrue(this.validationErrorsContain("contributors.contributors.2.role", "This field cannot be empty", validationErrors));
   }
 
+  @Test
+  void testAuthorAndDirectorPresentForThesis() {
+
+    Map<String, Object> metadataProperties = new HashMap<>();
+    metadataProperties.put("title", "validation test");
+    metadataProperties.put("languages", List.of(this.PUBLICATION_TEST_LANGUAGE));
+    metadataProperties.put("type", this.PUBLICATION_TYPE_DIPLOME_NAME);
+    metadataProperties.put("subtype", this.PUBLICATION_SUBTYPE_THESE_NAME);
+
+    List<AbstractContributor> contributors = new ArrayList<>();
+
+    ContributorDTO contributorDTO = new ContributorDTO();
+    contributorDTO.setFirstName("John");
+    contributorDTO.setLastName("Doe");
+    contributorDTO.setRole("author");
+    contributorDTO.setCnIndividu("12345");
+    contributors.add(contributorDTO);
+
+    CollaborationDTO collaborationDTO = new CollaborationDTO();
+    collaborationDTO.setName("My collaboration");
+    contributors.add(collaborationDTO);
+
+    contributorDTO = new ContributorDTO();
+    contributorDTO.setFirstName("Mika");
+    contributorDTO.setLastName("Mou");
+    contributorDTO.setRole("director");
+    contributorDTO.setCnIndividu("8596");
+    contributors.add(contributorDTO);
+
+    metadataProperties.put("contributors", contributors);
+
+    String xmlMetadata = this.getMetadata(metadataProperties);
+    Publication publication = new Publication();
+    publication.setMetadata(xmlMetadata);
+    publication.setFormStep(Publication.DepositFormStep.CONTRIBUTORS);
+    Publication savedPublication = this.publicationService.create(publication);
+    assertNotNull(savedPublication);
+    assertEquals(this.getTemporaryTestLabel("validation test"), savedPublication.getTitle());
+
+    DepositDoc savedDepositDoc = this.createDepositDocFromXml(savedPublication.getMetadata());
+    assertEquals("John", ((Contributor) savedDepositDoc.getContributors().getContributorOrCollaboration().get(0)).getFirstname());
+    assertEquals("Doe", ((Contributor) savedDepositDoc.getContributors().getContributorOrCollaboration().get(0)).getLastname());
+    assertEquals(AuthorRole.AUTHOR.name(),
+            ((Contributor) savedDepositDoc.getContributors().getContributorOrCollaboration().get(0)).getRole().name());
+    assertEquals("12345", ((Contributor) savedDepositDoc.getContributors().getContributorOrCollaboration().get(0)).getCnIndividu());
+
+    assertEquals("My collaboration", ((Collaboration) savedDepositDoc.getContributors().getContributorOrCollaboration().get(1)).getName());
+
+    assertEquals("Mika", ((Contributor) savedDepositDoc.getContributors().getContributorOrCollaboration().get(2)).getFirstname());
+    assertEquals("Mou", ((Contributor) savedDepositDoc.getContributors().getContributorOrCollaboration().get(2)).getLastname());
+    assertEquals(AuthorRole.DIRECTOR.name(),
+            ((Contributor) savedDepositDoc.getContributors().getContributorOrCollaboration().get(2)).getRole().name());
+    assertEquals("8596", ((Contributor) savedDepositDoc.getContributors().getContributorOrCollaboration().get(2)).getCnIndividu());
+  }
+
+  @Test
+  void testContributorsMissingAuthorForThesis() {
+    Map<String, Object> metadataProperties = new HashMap<>();
+    metadataProperties.put("title", "validation test");
+    metadataProperties.put("languages", List.of(this.PUBLICATION_TEST_LANGUAGE));
+    metadataProperties.put("type", this.PUBLICATION_TYPE_DIPLOME_NAME);
+    metadataProperties.put("subtype", this.PUBLICATION_SUBTYPE_THESE_NAME);
+
+    List<AbstractContributor> contributors = new ArrayList<>();
+
+    ContributorDTO contributorDTO = new ContributorDTO();
+    contributorDTO.setFirstName("John");
+    contributorDTO.setLastName("Doe");
+    contributorDTO.setRole("director");
+    contributorDTO.setCnIndividu("12345");
+    contributors.add(contributorDTO);
+
+    contributorDTO = new ContributorDTO();
+    contributorDTO.setFirstName("Mika");
+    contributorDTO.setLastName("Mou");
+    contributorDTO.setRole("director");
+    contributorDTO.setCnIndividu("8596");
+    contributors.add(contributorDTO);
+
+    metadataProperties.put("contributors", contributors);
+
+    String xmlMetadata = this.getMetadata(metadataProperties);
+    Publication publication = new Publication();
+    publication.setMetadata(xmlMetadata);
+    publication.setFormStep(Publication.DepositFormStep.CONTRIBUTORS);
+    HttpClientErrorException e = assertThrows(HttpClientErrorException.class, () -> {
+      this.publicationService.create(publication);
+    });
+    List<FieldValidationError> validationErrors = this.getValidationErrors(e.getResponseBodyAsString());
+    assertTrue(this.validationErrorsContain("contributors.contributors", "Missing author for this subtype of publication:'" +  this.PUBLICATION_SUBTYPE_THESE_NAME + "'", validationErrors));
+  }
+
   @Test
   void testRepeatedContributors() {
     Map<String, Object> metadataProperties = this.getBasicMetadataProperties();

AoU-IntegrationTests/src/test/java/ch/unige/aou/test/admin/LicenseIT.java

@@ -32,6 +32,7 @@ class LicenseIT extends AbstractAdminIT {
     // Create a license
     License expectedLicense = new License();
     expectedLicense.setTitle(AouConstants.TEMPORARY_TEST_DATA_LABEL + "GNU Free Documentation License ");
+    expectedLicense.setSortValue(10);
     final String gnuLicense = "GNU" + ThreadLocalRandom.current().nextInt();
     expectedLicense.setOpenLicenseId(gnuLicense);
     expectedLicense = this.licenseService.create(expectedLicense);
@@ -59,6 +60,7 @@ class LicenseIT extends AbstractAdminIT {
     License expectedLicense = new License();
     expectedLicense.setTitle(AouConstants.TEMPORARY_TEST_DATA_LABEL + "License  " + ThreadLocalRandom.current().nextInt());
     expectedLicense.setOpenLicenseId("License  " + ThreadLocalRandom.current().nextInt());
+    expectedLicense.setSortValue(10);
     expectedLicense = this.licenseService.create(expectedLicense);
 
     // Delete
@@ -76,6 +78,7 @@ class LicenseIT extends AbstractAdminIT {
     final License expectedLicense = new License();
     expectedLicense.setTitle(AouConstants.TEMPORARY_TEST_DATA_LABEL + " License  " + ThreadLocalRandom.current().nextInt());
     expectedLicense.setOpenLicenseId("License  " + ThreadLocalRandom.current().nextInt());
+    expectedLicense.setSortValue(10);
 
     this.licenseService.create(expectedLicense);
 
@@ -93,7 +96,7 @@ class LicenseIT extends AbstractAdminIT {
     String actualPayload = this.licenseService.importLicenseFile(AOU_IMPORT_FILE_NAME).getBody();
     assertEquals(expectedPayload, actualPayload);
     // Test import as openLicense file format
-    expectedPayload = new JSONObject().put("imported", 109).toString();
+    expectedPayload = new JSONObject().put("imported", 11).toString();
     actualPayload = this.licenseService.importOpenLicenseFile(ALL_IMPORT_FILE_NAME).getBody();
     assertEquals(expectedPayload, actualPayload);
     // Test import as ckan file format
@@ -162,6 +165,7 @@ class LicenseIT extends AbstractAdminIT {
     assertEquals(expectedLicense.getOdConformance(), actualLicense.getOsdConformance());
     assertEquals(expectedLicense.getOsdConformance(), actualLicense.getOsdConformance());
     assertEquals(expectedLicense.getStatus(), actualLicense.getStatus());
+    assertEquals(expectedLicense.getSortValue(), actualLicense.getSortValue());
     assertEquals(expectedLicense.getUrl(), actualLicense.getUrl());
     assertEquals(expectedLicense.getOpenLicenseId() + " (" + expectedLicense.getTitle() + ")", actualLicense.getDescription());
   }

AoU-Model/pom.xml

-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <parent>
         <groupId>ch.unige.aou</groupId>

AoU-Model/src/main/java/ch/unige/aou/model/settings/License.java

@@ -172,6 +172,12 @@ public class License extends AouSearchableResourceNormalized<License> {
   @NotNull
   private String title;
 
+  /**
+   * Property allowing to sort subtypes in lists
+   */
+  @Column(nullable = false)
+  private Integer sortValue;
+
   private URL url;
 
   public String getDescription() {
@@ -224,6 +230,14 @@ public class License extends AouSearchableResourceNormalized<License> {
     return this.title;
   }
 
+  public Integer getSortValue() {
+    return this.sortValue;
+  }
+
+  public void setSortValue(Integer sort) {
+    this.setCurrentProperty(sort);
+  }
+
   public URL getUrl() {
     return this.url;
   }

AoU-Model/src/main/java/ch/unige/aou/rest/AouActionName.java

@@ -29,6 +29,7 @@ public class AouActionName {
   public static final String GET_METADATA_FROM_ARXIV = "get-metadata-from-arxiv";
   public static final String IMPORT_FILE_ARXIV = "import-file-from-arxiv";
   public static final String GET_METADATA_FROM_PMID = "get-metadata-from-pmid";
+  public static final String GET_ROMEO_INFOS = "get-romeo-infos";
   public static final String LIST_VALIDATOR_COMMENTS = "list-validator-comments";
   public static final String GET_MY_DEFAULT_PROFILE_DATA = "get-my-default-profile-data";
   public static final String GET_JOURNAL_TITLES = "get-journal-titles";

AoU-Model/src/main/java/ch/unige/aou/specification/LicenseSpecification.java

@@ -34,5 +34,8 @@ public class LicenseSpecification extends SolidifySpecification<License> {
     if (this.criteria.getFamily() != null) {
       predicatesList.add(builder.like(root.get("family"), "%" + this.criteria.getFamily() + "%"));
     }
+    if (this.criteria.getSortValue() != null) {
+      predicatesList.add(builder.equal(root.get("sortValue"), this.criteria.getSortValue()));
+    }
   }
 }

AoU-Model/src/main/java/ch/unige/aou/specification/PublicationSpecification.java

 package ch.unige.aou.specification;
 
+import java.time.OffsetDateTime;
+import java.util.Arrays;
 import java.util.List;
+import java.util.stream.Collectors;
 import javax.persistence.criteria.CriteriaBuilder;
 import javax.persistence.criteria.CriteriaQuery;
 import javax.persistence.criteria.Predicate;
 import javax.persistence.criteria.Root;
 
 import ch.unige.solidify.specification.SolidifySpecification;
+import ch.unige.solidify.util.StringTool;
 
 import ch.unige.aou.model.publication.Publication;
 
 public class PublicationSpecification extends SolidifySpecification<Publication> {
   private static final long serialVersionUID = -2649320901418924922L;
 
+  private String fullName;
+
   public PublicationSpecification(Publication criteria) {
     super(criteria);
   }
@@ -35,5 +41,22 @@ public class PublicationSpecification extends SolidifySpecification<Publication>
     if (this.criteria.getMetadata() != null) {
       predicatesList.add(builder.like(root.get("metadata"), "%" + this.criteria.getMetadata() + "%"));
     }
+    if (this.criteria.getSubtype() != null && this.criteria.getSubtype().getResId() != null) {
+      predicatesList.add(builder.equal(root.get("subtype").get("resId"), this.criteria.getSubtype().getResId()));
+    }
+    if (!StringTool.isNullOrEmpty(fullName)) {
+      List<String> listTerm = Arrays.stream(fullName.split(" ")).filter(term -> !StringTool.isNullOrEmpty(term)).collect(Collectors.toList());
+      if (listTerm.size() > 0) {
+        for (String term : listTerm) {
+          Predicate likeFirstName = builder.like(root.get("creator").get("firstName"), "%" + term + "%");
+          Predicate likeLastName = builder.like(root.get("creator").get("lastName"), "%" + term + "%");
+          predicatesList.add(builder.or(likeFirstName, likeLastName));
+        }
+      }
+    }
+  }
+
+  public void setFullName(String fullName) {
+    this.fullName = fullName;
   }
 }

AoU-ResourceServerCommon/src/main/java/ch/unige/aou/business/ContributorRoleService.java

@@ -114,17 +114,17 @@ public class ContributorRoleService extends AouResourceService<ContributorRole>
      * L1     Livre
      * L2     Ouvrage collectif
      * L3     Chapitre de livre
-     * L4     Chapitre d'actes
      * L5     Contribution à un dictionnaire / une encyclopédie
      * C1     Actes de conférence
      * C2     Présentation / Intervention
      * C3     Poster
+     * C4     Chapitre d'actes
      * R1     Rapport de recherche
      * R2     Rapport technique
      * R3     Working paper
      * R4     Preprint
      */
-    subtypeCodes = Arrays.asList("L1", "L2", "L3", "L4", "L5", "C1", "C2", "C3", "R1", "R2", "R3", "R4");
+    subtypeCodes = Arrays.asList("L1", "L2", "L3", "L5", "C1", "C2", "C3", "C4", "R1", "R2", "R3", "R4");
     // @formatter:off
     valuesWithTranslations = Arrays.asList(
             valueAuthor,

AoU-ResourceServerCommon/src/main/java/ch/unige/aou/business/DocumentFileTypeService.java

@@ -124,6 +124,21 @@ public class DocumentFileTypeService extends AouResourceService<DocumentFileType
     this.createSecondaryFileTypes(subtypeCodes);
     this.createCorrectiveFileTypes(subtypeCodes);
 
+    /**
+     * C4     Chapitre d'actes
+     */
+    subtypeCodes = Arrays.asList("C4");
+    // @formatter:off
+    valuesWithTranslations = Arrays.asList(
+            this.newValueWithEngFreTranslations("Proceedings chapter (Published version)", DOCUMENT_PUBLISHED_VERSION_EN, DOCUMENT_PUBLISHED_VERSION_FR),
+            this.newValueWithEngFreTranslations("Proceedings chapter (Accepted version)",  DOCUMENT_ACCEPTED_VERSION_EN,  DOCUMENT_ACCEPTED_VERSION_FR),
+            this.newValueWithEngFreTranslations("Proceedings chapter (Submitted version)", DOCUMENT_SUBMITTED_VERSION_EN, DOCUMENT_SUBMITTED_VERSION_FR)
+    );
+    // @formatter:on
+    this.createPrincipalFileTypes(subtypeCodes, valuesWithTranslations);
+    this.createSecondaryFileTypes(subtypeCodes);
+    this.createCorrectiveFileTypes(subtypeCodes);
+
     /**
      * D1     Thèse
      * D4     Thèse de privat-docent
@@ -186,20 +201,6 @@ public class DocumentFileTypeService extends AouResourceService<DocumentFileType
     this.createSecondaryFileTypes(subtypeCodes);
     this.createCorrectiveFileTypes(subtypeCodes);
 
-    /**
-     * L4     Chapitre d'actes
-     */
-    subtypeCodes = Arrays.asList("L4");
-    // @formatter:off
-    valuesWithTranslations = Arrays.asList(
-            this.newValueWithEngFreTranslations("Proceedings chapter (Published version)", DOCUMENT_PUBLISHED_VERSION_EN, DOCUMENT_PUBLISHED_VERSION_FR),
-            this.newValueWithEngFreTranslations("Proceedings chapter (Accepted version)",  DOCUMENT_ACCEPTED_VERSION_EN,  DOCUMENT_ACCEPTED_VERSION_FR),
-            this.newValueWithEngFreTranslations("Proceedings chapter (Submitted version)", DOCUMENT_SUBMITTED_VERSION_EN, DOCUMENT_SUBMITTED_VERSION_FR)
-    );
-    // @formatter:on
-    this.createPrincipalFileTypes(subtypeCodes, valuesWithTranslations);
-    this.createSecondaryFileTypes(subtypeCodes);
-    this.createCorrectiveFileTypes(subtypeCodes);
 
     /**
      * L5     Contribution à un dictionnaire / une encyclopédie

AoU-ResourceServerCommon/src/main/java/ch/unige/aou/business/LicenseService.java

@@ -2,12 +2,15 @@ package ch.unige.aou.business;
 
 import java.net.MalformedURLException;
 import java.net.URL;
+import java.util.Optional;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
 
+import ch.unige.aou.AouConstants;
 import ch.unige.aou.model.settings.License;
+import ch.unige.aou.model.settings.Structure;
 import ch.unige.aou.repository.LicenseRepository;
 import ch.unige.aou.specification.LicenseSpecification;
 
@@ -71,4 +74,19 @@ public class LicenseService extends AouResourceService<License> {
       log.info("License '{}' created", openLicenseId);
     }
   }
+
+  @Override
+  protected void beforeValidate(License item) {
+
+    // Calculates a default sort value if no one is given
+    if (!this.itemRepository.existsById(item.getResId()) && item.getSortValue() == null) {
+      Optional<Integer> maxValueOpt = this.getMaxSortValue();
+      int newOrder = maxValueOpt.isPresent() ? maxValueOpt.get() + AouConstants.ORDER_INCREMENT : AouConstants.ORDER_INCREMENT;
+      item.setSortValue(newOrder);
+    }
+  }
+
+  public Optional<Integer> getMaxSortValue() {
+    return ((LicenseRepository) this.itemRepository).findMaxSortValue();
+  }
 }

AoU-ResourceServerCommon/src/main/java/ch/unige/aou/business/PublicationService.java

@@ -86,9 +86,11 @@ public class PublicationService extends AouResourceService<Publication> {
     this.contributorService = contributorService;
   }
 
-  public Page<Publication> findMyPublications(Publication filterItem, String personId, String cnIndividu, Pageable pageable) {
+  public Page<Publication> findMyPublications(Publication filterItem, String personId, String cnIndividu, Pageable pageable, String fullName) {
     // Use a specification specifically made to find the publications that has the same creator OR the same cnIndividu
-    Specification specification = new PublicationContributorSpecification(filterItem, personId, cnIndividu);
+    PublicationContributorSpecification specification = new PublicationContributorSpecification(filterItem, personId, cnIndividu);
+
+    specification.setFullName(fullName);
 
     return this.findAll(specification, pageable);
   }

AoU-ResourceServerCommon/src/main/java/ch/unige/aou/business/PublicationSubtypeService.java

@@ -76,6 +76,7 @@ public class PublicationSubtypeService extends AouResourceService<PublicationSub
     this.createPublicationSubtype(type, "Actes de conférence", "C1", (sort = sort + 10));
     this.createPublicationSubtype(type, "Présentation / Intervention", "C2", (sort = sort + 10));
     this.createPublicationSubtype(type, "Poster", "C3", (sort = sort + 10));
+    this.createPublicationSubtype(type, "Chapitre d'actes", "C4", (sort = sort + 10));
 
     type = "Diplôme";
     this.createPublicationSubtype(type, "Thèse", "D1", (sort = sort + 10));
@@ -90,7 +91,6 @@ public class PublicationSubtypeService extends AouResourceService<PublicationSub
     this.createPublicationSubtype(type, "Livre", "L1", (sort = sort + 10));
     this.createPublicationSubtype(type, "Ouvrage collectif", "L2", (sort = sort + 10));
     this.createPublicationSubtype(type, "Chapitre de livre", "L3", (sort = sort + 10));
-    this.createPublicationSubtype(type, "Chapitre d'actes", "L4", (sort = sort + 10));
     this.createPublicationSubtype(type, "Contribution à un dictionnaire / une encyclopédie", "L5", (sort = sort + 10));
 
     type = "Rapport";
@@ -120,4 +120,9 @@ public class PublicationSubtypeService extends AouResourceService<PublicationSub
       log.warn("unable to create PublicationSubtype {} as PublicationType {} does not exist", name, typeName);
     }
   }
+
+  public boolean isThesisOrMasterOrAdvancedMaster(String subtype) {
+    return subtype.equals(this.findByName("Thèse").getName()) || subtype.equals(this.findByName("Master d'études avancées").getName()) || subtype
+            .equals(this.findByName("Master").getName());
+  }
 }

AoU-ResourceServerCommon/src/main/java/ch/unige/aou/repository/LicenseRepository.java

 package ch.unige.aou.repository;
 
+import java.util.Optional;
+
+import org.springframework.data.jpa.repository.Query;
 import org.springframework.stereotype.Repository;
 
 import ch.unige.aou.model.settings.License;
@@ -15,5 +18,6 @@ public interface LicenseRepository extends SolidifyRepository<License> {
 
   License findByOpenLicenseId(String openLicenseid);
 
-
+  @Query(value = "SELECT max(sortValue) FROM License")
+  Optional<Integer> findMaxSortValue();
 }

AoU-ResourceServerCommon/src/main/java/ch/unige/aou/service/metadata/MetadataValidatorService.java

@@ -52,6 +52,8 @@ public abstract class MetadataValidatorService implements MetadataValidator {
   protected static final String ERROR_INVALID_ARXIVID = "deposit.error.container.identifiers.invalid_arxiv";
   protected static final String ERROR_INVALID_URN = "deposit.error.container.identifiers.invalid_urn";
   private static final String ERROR_CONTRIBUTOR_APPEARS_MORE_THAN_ONCE = "deposit.error.contributors.appears_more_than_once";
+  private static final String ERROR_MISSING_AUTHOR_IN_CONTRIBUTORS = "deposit.error.contributors.missing_author_in_contributors";
+  private static final String ERROR_MISSING_DIRECTOR_IN_CONTRIBUTORS = "deposit.error.contributors.missing_director_in_contributors";
   protected static final String ERROR_FIELD_CANNOT_BE_EMPTY = "deposit.error.field_cannot_be_empty";
   protected static final String ERROR_FIELD_INVALID_VALUE = "deposit.error.field_invalid_value";
   private static final String ERROR_STRUCTURE_INVALID_CODE = "deposit.error.structure.invalid_code";
@@ -122,6 +124,7 @@ public abstract class MetadataValidatorService implements MetadataValidator {
   protected void validateFormContributorsStep(Publication publication, Object depositDocObj, BindingResult errors) {
     this.validateContributorsProperties(publication, depositDocObj, errors);
     this.validateContributorsAppearOnce(publication, depositDocObj, errors);
+    this.validateAuthorAndDirectorAppearsOnceForMaster(publication, depositDocObj, errors);
     this.validateResearchGroups(publication, depositDocObj, errors);
     this.validateStructures(publication, depositDocObj, errors);
     this.validateFundings(publication, depositDocObj, errors);
@@ -264,6 +267,32 @@ public abstract class MetadataValidatorService implements MetadataValidator {
     }
   }
 
+  protected void validateAuthorAndDirectorAppearsOnceForMaster(Publication publication, Object depositDocObj, BindingResult errors) {
+    PublicationSubtype thesisPrivateSubtype = this.publicationSubtypeService.findByName("Thèse de privat-docent");
+    boolean isPrivateThesis = publication.getSubtype().getName().equals(thesisPrivateSubtype.getName());
+    if (this.publicationSubtypeService.isThesisOrMasterOrAdvancedMaster(publication.getSubtype().getName()) || isPrivateThesis) {
+      List<AbstractContributor> contributors = this.metadataExtractor.getContributors(depositDocObj);
+      boolean isThereAuthorInContributors = contributors.stream().filter(c -> c instanceof ContributorDTO)
+              .anyMatch(c -> ((ContributorDTO) c).getRole().equals("author"));
+      if (!isThereAuthorInContributors) {
+        errors.addError(
+                new FieldError(publication.getClass().getSimpleName(),
+                        FORM_STEP_CONTRIBUTORS_PREFIX + "contributors", this.messageService.get(ERROR_MISSING_AUTHOR_IN_CONTRIBUTORS,
+                        new Object[] { publication.getSubtype().getName() })));
+      }
+      if (!isPrivateThesis) {
+        boolean isThereDirectorInContributors = contributors.stream().filter(c -> c instanceof ContributorDTO)
+                .anyMatch(c -> ((ContributorDTO) c).getRole().equals("director"));
+        if (!isThereDirectorInContributors) {
+          errors.addError(
+                  new FieldError(publication.getClass().getSimpleName(),
+                          FORM_STEP_CONTRIBUTORS_PREFIX + "contributors", this.messageService.get(ERROR_MISSING_DIRECTOR_IN_CONTRIBUTORS,
+                          new Object[] { publication.getSubtype().getName() })));
+        }
+      }
+    }
+  }
+
   protected void validateResearchGroups(Publication publication, Object depositDocObj, BindingResult errors) {
     List<ResearchGroup> researchGroups = this.metadataExtractor.getResearchGroups(depositDocObj);
 

AoU-ResourceServerCommon/src/test/java/ch/unige/aou/test/RomeoServiceTest.java

+package ch.unige.aou.test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.core.io.ClassPathResource;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+
+import ch.unige.solidify.config.SolidifyProperties;
+import ch.unige.solidify.util.FileTool;
+
+import ch.unige.aou.config.AouProperties;
+import ch.unige.aou.service.rest.RomeoService;
+
+public class RomeoServiceTest {
+
+  protected static final String JSON_ROMEO_API_DATA_FILE = "test-romeo-response.json";
+
+  protected AouProperties aouProperties = new AouProperties(new SolidifyProperties());
+  RomeoService romeoService = new RomeoService(this.aouProperties);
+
+  @Test
+  void generateRomeoDataTest() {
+    String jsonRomeoApiData = this.getJsonRomeoApiData();
+    String aouRomeoJson = this.romeoService.transformRomeoJsonDataIntoAouJson("0094-5765", jsonRomeoApiData);
+    assertNotNull(aouRomeoJson);
+
+    try {
+      ObjectMapper mapper = new ObjectMapper();
+      JsonNode aouRomeoNode = mapper.readTree(aouRomeoJson);
+
+      assertTrue(aouRomeoNode.has("issn"));
+      assertEquals("0094-5765", aouRomeoNode.get("issn").asText());
+
+      assertTrue(aouRomeoNode.has("journalType"));
+      assertEquals("Hybrid. This journal contains both subscribers-only and Open Access articles.", aouRomeoNode.get("journalType").asText());
+
+      assertTrue(aouRomeoNode.has("listedInDoaj"));
+      assertFalse(aouRomeoNode.get("listedInDoaj").booleanValue());
+
+      assertTrue(aouRomeoNode.has("title"));
+      assertEquals("Acta Astronautica", aouRomeoNode.get("title").asText());
+
+      assertTrue(aouRomeoNode.has("footer"));
+      ArrayNode footerNode = (ArrayNode) aouRomeoNode.get("footer");
+      assertEquals(2, footerNode.size());
+      assertEquals("If your research project was supported by a funder, more advantageous conditions can apply (see link below).",
+              footerNode.get(0).asText());
+      assertEquals("Whole set of conditions for this journal can be found in Sherpa Romeo: https://v2.sherpa.ac.uk/id/publication/171.",
+              footerNode.get(1).asText());
+
+      assertTrue(aouRomeoNode.has("versions"));
+      JsonNode versionsNode = aouRomeoNode.get("versions");
+      assertTrue(versionsNode.has("accepted"));
+      assertTrue(versionsNode.has("submitted"));
+      assertTrue(versionsNode.has("published"));
+
+      /**
+       * Accepted versions
+       */
+      JsonNode acceptedNode = versionsNode.get("accepted");
+      assertTrue(acceptedNode.has("version"));
+      assertEquals("accepted version", acceptedNode.get("version").asText());
+      assertTrue(acceptedNode.has("policies"));
+      ArrayNode acceptedPoliciesNode = (ArrayNode) acceptedNode.get("policies");
+      assertEquals(1, acceptedPoliciesNode.size());
+      JsonNode acceptedPolicyNode = acceptedPoliciesNode.get(0);
+      assertTrue(acceptedPolicyNode.has("embargo"));
+      assertEquals("24 months", acceptedPolicyNode.get("embargo").asText());
+      assertTrue(acceptedPolicyNode.has("licences"));
+      ArrayNode licencesNode = (ArrayNode) acceptedPolicyNode.get("licences");
+      assertEquals("CC BY-NC-ND", licencesNode.get(0).asText());
+      assertTrue(acceptedPolicyNode.has("oaDiffusion"));
+      JsonNode oaDiffusionNode = acceptedPolicyNode.get("oaDiffusion");
+      assertTrue(oaDiffusionNode.has("icon"));
+      assertEquals("authorized", oaDiffusionNode.get("icon").asText());
+      assertTrue(oaDiffusionNode.has("text"));
+      assertEquals("free access authorized", oaDiffusionNode.get("text").asText());
+
+      /**
+       * Published versions
+       */
+      JsonNode publishedNode = versionsNode.get("published");
+      assertTrue(publishedNode.has("version"));
+      assertEquals("published version", publishedNode.get("version").asText());
+      assertTrue(publishedNode.has("policies"));
+      ArrayNode publishedPoliciesNode = (ArrayNode) publishedNode.get("policies");
+      assertEquals(1, publishedPoliciesNode.size());
+      JsonNode publishedPolicyNode = publishedPoliciesNode.get(0);
+      assertTrue(publishedPolicyNode.has("licences"));
+      ArrayNode publishedLicencesNode = (ArrayNode) publishedPolicyNode.get("licences");
+      assertEquals("CC BY-NC-ND \"4.0\"", publishedLicencesNode.get(0).asText());
+      assertEquals("CC BY", publishedLicencesNode.get(1).asText());
+      assertFalse(publishedPolicyNode.has("embargo"));
+      assertTrue(publishedPolicyNode.has("oaDiffusion"));
+      JsonNode publishedOaDiffusionNode = publishedPolicyNode.get("oaDiffusion");
+      assertTrue(publishedOaDiffusionNode.has("icon"));
+      assertEquals("question", publishedOaDiffusionNode.get("icon").asText());
+      assertTrue(publishedOaDiffusionNode.has("text"));
+      assertEquals(
+              "Free access authorized, as long as an APC fee was paid for the article or the document includes an <em>Open Access</em> or <em>Creative Commons</em> mention",
+              publishedOaDiffusionNode.get("text").asText());
+
+      /**
+       * Submitted version
+       */
+      JsonNode submittedNode = versionsNode.get("submitted");
+      assertTrue(submittedNode.has("version"));
+      assertEquals("submitted version", submittedNode.get("version").asText());
+      assertTrue(submittedNode.has("policies"));
+      ArrayNode submittedPoliciesNode = (ArrayNode) submittedNode.get("policies");
+      assertEquals(1, submittedPoliciesNode.size());
+      JsonNode submittedPolicyNode = submittedPoliciesNode.get(0);
+      assertFalse(submittedPolicyNode.has("licences"));
+      assertFalse(submittedPolicyNode.has("embargo"));
+      assertTrue(submittedPolicyNode.has("oaDiffusion"));
+      JsonNode submittedOaDiffusionNode = submittedPolicyNode.get("oaDiffusion");
+      assertTrue(submittedOaDiffusionNode.has("icon"));
+      assertEquals("authorized", submittedOaDiffusionNode.get("icon").asText());
+      assertTrue(submittedOaDiffusionNode.has("text"));
+      assertEquals("free access authorized", submittedOaDiffusionNode.get("text").asText());
+
+    } catch (JsonProcessingException e) {
+      fail("unable to read Romeo API file");
+    }
+  }
+
+  private String getJsonRomeoApiData() {
+    try (InputStream jsonStream = new ClassPathResource(JSON_ROMEO_API_DATA_FILE).getInputStream()) {
+      return FileTool.toString(jsonStream);
+    } catch (IOException e) {
+      fail("Unable to read " + JSON_ROMEO_API_DATA_FILE + ": " + e.getMessage());
+      return null;
+    }
+  }
+}