diff --git a/config/checkstyle/checkstyle.xml b/config/checkstyle/checkstyle.xml
index 9540e2bd..fe674881 100644
--- a/config/checkstyle/checkstyle.xml
+++ b/config/checkstyle/checkstyle.xml
@@ -245,6 +245,7 @@
             <message key="ws.notPreceded"
                      value="GenericWhitespace ''{0}'' is not preceded with whitespace."/>
         </module>
+        <!--
         <module name="Indentation">
             <property name="basicOffset" value="4"/>
             <property name="braceAdjustment" value="0"/>
@@ -253,6 +254,7 @@
             <property name="lineWrappingIndentation" value="4"/>
             <property name="arrayInitIndent" value="2"/>
         </module>
+        -->
         <module name="AbbreviationAsWordInName">
             <property name="ignoreFinal" value="false"/>
             <property name="allowedAbbreviationLength" value="3"/>
diff --git a/src/main/java/it/gov/innovazione/ndc/controller/SemanticAssetStatSample.java b/src/main/java/it/gov/innovazione/ndc/controller/SemanticAssetStatSample.java
new file mode 100644
index 00000000..7d3052b8
--- /dev/null
+++ b/src/main/java/it/gov/innovazione/ndc/controller/SemanticAssetStatSample.java
@@ -0,0 +1,17 @@
+package it.gov.innovazione.ndc.controller;
+
+import it.gov.innovazione.ndc.harvester.SemanticAssetType;
+import lombok.Builder;
+import lombok.Data;
+
+@Data
+@Builder
+public class SemanticAssetStatSample {
+  private final String resourceUri;
+  private final SemanticAssetType resourceType;
+  private final String rightHolder;
+  private final boolean hasErrors;
+  private final boolean hasWarnings;
+  private final String statusType;
+  private final int yearOfHarvest;
+}
diff --git a/src/main/java/it/gov/innovazione/ndc/controller/SemanticAssetStats.java b/src/main/java/it/gov/innovazione/ndc/controller/SemanticAssetStats.java
index 584efbe2..b8557963 100644
--- a/src/main/java/it/gov/innovazione/ndc/controller/SemanticAssetStats.java
+++ b/src/main/java/it/gov/innovazione/ndc/controller/SemanticAssetStats.java
@@ -1,45 +1,65 @@
 package it.gov.innovazione.ndc.controller;
 
-import lombok.Builder;
-import lombok.Data;
-
 import java.math.BigDecimal;
 import java.math.RoundingMode;
+import lombok.Builder;
+import lombok.Data;
 
 @Data
 @Builder
 public class SemanticAssetStats {
-    private final SemanticAssetTypeStats total;
-    private final SemanticAssetTypeStats controlledVocabulary;
-    private final SemanticAssetTypeStats ontology;
-    private final SemanticAssetTypeStats schema;
-
-    @Data
-    @Builder
-    public static class SemanticAssetTypeStats {
-        private final long current;
-        private final long lastYear;
-        private final StatusStat status;
-
-        public long getIncrementOverLastYear() {
-            return current - lastYear;
-        }
-
-        public double getIncrementPercentageOverLastYear() {
-            BigDecimal bigDecimal = BigDecimal.valueOf(
-                    lastYear == 0
-                            ? 0
-                            : ((double) current - lastYear) / lastYear * 100);
-            return bigDecimal.setScale(1, RoundingMode.HALF_UP).doubleValue();
-        }
+  private final SemanticAssetTypeStats total;
+  private final SemanticAssetTypeStats controlledVocabulary;
+  private final SemanticAssetTypeStats ontology;
+  private final SemanticAssetTypeStats schema;
+
+  private static double round(double value) {
+    BigDecimal bigDecimal = BigDecimal.valueOf(value);
+    return bigDecimal.setScale(1, RoundingMode.HALF_UP).doubleValue();
+  }
+
+  @Data
+  @Builder
+  public static class SemanticAssetTypeStats {
+    private final long current;
+    private final long lastYear;
+    private final StatusStat status;
+
+    public long getIncrementOverLastYear() {
+      return current - lastYear;
+    }
+
+    public double getIncrementPercentageOverLastYear() {
+      return round(lastYear == 0 ? 0 : ((double) current - lastYear) / lastYear * 100);
+    }
+  }
+
+  @Builder
+  public static class StatusStat {
+    private final double archived;
+    private final double published;
+    private final double closedAccess;
+    private final double draft;
+    private final double unknown;
+
+    public double getArchived() {
+      return round(archived * 100);
+    }
+
+    public double getPublished() {
+      return round(published * 100);
+    }
+
+    public double getClosedAccess() {
+      return round(closedAccess * 100);
+    }
+
+    public double getDraft() {
+      return round(draft * 100);
     }
 
-    @Data
-    @Builder
-    public static class StatusStat {
-        private final double archived;
-        private final double published;
-        private final double closedAccess;
-        private final double draft;
+    public double getUnknown() {
+      return round(unknown * 100);
     }
+  }
 }
diff --git a/src/main/java/it/gov/innovazione/ndc/controller/SemanticAssetsController.java b/src/main/java/it/gov/innovazione/ndc/controller/SemanticAssetsController.java
index fe58bd88..c077eb7e 100644
--- a/src/main/java/it/gov/innovazione/ndc/controller/SemanticAssetsController.java
+++ b/src/main/java/it/gov/innovazione/ndc/controller/SemanticAssetsController.java
@@ -1,5 +1,7 @@
 package it.gov.innovazione.ndc.controller;
 
+import static it.gov.innovazione.ndc.gen.dto.Direction.ASC;
+
 import com.github.jsonldjava.shaded.com.google.common.base.CaseFormat;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.media.Content;
@@ -15,21 +17,18 @@
 import it.gov.innovazione.ndc.harvester.model.index.RightsHolder;
 import it.gov.innovazione.ndc.harvester.service.RepositoryService;
 import it.gov.innovazione.ndc.service.SemanticAssetSearchService;
-import lombok.RequiredArgsConstructor;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.domain.Sort;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RestController;
-
 import java.net.URI;
 import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Collectors;
-
-import static it.gov.innovazione.ndc.gen.dto.Direction.ASC;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
 
 @RequiredArgsConstructor
 @RestController
@@ -37,78 +36,34 @@ public class SemanticAssetsController implements SemanticAssetsApi {
     private final SemanticAssetSearchService searchService;
     private final RepositoryService repositoryService;
 
-    /**
-     * GET /semantic-assets/rights-holders
-     * Retrieves the rights holders of the semantic assets.
-     *
-     * @return OK (status code 200)
-     */
-    @Operation(tags = {"semantic-assets"},
-            summary = "Retrieves the rights holders",
-            description = "Retrieves the rights holders of the semantic assets.",
-            operationId = "getRightsHolders",
-            responses = {@ApiResponse(responseCode = "200", description = "OK", content = {
-                @Content(mediaType = "application/json", schema = @Schema(implementation = RightsHolder.class))
-            })})
-    @GetMapping(value = "/semantic-assets/rights-holders", produces = {"application/json"})
-    List<RightsHolder> getRightsHolders() {
+  /**
+   * GET /semantic-assets/rights-holders Retrieves the rights holders of the semantic assets.
+   *
+   * @return OK (status code 200)
+   */
+  @Operation(
+      tags = {"semantic-assets"},
+      summary = "Retrieves the rights holders",
+      description = "Retrieves the rights holders of the semantic assets.",
+      operationId = "getRightsHolders",
+      responses = {
+        @ApiResponse(
+            responseCode = "200",
+            description = "OK",
+            content = {
+              @Content(
+                  mediaType = "application/json",
+                  schema = @Schema(implementation = RightsHolder.class))
+            })
+      })
+  @GetMapping(
+      value = "/semantic-assets/rights-holders",
+      produces = {"application/json"})
+  List<RightsHolder> getRightsHolders() {
         return repositoryService.getRightsHolders();
 
     }
 
-    @Operation(tags = {"semantic-assets"},
-            summary = "Retrieves the statistics",
-            description = "Retrieves the statistics of the semantic assets.",
-            operationId = "getStats",
-            responses = {@ApiResponse(responseCode = "200", description = "OK", content = {
-                @Content(mediaType = "application/json", schema = @Schema(implementation = SemanticAssetStats.class))
-            })})
-    @GetMapping(value = "/semantic-assets/stats", produces = {"application/json"})
-    SemanticAssetStats getStats() {
-        return SemanticAssetStats.builder()
-                .total(SemanticAssetStats.SemanticAssetTypeStats.builder()
-                        .current(118)
-                        .lastYear(115)
-                        .status(SemanticAssetStats.StatusStat.builder()
-                                .archived(0.1)
-                                .published(0.8)
-                                .closedAccess(0.1)
-                                .draft(0.0)
-                                .build())
-                        .build())
-                .controlledVocabulary(SemanticAssetStats.SemanticAssetTypeStats.builder()
-                        .current(120)
-                        .lastYear(118)
-                        .status(SemanticAssetStats.StatusStat.builder()
-                                .archived(0.1)
-                                .published(0.8)
-                                .closedAccess(0.1)
-                                .draft(0.0)
-                                .build())
-                        .build())
-                .ontology(SemanticAssetStats.SemanticAssetTypeStats.builder()
-                        .current(100)
-                        .lastYear(98)
-                        .status(SemanticAssetStats.StatusStat.builder()
-                                .archived(0.1)
-                                .published(0.8)
-                                .closedAccess(0.1)
-                                .draft(0.0)
-                                .build())
-                        .build())
-                .schema(SemanticAssetStats.SemanticAssetTypeStats.builder()
-                        .current(80)
-                        .lastYear(80)
-                        .status(SemanticAssetStats.StatusStat.builder()
-                                .archived(0.1)
-                                .published(0.8)
-                                .closedAccess(0.1)
-                                .draft(0.0)
-                                .build())
-                        .build())
-                .build();
-    }
-
     @Override
     public ResponseEntity<SearchResult> search(
             String q,
diff --git a/src/main/java/it/gov/innovazione/ndc/controller/SemanticAssetsStatsController.java b/src/main/java/it/gov/innovazione/ndc/controller/SemanticAssetsStatsController.java
new file mode 100644
index 00000000..e863c60e
--- /dev/null
+++ b/src/main/java/it/gov/innovazione/ndc/controller/SemanticAssetsStatsController.java
@@ -0,0 +1,46 @@
+package it.gov.innovazione.ndc.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import it.gov.innovazione.ndc.harvester.service.SemanticContentStatsService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.time.LocalDate;
+
+@RequiredArgsConstructor
+@RestController
+public class SemanticAssetsStatsController {
+
+  private final SemanticContentStatsService semanticContentStatsService;
+
+  @Operation(
+      tags = {"semantic-assets"},
+      summary = "Retrieves the statistics",
+      description = "Retrieves the statistics of the semantic assets.",
+      operationId = "getStats",
+      responses = {
+        @ApiResponse(
+            responseCode = "200",
+            description = "OK",
+            content = {
+              @Content(
+                  mediaType = "application/json",
+                  schema = @Schema(implementation = SemanticAssetStats.class))
+            })
+      })
+  @GetMapping(
+      value = "semantic-assets/stats",
+      produces = {"application/json"})
+  public SemanticAssetStats getStats(@RequestParam(name = "year", required = false) Integer year) {
+    // get current year from system date
+    if (year == null) {
+      year = LocalDate.now().getYear();
+    }
+    return semanticContentStatsService.getStats(year);
+  }
+}
diff --git a/src/main/java/it/gov/innovazione/ndc/harvester/model/SemanticAssetModelValidationContext.java b/src/main/java/it/gov/innovazione/ndc/harvester/model/SemanticAssetModelValidationContext.java
index 8a396aea..77c32668 100644
--- a/src/main/java/it/gov/innovazione/ndc/harvester/model/SemanticAssetModelValidationContext.java
+++ b/src/main/java/it/gov/innovazione/ndc/harvester/model/SemanticAssetModelValidationContext.java
@@ -1,15 +1,14 @@
 package it.gov.innovazione.ndc.harvester.model;
 
 import it.gov.innovazione.ndc.validator.model.ValidationOutcome;
-import lombok.Builder;
-import lombok.Data;
-
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
+import lombok.Builder;
+import lombok.Data;
 
 @Data
 @Builder(toBuilder = true)
@@ -74,7 +73,7 @@ private static List<ValidationOutcome> getNormalized(List<ValidationOutcome> val
                 .collect(Collectors.toList());
     }
 
-    public void addValidationException(RuntimeException invalidModelException) {
+    public synchronized void addValidationException(RuntimeException invalidModelException) {
         if (validationContextType == ValidationContextType.ERROR) {
             if (getNormalizedErrors().contains(invalidModelException.getMessage())) {
                 return;
diff --git a/src/main/java/it/gov/innovazione/ndc/harvester/pathprocessors/BaseSemanticAssetPathProcessor.java b/src/main/java/it/gov/innovazione/ndc/harvester/pathprocessors/BaseSemanticAssetPathProcessor.java
index a0411af8..9cc9337e 100644
--- a/src/main/java/it/gov/innovazione/ndc/harvester/pathprocessors/BaseSemanticAssetPathProcessor.java
+++ b/src/main/java/it/gov/innovazione/ndc/harvester/pathprocessors/BaseSemanticAssetPathProcessor.java
@@ -1,5 +1,12 @@
 package it.gov.innovazione.ndc.harvester.pathprocessors;
 
+import static it.gov.innovazione.ndc.harvester.model.SemanticAssetModelValidationContext.NO_VALIDATION;
+import static it.gov.innovazione.ndc.service.logging.NDCHarvesterLogger.logInfrastructureError;
+import static it.gov.innovazione.ndc.service.logging.NDCHarvesterLogger.logSemanticError;
+import static it.gov.innovazione.ndc.service.logging.NDCHarvesterLogger.logSemanticInfo;
+import static it.gov.innovazione.ndc.service.logging.NDCHarvesterLogger.logSemanticWarn;
+import static java.util.stream.Collectors.toList;
+
 import it.gov.innovazione.ndc.harvester.context.HarvestExecutionContext;
 import it.gov.innovazione.ndc.harvester.context.HarvestExecutionContextUtils;
 import it.gov.innovazione.ndc.harvester.exception.SinglePathProcessingException;
@@ -15,20 +22,12 @@
 import it.gov.innovazione.ndc.repository.TripleStoreRepository;
 import it.gov.innovazione.ndc.service.logging.HarvesterStage;
 import it.gov.innovazione.ndc.service.logging.LoggingContext;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.jena.rdf.model.Resource;
-
 import java.util.Collections;
 import java.util.Objects;
 import java.util.Optional;
-
-import static it.gov.innovazione.ndc.harvester.model.SemanticAssetModelValidationContext.NO_VALIDATION;
-import static it.gov.innovazione.ndc.service.logging.NDCHarvesterLogger.logInfrastructureError;
-import static it.gov.innovazione.ndc.service.logging.NDCHarvesterLogger.logSemanticError;
-import static it.gov.innovazione.ndc.service.logging.NDCHarvesterLogger.logSemanticInfo;
-import static it.gov.innovazione.ndc.service.logging.NDCHarvesterLogger.logSemanticWarn;
-import static java.util.stream.Collectors.toList;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.jena.rdf.model.Resource;
 
 @RequiredArgsConstructor
 @Slf4j
@@ -51,7 +50,7 @@ protected HarvesterStatsHolder processWithModel(String repoUrl, P path, M model)
         SemanticAssetModelValidationContext.ValidationContextStats statsBefore = getStats(model);
         SemanticAssetMetadata meta = indexMetadataForSearch(model);
         SemanticAssetModelValidationContext.ValidationContextStats statsAfter = getStats(model);
-        persistModelToTripleStore(repoUrl, path, model);
+        persistModelToTripleStore(repoUrl, model);
         collectRightsHolderInContext(repoUrl, model);
         return HarvesterStatsHolder.builder()
                 .metadata(meta)
@@ -98,10 +97,9 @@ public HarvesterStatsHolder process(String repoUrl, P path) {
         try {
             log.info("Processing path {}", path);
 
-            log.debug("Loading model");
+            log.debug("Loading model from {}", path);
             M model = loadModel(path.getTtlPath(), repoUrl);
 
-            log.debug("Extracting main resource");
             Resource resource = model.getMainResource();
             log.info("Found resource {}", resource);
 
@@ -152,15 +150,15 @@ private SemanticAssetMetadata indexMetadataForSearch(M model) {
     protected void postProcessMetadata(SemanticAssetMetadata metadata) {
         if (Objects.nonNull(metadata)) {
             metadata.setKeyClassesLabels(
-                    Optional.ofNullable(metadata)
+                    Optional.of(metadata)
                             .map(SemanticAssetMetadata::getKeyClasses)
                             .orElse(Collections.emptyList()).stream()
                             .map(NodeSummary::getSummary)
-                            .collect(toList()));
+                            .toList());
         }
     }
 
-    private void persistModelToTripleStore(String repoUrl, P path, M model) {
+    private void persistModelToTripleStore(String repoUrl, M model) {
         log.debug("Storing RDF content for {} in Virtuoso", model.getMainResource());
         try {
             tripleStoreRepository.save(repoUrl, model.getRdfModel());
diff --git a/src/main/java/it/gov/innovazione/ndc/harvester/pathprocessors/ControlledVocabularyPathProcessor.java b/src/main/java/it/gov/innovazione/ndc/harvester/pathprocessors/ControlledVocabularyPathProcessor.java
index 2b4ee07c..29385b5c 100644
--- a/src/main/java/it/gov/innovazione/ndc/harvester/pathprocessors/ControlledVocabularyPathProcessor.java
+++ b/src/main/java/it/gov/innovazione/ndc/harvester/pathprocessors/ControlledVocabularyPathProcessor.java
@@ -1,5 +1,8 @@
 package it.gov.innovazione.ndc.harvester.pathprocessors;
 
+import static it.gov.innovazione.ndc.service.logging.NDCHarvesterLogger.logSemanticError;
+import static it.gov.innovazione.ndc.service.logging.NDCHarvesterLogger.logSemanticInfo;
+
 import it.gov.innovazione.ndc.harvester.csv.CsvParser;
 import it.gov.innovazione.ndc.harvester.csv.CsvParser.CsvData;
 import it.gov.innovazione.ndc.harvester.model.ControlledVocabularyModel;
@@ -15,16 +18,12 @@
 import it.gov.innovazione.ndc.service.VocabularyIdentifier;
 import it.gov.innovazione.ndc.service.logging.HarvesterStage;
 import it.gov.innovazione.ndc.service.logging.LoggingContext;
+import java.util.List;
+import java.util.stream.Collectors;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Component;
 
-import java.util.List;
-import java.util.stream.Collectors;
-
-import static it.gov.innovazione.ndc.service.logging.NDCHarvesterLogger.logSemanticError;
-import static it.gov.innovazione.ndc.service.logging.NDCHarvesterLogger.logSemanticInfo;
-
 @Component
 @Slf4j
 public class ControlledVocabularyPathProcessor extends BaseSemanticAssetPathProcessor<CvPath, ControlledVocabularyModel> {
@@ -53,7 +52,7 @@ protected HarvesterStatsHolder processWithModel(String repoUrl, CvPath path, Con
             String agencyId = model.getAgencyId().getIdentifier();
             VocabularyIdentifier vocabularyIdentifier = new VocabularyIdentifier(agencyId, keyConcept);
 
-            logSemanticError(LoggingContext.builder()
+            logSemanticInfo(LoggingContext.builder()
                     .stage(HarvesterStage.PROCESS_RESOURCE)
                     .harvesterStatus(HarvesterRun.Status.RUNNING)
                     .message("Indexing CSV for " + vocabularyIdentifier)
diff --git a/src/main/java/it/gov/innovazione/ndc/harvester/service/SemanticContentStatsService.java b/src/main/java/it/gov/innovazione/ndc/harvester/service/SemanticContentStatsService.java
index a345adde..c5ae2647 100644
--- a/src/main/java/it/gov/innovazione/ndc/harvester/service/SemanticContentStatsService.java
+++ b/src/main/java/it/gov/innovazione/ndc/harvester/service/SemanticContentStatsService.java
@@ -1,91 +1,251 @@
 package it.gov.innovazione.ndc.harvester.service;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
+import it.gov.innovazione.ndc.controller.SemanticAssetStatSample;
+import it.gov.innovazione.ndc.controller.SemanticAssetStats;
+import it.gov.innovazione.ndc.harvester.SemanticAssetType;
 import it.gov.innovazione.ndc.harvester.context.HarvestExecutionContext;
 import it.gov.innovazione.ndc.harvester.context.HarvestExecutionContextUtils;
 import it.gov.innovazione.ndc.harvester.model.HarvesterStatsHolder;
 import it.gov.innovazione.ndc.model.harvester.SemanticContentStats;
 import it.gov.innovazione.ndc.service.logging.LoggingContext;
 import it.gov.innovazione.ndc.service.logging.NDCHarvesterLogger;
+import java.sql.ResultSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.CollectionUtils;
 import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.RowMapper;
 import org.springframework.stereotype.Service;
 
-import java.util.List;
-import java.util.Objects;
-import java.util.UUID;
-
 @Service
 @Slf4j
 @RequiredArgsConstructor
 public class SemanticContentStatsService {
 
-    private final JdbcTemplate jdbcTemplate;
-    private final ObjectMapper objectMapper;
+  public static final String HAS_STATS_QUERY =
+      """
+            select 1
+            where exists (select 1
+                          from SEMANTIC_CONTENT_STATS SCS
+                                   JOIN LATEST_HARVESTER_RUN_BY_YEAR LHRBY on SCS.HARVESTER_RUN_ID = LHRBY.ID
+                          where YEAR(LHRBY.STARTED) = ?);
+            """;
+  public static final String GET_STATS_QUERY =
+      """
+              select SCS.RESOURCE_URI,
+                     SCS.RESOURCE_TYPE,
+                     SCS.RIGHT_HOLDER,
+                     SCS.HAS_ERRORS,
+                     SCS.HAS_WARNINGS,
+                     CASE
+                         WHEN JSON_CONTAINS(lower(SCS.STATUS), '\\"archived\\"') THEN 'Archiviato'
+                         WHEN JSON_CONTAINS(lower(SCS.STATUS), '\\"catalogued\\"') || JSON_CONTAINS(lower(SCS.STATUS), '\\"published\\"') THEN 'Stabile'
+                         WHEN JSON_CONTAINS(lower(SCS.STATUS), '\\"closed access\\"') THEN 'Accesso Ristretto'
+                         WHEN JSON_CONTAINS(lower(SCS.STATUS), '\\"initial draft\\"') ||
+                              JSON_CONTAINS(lower(SCS.STATUS), '\\"draft\\"') ||
+                              JSON_CONTAINS(lower(SCS.STATUS), '\\"final draft\\"') ||
+                              JSON_CONTAINS(lower(SCS.STATUS), '\\"intermediate draft\\"') ||
+                              JSON_CONTAINS(lower(SCS.STATUS), '\\"submitted\\"')
+                              THEN 'Bozza'
+                         ELSE 'unknown'
+                         END          as STATUS_TYPE,
+                     YEAR(LHRBY.STARTED) as YEAR_OF_HARVEST
+              from SEMANTIC_CONTENT_STATS SCS
+                       JOIN LATEST_HARVESTER_RUN_BY_YEAR LHRBY on SCS.HARVESTER_RUN_ID = LHRBY.ID
+              where YEAR(LHRBY.STARTED) = ? OR YEAR(LHRBY.STARTED) = ?;
+              """;
+  public static final RowMapper<SemanticAssetStatSample> SEMANTIC_ASSET_STAT_SAMPLE_ROW_MAPPER =
+      (rs, rowNum) ->
+          SemanticAssetStatSample.builder()
+              .resourceUri(rs.getString("RESOURCE_URI"))
+              .resourceType(SemanticAssetType.valueOf(rs.getString("RESOURCE_TYPE")))
+              .rightHolder(rs.getString("RIGHT_HOLDER"))
+              .hasErrors(rs.getBoolean("HAS_ERRORS"))
+              .hasWarnings(rs.getBoolean("HAS_WARNINGS"))
+              .statusType(rs.getString("STATUS_TYPE"))
+              .yearOfHarvest(rs.getInt("YEAR_OF_HARVEST"))
+              .build();
+  private final JdbcTemplate jdbcTemplate;
+  private final ObjectMapper objectMapper;
 
-    public void saveStats() {
-        List<SemanticContentStats> semanticContentStats = HarvestExecutionContextUtils.getSemanticContentStats();
-        semanticContentStats.forEach(this::save);
-        HarvestExecutionContextUtils.clearSemanticContentStats();
-    }
+  public void saveStats() {
+    List<SemanticContentStats> semanticContentStats =
+        HarvestExecutionContextUtils.getSemanticContentStats();
+    semanticContentStats.forEach(this::save);
+    HarvestExecutionContextUtils.clearSemanticContentStats();
+  }
+
+  public int save(SemanticContentStats semanticContentStats) {
+    String statement =
+        "INSERT INTO SEMANTIC_CONTENT_STATS ("
+            + "ID, "
+            + "HARVESTER_RUN_ID, "
+            + "RESOURCE_URI, "
+            + "RESOURCE_TYPE, "
+            + "RIGHT_HOLDER, "
+            + "ISSUED_ON, "
+            + "MODIFIED_ON, "
+            + "HAS_ERRORS,"
+            + "HAS_WARNINGS, "
+            + "STATUS ) "
+            + "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+    return jdbcTemplate.update(
+        statement,
+        UUID.randomUUID().toString(),
+        semanticContentStats.getHarvesterRunId(),
+        semanticContentStats.getResourceUri(),
+        semanticContentStats.getResourceType().name(),
+        semanticContentStats.getRightHolder(),
+        semanticContentStats.getIssuedOn(),
+        semanticContentStats.getModifiedOn(),
+        semanticContentStats.isHasErrors(),
+        semanticContentStats.isHasWarnings(),
+        toJsonArray(semanticContentStats.getStatus()));
+  }
 
-    public int save(SemanticContentStats semanticContentStats) {
-        String statement = "INSERT INTO SEMANTIC_CONTENT_STATS ("
-                + "ID, "
-                + "HARVESTER_RUN_ID, "
-                + "RESOURCE_URI, "
-                + "RESOURCE_TYPE, "
-                + "RIGHT_HOLDER, "
-                + "ISSUED_ON, "
-                + "MODIFIED_ON, "
-                + "HAS_ERRORS,"
-                + "HAS_WARNINGS, "
-                + "STATUS ) "
-                + "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
-        return jdbcTemplate.update(statement,
-                UUID.randomUUID().toString(),
-                semanticContentStats.getHarvesterRunId(),
-                semanticContentStats.getResourceUri(),
-                semanticContentStats.getResourceType().name(),
-                semanticContentStats.getRightHolder(),
-                semanticContentStats.getIssuedOn(),
-                semanticContentStats.getModifiedOn(),
-                semanticContentStats.isHasErrors(),
-                semanticContentStats.isHasWarnings(),
-                toJsonArray(semanticContentStats.getStatus()));
+  private String toJsonArray(List<String> status) {
+    try {
+      return objectMapper.writeValueAsString(CollectionUtils.emptyIfNull(status));
+    } catch (Exception e) {
+      NDCHarvesterLogger.logApplicationError(
+          LoggingContext.builder()
+              .message("Error converting status to json array")
+              .details(e.getMessage())
+              .additionalInfo("status", status)
+              .build());
+      log.error("Error converting status to json", e);
+      return "[]";
     }
+  }
 
-    private String toJsonArray(List<String> status) {
-        try {
-            return objectMapper.writeValueAsString(CollectionUtils.emptyIfNull(status));
-        } catch (Exception e) {
-            NDCHarvesterLogger.logApplicationError(LoggingContext.builder()
-                    .message("Error converting status to json array")
-                    .details(e.getMessage())
-                    .additionalInfo("status", status)
-                    .build());
-            log.error("Error converting status to json", e);
-            return "[]";
-        }
+  public void updateStats(HarvesterStatsHolder harvesterStatsHolder) {
+    HarvestExecutionContext context = HarvestExecutionContextUtils.getContext();
+    if (Objects.nonNull(context)) {
+      SemanticContentStats stats =
+          SemanticContentStats.builder()
+              .harvesterRunId(context.getRunId())
+              .resourceUri(harvesterStatsHolder.getMetadata().getIri())
+              .hasErrors(harvesterStatsHolder.getValidationContextStats().getErrors() > 0)
+              .hasWarnings(harvesterStatsHolder.getValidationContextStats().getWarnings() > 0)
+              .status(harvesterStatsHolder.getMetadata().getStatus())
+              .rightHolder(harvesterStatsHolder.getMetadata().getAgencyId())
+              .issuedOn(harvesterStatsHolder.getMetadata().getIssuedOn())
+              .modifiedOn(harvesterStatsHolder.getMetadata().getModifiedOn())
+              .resourceType(harvesterStatsHolder.getMetadata().getType())
+              .build();
+      HarvestExecutionContextUtils.addSemanticContentStat(stats);
     }
+  }
+
+  public boolean hasStats(int year) {
+    Boolean result = jdbcTemplate.query(HAS_STATS_QUERY, ResultSet::next, year);
+    return Optional.ofNullable(result).orElse(false);
+  }
+
+  public SemanticAssetStats getStats(int year) {
+    List<SemanticAssetStatSample> samples =
+        jdbcTemplate.query(GET_STATS_QUERY, SEMANTIC_ASSET_STAT_SAMPLE_ROW_MAPPER, year, year - 1);
 
-    public void updateStats(HarvesterStatsHolder harvesterStatsHolder) {
-        HarvestExecutionContext context = HarvestExecutionContextUtils.getContext();
-        if (Objects.nonNull(context)) {
-            SemanticContentStats stats = SemanticContentStats.builder()
-                    .harvesterRunId(context.getRunId())
-                    .resourceUri(harvesterStatsHolder.getMetadata().getIri())
-                    .hasErrors(harvesterStatsHolder.getValidationContextStats().getErrors() > 0)
-                    .hasWarnings(harvesterStatsHolder.getValidationContextStats().getWarnings() > 0)
-                    .status(harvesterStatsHolder.getMetadata().getStatus())
-                    .rightHolder(harvesterStatsHolder.getMetadata().getAgencyId())
-                    .issuedOn(harvesterStatsHolder.getMetadata().getIssuedOn())
-                    .modifiedOn(harvesterStatsHolder.getMetadata().getModifiedOn())
-                    .resourceType(harvesterStatsHolder.getMetadata().getType())
-                    .build();
-            HarvestExecutionContextUtils.addSemanticContentStat(stats);
-        }
+    boolean hasLastYear =
+        samples.stream().anyMatch(sample -> sample.getYearOfHarvest() == year - 1);
+
+    int lastYear = year - 1;
+    if (!hasLastYear) {
+      lastYear = year;
     }
+
+    return SemanticAssetStats.builder()
+        .total(getSemanticAssetTypeStats(samples, year, lastYear, sample -> true))
+        .controlledVocabulary(
+            getSemanticAssetTypeStats(
+                samples,
+                year,
+                lastYear,
+                sample -> sample.getResourceType() == SemanticAssetType.CONTROLLED_VOCABULARY))
+        .ontology(
+            getSemanticAssetTypeStats(
+                samples,
+                year,
+                lastYear,
+                sample -> sample.getResourceType() == SemanticAssetType.ONTOLOGY))
+        .schema(
+            getSemanticAssetTypeStats(
+                samples,
+                year,
+                lastYear,
+                sample -> sample.getResourceType() == SemanticAssetType.SCHEMA))
+        .build();
+  }
+
+  private SemanticAssetStats.SemanticAssetTypeStats getSemanticAssetTypeStats(
+      List<SemanticAssetStatSample> samples,
+      int year,
+      int lastYear,
+      Predicate<SemanticAssetStatSample> filter) {
+    int totalCurrent =
+        (int)
+            samples.stream()
+                .filter(sample -> sample.getYearOfHarvest() == year)
+                .filter(filter)
+                .count();
+    int totalLastYear =
+        (int)
+            samples.stream()
+                .filter(sample -> sample.getYearOfHarvest() == lastYear)
+                .filter(filter)
+                .count();
+    Map<String, List<SemanticAssetStatSample>> byStatus =
+        samples.stream()
+            .filter(sample -> sample.getYearOfHarvest() == year)
+            .filter(filter)
+            .collect(Collectors.groupingBy(SemanticAssetStatSample::getStatusType));
+    return SemanticAssetStats.SemanticAssetTypeStats.builder()
+        .current(totalCurrent)
+        .lastYear(totalLastYear)
+        .status(
+            SemanticAssetStats.StatusStat.builder()
+                .archived(
+                    totalCurrent > 0
+                        ? byStatus.getOrDefault("Archiviato", List.of()).stream()
+                                .filter(filter)
+                                .count()
+                            / (double) totalCurrent
+                        : 0)
+                .published(
+                    totalCurrent > 0
+                        ? byStatus.getOrDefault("Stabile", List.of()).stream()
+                                .filter(filter)
+                                .count()
+                            / (double) totalCurrent
+                        : 0)
+                .closedAccess(
+                    totalCurrent > 0
+                        ? byStatus.getOrDefault("Accesso Ristretto", List.of()).stream()
+                                .filter(filter)
+                                .count()
+                            / (double) totalCurrent
+                        : 0)
+                .draft(
+                    totalCurrent > 0
+                        ? byStatus.getOrDefault("Bozza", List.of()).stream().filter(filter).count()
+                            / (double) totalCurrent
+                        : 0)
+                .unknown(
+                    totalCurrent > 0
+                        ? byStatus.getOrDefault("unknown", List.of()).stream()
+                                .filter(filter)
+                                .count()
+                            / (double) totalCurrent
+                        : 0)
+                .build())
+        .build();
+  }
 }
diff --git a/src/main/java/it/gov/innovazione/ndc/harvester/service/startupjob/Default2024StatPopulator.java b/src/main/java/it/gov/innovazione/ndc/harvester/service/startupjob/Default2024StatPopulator.java
new file mode 100644
index 00000000..ec042863
--- /dev/null
+++ b/src/main/java/it/gov/innovazione/ndc/harvester/service/startupjob/Default2024StatPopulator.java
@@ -0,0 +1,139 @@
+package it.gov.innovazione.ndc.harvester.service.startupjob;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import it.gov.innovazione.ndc.harvester.SemanticAssetType;
+import it.gov.innovazione.ndc.harvester.service.HarvesterRunService;
+import it.gov.innovazione.ndc.harvester.service.RepositoryService;
+import it.gov.innovazione.ndc.harvester.service.SemanticContentStatsService;
+import it.gov.innovazione.ndc.model.harvester.HarvesterRun;
+import it.gov.innovazione.ndc.model.harvester.Repository;
+import it.gov.innovazione.ndc.model.harvester.SemanticContentStats;
+import it.gov.innovazione.ndc.service.logging.LoggingContext;
+import it.gov.innovazione.ndc.service.logging.NDCHarvesterLogger;
+import it.gov.innovazione.ndc.service.logging.NDCHarvesterLoggerUtils;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import lombok.RequiredArgsConstructor;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.tuple.Pair;
+import org.springframework.core.io.Resource;
+import org.springframework.core.io.ResourceLoader;
+import org.springframework.stereotype.Component;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class Default2024StatPopulator implements StartupJob {
+
+    private static final int DEFAULT_YEAR = 2024;
+
+    private final ResourceLoader resourceLoader;
+    private final ObjectMapper objectMapper;
+    private final RepositoryService repositoryService;
+    private final HarvesterRunService harvesterRunService;
+    private final SemanticContentStatsService semanticContentStatsService;
+    private final DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+
+    private Map<String, HarvesterRun> latestHarvesterRunByRepoUrl;
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void run() {
+        try {
+
+            NDCHarvesterLoggerUtils.setInitialContext(LoggingContext.builder()
+                    .component("Default2024StatPopulator")
+                    .build());
+
+            if (defaultDataLoadIsNotNeeded()) {
+                NDCHarvesterLogger.logApplicationInfo(LoggingContext.builder()
+                        .message("Default 2024 stats already loaded")
+                        .build());
+                return;
+            }
+
+            Resource resource = resourceLoader.getResource("classpath:db/default-2024-stats.json");
+            List<Map<String, Object>> default2024StatsPath = objectMapper.readValue(resource.getContentAsString(Charset.defaultCharset()), List.class);
+            List<String> activeRepos = repositoryService.getActiveRepos().stream()
+                    .map(Repository::getUrl)
+                    .toList();
+
+            latestHarvesterRunByRepoUrl = harvesterRunService.getAllRuns().stream()
+                    .filter(harvesterRun -> activeRepos.contains(harvesterRun.getRepositoryUrl()))
+                    .filter(harvesterRun -> LocalDateTime.ofInstant(harvesterRun.getStartedAt(), ZoneId.systemDefault()).getYear() == DEFAULT_YEAR)
+                    .collect(Collectors.groupingBy(HarvesterRun::getRepositoryUrl))
+                    .entrySet().stream()
+                    .map(stringListEntry -> Pair.of(
+                            stringListEntry.getKey(),
+                            stringListEntry.getValue().stream().min(Comparator.comparing(HarvesterRun::getStartedAt)).orElse(null)))
+                    .collect(Collectors.toMap(Pair::getLeft, Pair::getRight));
+
+            default2024StatsPath.forEach(this::insertIfPossible);
+
+            log.info("Default 2024 stats loaded");
+        } catch (RuntimeException | IOException e) {
+            NDCHarvesterLogger.logApplicationError(LoggingContext.builder()
+                    .message("Error while populating default 2024 stats")
+                    .details(e.getMessage())
+                    .build());
+            log.error("Error while reading default 2024 stats", e);
+        }
+    }
+
+    private boolean defaultDataLoadIsNotNeeded() {
+        return semanticContentStatsService.hasStats(DEFAULT_YEAR);
+    }
+
+    @SuppressWarnings("unchecked")
+    @SneakyThrows
+    private void insertIfPossible(Map<String, Object> stat) {
+        try {
+            if (latestHarvesterRunByRepoUrl.containsKey(stat.get("REPOSITORY_URL").toString())) {
+                String repoUrl = stat.get("REPOSITORY_URL").toString();
+                HarvesterRun harvesterRun = latestHarvesterRunByRepoUrl.get(repoUrl);
+                if (harvesterRun != null) {
+                    String harvesterRunId = harvesterRun.getId();
+                    SemanticContentStats semanticContentStats = SemanticContentStats.builder()
+                            .resourceUri(stat.get("RESOURCE_URI").toString())
+                            .harvesterRunId(harvesterRunId)
+                            .resourceType(SemanticAssetType.valueOf(stat.get("RESOURCE_TYPE").toString()))
+                            .rightHolder(stat.get("RIGHT_HOLDER").toString())
+                            .issuedOn(Optional.ofNullable(stat.get("ISSUED_ON"))
+                                    .map(o -> LocalDateTime.parse(o.toString(), dateTimeFormatter).toLocalDate())
+                                    .orElse(null))
+                            .modifiedOn(
+                                    Optional.ofNullable(stat.get("MODIFIED_ON"))
+                                            .map(o -> LocalDateTime.parse(o.toString(), dateTimeFormatter).toLocalDate())
+                                            .orElse(null))
+                            .hasErrors(stat.get("HAS_ERRORS").toString().equals("1"))
+                            .hasWarnings(stat.get("HAS_WARNINGS").toString().equals("1"))
+                            .status(objectMapper.readValue(stat.get("STATUS").toString(), List.class))
+                            .build();
+                    semanticContentStatsService.save(semanticContentStats);
+                }
+            } else {
+                NDCHarvesterLogger.logApplicationWarn(LoggingContext.builder()
+                        .message("Cannot insert default 2024 stats")
+                        .details("No harvester run found for repository " + stat.get("REPOSITORY_URL"))
+                        .build());
+                log.warn("Cannot insert default 2024 stats for " + stat.get("RESOURCE_URI") + ". No harvester run found for repository " + stat.get("REPOSITORY_URL"));
+            }
+        } catch (RuntimeException e) {
+            NDCHarvesterLogger.logApplicationError(LoggingContext.builder()
+                    .message("Error while inserting default 2024 stats for " + stat.get("RESOURCE_URI"))
+                    .details(e.getMessage())
+                    .build());
+            log.error("Error while inserting default " + DEFAULT_YEAR + " stats", e);
+        }
+    }
+}
diff --git a/src/main/java/it/gov/innovazione/ndc/service/logging/NDCHarvesterLoggerUtils.java b/src/main/java/it/gov/innovazione/ndc/service/logging/NDCHarvesterLoggerUtils.java
index b96453e5..2bc23d1d 100644
--- a/src/main/java/it/gov/innovazione/ndc/service/logging/NDCHarvesterLoggerUtils.java
+++ b/src/main/java/it/gov/innovazione/ndc/service/logging/NDCHarvesterLoggerUtils.java
@@ -1,14 +1,13 @@
 package it.gov.innovazione.ndc.service.logging;
 
-import lombok.NoArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.BiFunction;
 import java.util.function.Function;
+import lombok.NoArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 
 @NoArgsConstructor(access = lombok.AccessLevel.PRIVATE)
 @Slf4j
@@ -76,6 +75,4 @@ private static <T> LoggingContext.LoggingContextBuilder addToBuilder(
                 .map(value -> setter.apply(builder, value))
                 .orElse(builder);
     }
-
-
 }
diff --git a/src/main/resources/application-local.properties b/src/main/resources/application-local.properties
index 7713894a..e887ce05 100644
--- a/src/main/resources/application-local.properties
+++ b/src/main/resources/application-local.properties
@@ -1,4 +1,4 @@
-harvester.repositories=https://github.com/FrankMaverick/Leo-OpenData,https://github.com/italia/daf-ontologie-vocabolari-controllati,https://github.com/InailUfficio5/inail-ndc
+harvester.repositories=https://github.com/italia/daf-ontologie-vocabolari-controllati,https://github.com/INPS-it/NDC,https://github.com/isprambiente/dati-semantic,https://github.com/Bluarancio/Leo-OpenData,https://github.com/InailUfficio5/inail-ndc
 
 virtuoso.sparql=http://localhost:8890/sparql-auth
 virtuoso.sparql-graph-store=http://localhost:8890/sparql-graph-crud-auth
diff --git a/src/main/resources/db/default-2024-stats.json b/src/main/resources/db/default-2024-stats.json
new file mode 100644
index 00000000..c72c5f03
--- /dev/null
+++ b/src/main/resources/db/default-2024-stats.json
@@ -0,0 +1,2554 @@
+[
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/env/vocab/bathing_waters/bodies",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "ispra_rm",
+    "ISSUED_ON": "2023-11-13 00:00:00",
+    "MODIFIED_ON": "2024-03-25 00:00:00",
+    "HAS_ERRORS": 1,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/isprambiente/dati-semantic"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/env/onto/rendis",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "ispra_rm",
+    "ISSUED_ON": "2023-03-08 00:00:00",
+    "MODIFIED_ON": "2024-03-12 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"draft\"]",
+    "REPOSITORY_URL": "https://github.com/isprambiente/dati-semantic"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/env/vocab/observations/certainty",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "ispra_rm",
+    "ISSUED_ON": "2023-03-03 00:00:00",
+    "MODIFIED_ON": "2024-03-25 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/isprambiente/dati-semantic"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/env/vocab/bathing_waters/quality",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "ispra_rm",
+    "ISSUED_ON": "2023-11-13 00:00:00",
+    "MODIFIED_ON": "2024-03-25 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/isprambiente/dati-semantic"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/env/vocab/soil-protection/repair-types",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "ispra_rm",
+    "ISSUED_ON": "2024-07-31 00:00:00",
+    "MODIFIED_ON": "2024-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/isprambiente/dati-semantic"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/env/vocab/soil-protection/implementation-plan-steps",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "ispra_rm",
+    "ISSUED_ON": "2024-07-31 00:00:00",
+    "MODIFIED_ON": "2024-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/isprambiente/dati-semantic"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/env/vocab/platforms/datastation_types",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "ispra_rm",
+    "ISSUED_ON": "2023-03-03 00:00:00",
+    "MODIFIED_ON": "2024-03-25 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/isprambiente/dati-semantic"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/env/onto/top",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "ispra_rm",
+    "ISSUED_ON": "2023-03-08 00:00:00",
+    "MODIFIED_ON": "2024-03-12 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"catalogued\",\"published\"]",
+    "REPOSITORY_URL": "https://github.com/isprambiente/dati-semantic"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/env/vocab/soil-protection/instability-categories",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "ispra_rm",
+    "ISSUED_ON": "2024-08-05 00:00:00",
+    "MODIFIED_ON": "2024-08-05 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/isprambiente/dati-semantic"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/env/vocab/platforms/operational_status",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "ispra_rm",
+    "ISSUED_ON": "2023-03-03 00:00:00",
+    "MODIFIED_ON": "2024-03-25 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/isprambiente/dati-semantic"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/env/vocab/soil-protection/instability-types",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "ispra_rm",
+    "ISSUED_ON": "2024-07-31 00:00:00",
+    "MODIFIED_ON": "2024-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/isprambiente/dati-semantic"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/env/onto/inspire-mf",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "ispra_rm",
+    "ISSUED_ON": "2023-03-08 00:00:00",
+    "MODIFIED_ON": "2024-03-12 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\",\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/isprambiente/dati-semantic"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/env/onto/place",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "ispra_rm",
+    "ISSUED_ON": "2023-03-08 00:00:00",
+    "MODIFIED_ON": "2024-03-12 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\",\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/isprambiente/dati-semantic"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/env/vocab/euring/capture_types",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "ispra_rm",
+    "ISSUED_ON": "2023-03-03 00:00:00",
+    "MODIFIED_ON": "2024-03-25 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/isprambiente/dati-semantic"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/settore_correlato_malattia",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-07-22 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/esito-definizione/latest/esito-definizione.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/tipo_definizione_decisione_istruttoria",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-09-07 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/classe_menomazione",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-09-06 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/grande_gruppo_tariffario",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-07-22 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/infortunio/latest/infortunio.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/decisione_istruttoria_esito_mortale",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-07-22 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/proc21_self_liquidation/specie_navigazione",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-12-21 00:00:00",
+    "MODIFIED_ON": "2023-12-27 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/tipo_tecnopatia",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-09-06 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/infortunato/latest/infortunato.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/proc6_pdda1/stato_pratica_pdda1",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2023-08-28 00:00:00",
+    "MODIFIED_ON": "2023-08-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/onto/adm_serv/",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-09-06 00:00:00",
+    "MODIFIED_ON": "2023-12-01 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\",\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/tipo-indennizzo/latest/tipo-indennizzo.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/proc21_self_liquidation/tipo_nave",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-12-21 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/tipo_trattazione",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-09-06 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/agente_materiale",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-07-26 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/luogo_accadimento",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-09-06 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/classificazione_ICDX",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-07-28 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/soggetto-assicurante/latest/soggetto-assicurante.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/agente_causale",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-09-06 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/natura_lesione",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-09-07 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/onto/proc21_self_liquidation/",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-09-06 00:00:00",
+    "MODIFIED_ON": "2023-12-01 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\",\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/core/settore_attivita",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-06-18 00:00:00",
+    "MODIFIED_ON": "2024-06-22 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/tipo_contatto",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-09-06 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/onto/core/",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-09-06 00:00:00",
+    "MODIFIED_ON": "2024-06-07 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\",\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/tipo_lavoratore",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-09-07 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/causa_esterna",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-09-07 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/documento-pdda1/latest/documento-pdda1.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/tecnopatico/latest/tecnopatico.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/tipo-trattazione/latest/tipo-trattazione.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/tipo_malattia",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-09-06 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/definizione_amministrativa",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-07-22 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/sede-inail/latest/sede-inail.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/denuncia-cessazione/latest/denuncia-cessazione.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/deviazione",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-09-06 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/mansione",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-09-07 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/inabilita-temporanea/latest/inabilita-temporanea.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/posizione-assicurativa-territoriale/latest/posizione-assicurativa-territoriale.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/richiesta-pdda1/latest/richiesta-pdda1.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/riapertura-trattazione/latest/riapertura-trattazione.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/persona-fisica/latest/persona-fisica.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/proc21_self_liquidation/servizio_nave",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-12-21 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/malattia-professionale/latest/malattia-professionale.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/onto/proc6_pdda1/",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2023-08-28 00:00:00",
+    "MODIFIED_ON": "2023-11-01 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\",\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/proc6_pdda1/tipo_richiedente_pdda1",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2023-08-28 00:00:00",
+    "MODIFIED_ON": "2023-11-01 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/prestazione-economica/latest/prestazione-economica.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/inabilita",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-09-06 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/attivita_fisica",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-09-06 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/denuncia/latest/denuncia.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/pratica-pdda1/latest/pratica-pdda1.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/proc21_self_liquidation/registro_iscrizione_nave",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-12-21 00:00:00",
+    "MODIFIED_ON": "2023-12-27 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/tipo_lavoro",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-09-06 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/work-accident/controlled-vocabulary/adm_serv/sede_lesione",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2022-09-06 00:00:00",
+    "MODIFIED_ON": "2023-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/trattazione/latest/trattazione.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/indennizzo/latest/indennizzo.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inail",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/InailUfficio5/inail-ndc"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-routes/route-types",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2018-10-19 00:00:00",
+    "MODIFIED_ON": "2018-10-19 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-people/registry-office-registration-types",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "m_it",
+    "ISSUED_ON": "2022-12-15 00:00:00",
+    "MODIFIED_ON": "2023-07-15 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-trasparency/transparency-subject",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "cvtiap",
+    "ISSUED_ON": "2019-10-23 00:00:00",
+    "MODIFIED_ON": "2024-09-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-her/fields-of-research-development",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "unesco",
+    "ISSUED_ON": "2020-06-06 00:00:00",
+    "MODIFIED_ON": "2020-06-06 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-organizations/ateco-2007",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "istat",
+    "ISSUED_ON": "2008-01-01 00:00:00",
+    "MODIFIED_ON": "2020-12-18 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/HER",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "r_toscan",
+    "ISSUED_ON": "2020-04-02 00:00:00",
+    "MODIFIED_ON": "2020-11-06 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"draft\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-people/person-title",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2019-05-06 00:00:00",
+    "MODIFIED_ON": "2019-05-06 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-universities/academic-disciplines",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "m_pi",
+    "ISSUED_ON": "2019-03-05 00:00:00",
+    "MODIFIED_ON": "2020-07-01 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/MU",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-11-13 00:00:00",
+    "MODIFIED_ON": "2020-06-15 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"catalogued\",\"published\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/COV",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-07-20 00:00:00",
+    "MODIFIED_ON": "2020-09-30 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\",\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-organizations/cofog-2009",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "istat",
+    "ISSUED_ON": "2014-07-08 00:00:00",
+    "MODIFIED_ON": "2018-03-14 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/RPO",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "m_it",
+    "ISSUED_ON": "2022-12-31 00:00:00",
+    "MODIFIED_ON": "2024-06-10 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/ACCO",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-10-23 00:00:00",
+    "MODIFIED_ON": "2018-07-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"catalogued\",\"published\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-organizations/S13",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "istat",
+    "ISSUED_ON": "2018-02-22 00:00:00",
+    "MODIFIED_ON": "2018-07-10 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/PARK",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-12-19 00:00:00",
+    "MODIFIED_ON": "2018-06-25 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\",\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/FULL",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2018-01-25 00:00:00",
+    "MODIFIED_ON": "2020-11-06 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/public-event-types",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-10-17 00:00:00",
+    "MODIFIED_ON": "2020-04-08 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-culture/subject-disciplines",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2018-03-06 00:00:00",
+    "MODIFIED_ON": "2019-01-21 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-accommodation-facilities/accommodation-star-rating",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-10-20 00:00:00",
+    "MODIFIED_ON": "2018-02-11 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/ACO",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "m_it",
+    "ISSUED_ON": "2022-12-15 00:00:00",
+    "MODIFIED_ON": "2023-07-15 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/IoT",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-05-15 00:00:00",
+    "MODIFIED_ON": "2020-06-09 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"catalogued\",\"published\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/Language",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2018-06-27 00:00:00",
+    "MODIFIED_ON": "2018-06-27 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"final draft\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-people/education-level",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "istat",
+    "ISSUED_ON": "2018-01-23 00:00:00",
+    "MODIFIED_ON": "2018-06-05 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/Learning",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "kh5rhfcv",
+    "ISSUED_ON": "2023-07-27 00:00:00",
+    "MODIFIED_ON": "2023-11-06 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"draft\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-public-services/life-business-event/business-event",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-10-20 00:00:00",
+    "MODIFIED_ON": "2018-03-14 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/CPEV",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-12-06 00:00:00",
+    "MODIFIED_ON": "2019-04-23 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\",\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/PublicContract",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "cvtiap",
+    "ISSUED_ON": "2018-04-27 00:00:00",
+    "MODIFIED_ON": "2024-09-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"final draft\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-universities/documents-titulus",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "coinfo-unidoc",
+    "ISSUED_ON": "2018-12-15 00:00:00",
+    "MODIFIED_ON": "2018-12-15 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/poi-category-classification",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-10-20 00:00:00",
+    "MODIFIED_ON": "2018-03-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-indicators/indicator-types",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "mds",
+    "ISSUED_ON": "2020-05-26 00:00:00",
+    "MODIFIED_ON": "2020-05-26 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/AccessCondition",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2018-06-18 00:00:00",
+    "MODIFIED_ON": "2018-06-18 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"initial draft\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-people/sex",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "istat",
+    "ISSUED_ON": "2018-01-16 00:00:00",
+    "MODIFIED_ON": "2023-03-15 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/theme-subtheme-mapping",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-10-20 00:00:00",
+    "MODIFIED_ON": "2018-02-12 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/SM",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-09-29 00:00:00",
+    "MODIFIED_ON": "2019-04-24 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\",\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-people/marital-status-types",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "m_it",
+    "ISSUED_ON": "2022-12-15 00:00:00",
+    "MODIFIED_ON": "2023-07-15 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/territorial-classifications/provinces",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2018-06-19 00:00:00",
+    "MODIFIED_ON": "2019-04-03 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/territorial-classifications/regions",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2018-04-12 00:00:00",
+    "MODIFIED_ON": "2023-11-19 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/Indicator",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2020-05-21 00:00:00",
+    "MODIFIED_ON": "2019-05-21 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"initial draft\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-trasparency/transparency-obligation",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "cvtiap",
+    "ISSUED_ON": "2019-07-25 00:00:00",
+    "MODIFIED_ON": "2024-09-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-people/registry-office-removal-types",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "m_it",
+    "ISSUED_ON": "2022-12-15 00:00:00",
+    "MODIFIED_ON": "2023-07-15 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/Route",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "m_bac",
+    "ISSUED_ON": "2018-10-18 00:00:00",
+    "MODIFIED_ON": "2020-04-16 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"initial draft\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-culture/cultural-interest-places",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "m_bac",
+    "ISSUED_ON": "2019-06-21 00:00:00",
+    "MODIFIED_ON": "2020-03-04 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/CPSV",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2015-11-21 00:00:00",
+    "MODIFIED_ON": "2020-09-30 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"final draft\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/POT",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-11-17 00:00:00",
+    "MODIFIED_ON": "2019-04-24 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\",\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/NDC",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "pcm-aa1d3a2",
+    "ISSUED_ON": "2021-11-19 00:00:00",
+    "MODIFIED_ON": "2021-11-19 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/RO",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-11-21 00:00:00",
+    "MODIFIED_ON": "2019-04-23 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\",\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/AtlasOfPaths",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "m_bac",
+    "ISSUED_ON": "2018-10-18 00:00:00",
+    "MODIFIED_ON": "2019-04-24 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"initial draft\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/territorial-classifications/geographical-distribution",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "istat",
+    "ISSUED_ON": "2018-06-19 00:00:00",
+    "MODIFIED_ON": "2019-04-03 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/Project",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2019-05-14 00:00:00",
+    "MODIFIED_ON": "2020-11-01 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"draft\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-accommodation-facilities/accommodation-typology",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-10-17 00:00:00",
+    "MODIFIED_ON": "2018-02-12 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-public-services/interactivity-level",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-10-20 00:00:00",
+    "MODIFIED_ON": "2018-03-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/CPV",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "istat",
+    "ISSUED_ON": "2017-07-19 00:00:00",
+    "MODIFIED_ON": "2023-03-15 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\",\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-public-services/authentication-type",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-10-20 00:00:00",
+    "MODIFIED_ON": "2018-03-14 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-transparency/transparency-titulus",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "cvtiap",
+    "ISSUED_ON": "2018-12-13 00:00:00",
+    "MODIFIED_ON": "2024-09-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/l0",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-09-29 00:00:00",
+    "MODIFIED_ON": "2020-04-16 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-organizations/legal-status",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "istat",
+    "ISSUED_ON": "2018-02-13 00:00:00",
+    "MODIFIED_ON": "2018-02-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-public-services/life-business-event/life-event",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-10-20 00:00:00",
+    "MODIFIED_ON": "2018-03-14 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-public-services/service-input-output",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-10-20 00:00:00",
+    "MODIFIED_ON": "2018-03-14 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-documents/government-documents-types",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2019-07-26 00:00:00",
+    "MODIFIED_ON": "2020-03-09 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-public-services/channel",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-10-20 00:00:00",
+    "MODIFIED_ON": "2018-10-19 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/territorial-classifications/countries/italy",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2018-04-12 00:00:00",
+    "MODIFIED_ON": "2019-04-03 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "http://dati.beniculturali.it/cis",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "m_bac",
+    "ISSUED_ON": "2015-01-12 00:00:00",
+    "MODIFIED_ON": "2019-05-27 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/ADMS",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2018-02-26 00:00:00",
+    "MODIFIED_ON": "2019-04-23 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"draft\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "http://dati.gov.it/onto/dcatapit",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2016-03-18 00:00:00",
+    "MODIFIED_ON": "2022-06-23 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"catalogued\",\"published\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/territorial-classifications/cities",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "istat",
+    "ISSUED_ON": "2018-06-19 00:00:00",
+    "MODIFIED_ON": "2024-06-10 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/TI",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-09-25 00:00:00",
+    "MODIFIED_ON": "2020-11-06 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\",\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/Transparency",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2019-05-30 00:00:00",
+    "MODIFIED_ON": "2020-04-23 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"draft\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-public-services/public-services-subject-matters",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2019-07-30 00:00:00",
+    "MODIFIED_ON": "2022-04-12 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-documents/municipal-notice-board",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2019-07-22 00:00:00",
+    "MODIFIED_ON": "2019-07-22 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/CulturalHeritage",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "m_bac",
+    "ISSUED_ON": "2018-10-15 00:00:00",
+    "MODIFIED_ON": "2019-03-26 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-universities/italian-academic-roles",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "m_pi",
+    "ISSUED_ON": "2020-04-05 00:00:00",
+    "MODIFIED_ON": "2020-05-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/CLV",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "istat",
+    "ISSUED_ON": "2017-08-07 00:00:00",
+    "MODIFIED_ON": "2019-04-29 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"catalogued\",\"published\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-her/all-science-journal",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "elsevier",
+    "ISSUED_ON": "2020-05-20 00:00:00",
+    "MODIFIED_ON": "2020-06-23 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-people/parental-relationship-types",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "istat",
+    "ISSUED_ON": "2019-07-17 00:00:00",
+    "MODIFIED_ON": "2023-03-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/onto/POI",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2017-10-16 00:00:00",
+    "MODIFIED_ON": "2019-04-23 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\",\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/licences",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "agid",
+    "ISSUED_ON": "2018-01-16 00:00:00",
+    "MODIFIED_ON": "2024-09-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/controlled-vocabulary/classifications-for-her/erc-panel-h2020-fp",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "erc",
+    "ISSUED_ON": "2020-06-06 00:00:00",
+    "MODIFIED_ON": "2020-06-11 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/italia/daf-ontologie-vocabolari-controllati"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/onto/analysis",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2019-03-14 00:00:00",
+    "MODIFIED_ON": "2023-07-01 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\"]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/controlled-vocabulary/bovine-carcass-classification",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2021-10-01 00:00:00",
+    "MODIFIED_ON": "2021-10-01 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/onto/milking-efficiency-assessment",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2023-03-10 00:00:00",
+    "MODIFIED_ON": "2023-03-10 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\"]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/controlled-vocabulary/livestock-family",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2022-04-22 00:00:00",
+    "MODIFIED_ON": "2022-04-22 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/onto/co",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2018-06-20 00:00:00",
+    "MODIFIED_ON": "2022-04-02 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/onto/lactation-assessment",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2023-03-17 00:00:00",
+    "MODIFIED_ON": "2023-03-17 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"draft\"]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/onto/milk-functional-testing",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2023-03-11 00:00:00",
+    "MODIFIED_ON": "2023-03-11 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\"]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/controlled-vocabulary/livestock-species",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2020-12-09 00:00:00",
+    "MODIFIED_ON": "2022-04-22 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/onto/livestockfarm-description",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2022-04-22 00:00:00",
+    "MODIFIED_ON": "2023-07-01 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\"]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/onto/animal",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2018-06-18 00:00:00",
+    "MODIFIED_ON": "2023-06-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/onto/livestock-assessment",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2023-02-15 00:00:00",
+    "MODIFIED_ON": "2023-03-10 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\"]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/onto/ale",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2018-06-18 00:00:00",
+    "MODIFIED_ON": "2023-06-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/onto/apiary",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2023-10-31 00:00:00",
+    "MODIFIED_ON": "2023-10-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"initial draft\"]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/controlled-vocabulary/milk-functional-testing-frequencies",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2022-10-10 00:00:00",
+    "MODIFIED_ON": "2023-06-17 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/onto/leo",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2018-06-18 00:00:00",
+    "MODIFIED_ON": "2023-10-31 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"draft\"]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/controlled-vocabulary/exit-from-farm-reason",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2022-01-11 00:00:00",
+    "MODIFIED_ON": "2022-01-11 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/controlled-vocabulary/bovine-carcass-category",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2021-10-01 00:00:00",
+    "MODIFIED_ON": "2021-10-01 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/onto/livestock-indicator",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2018-06-18 00:00:00",
+    "MODIFIED_ON": "2022-11-16 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/onto/livestockfarm-building-description",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2022-04-15 00:00:00",
+    "MODIFIED_ON": "2023-06-22 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/controlled-vocabulary/entry-in-farm-reason",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2022-01-11 00:00:00",
+    "MODIFIED_ON": "2022-01-11 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/controlled-vocabulary/breed",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2020-12-09 00:00:00",
+    "MODIFIED_ON": "2022-01-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/controlled-vocabulary/measurement-unit",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2021-07-22 00:00:00",
+    "MODIFIED_ON": "2022-09-15 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/controlled-vocabulary/production-type",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2022-01-13 00:00:00",
+    "MODIFIED_ON": "2022-01-13 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/onto/health-assessment",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2022-11-22 00:00:00",
+    "MODIFIED_ON": "2023-03-09 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\"]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/controlled-vocabulary/farm-animal-status",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2022-02-24 00:00:00",
+    "MODIFIED_ON": "2022-02-24 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/leo/onto/weather",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "00944701002",
+    "ISSUED_ON": "2019-11-20 00:00:00",
+    "MODIFIED_ON": "2023-06-22 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\"]",
+    "REPOSITORY_URL": "https://github.com/Bluarancio/Leo-OpenData"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/datore-di-lavoro-domestico/latest/datore-di-lavoro-domestico.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/richiedente-naspi/latest/richiedente-naspi.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-06-13 00:00:00",
+    "MODIFIED_ON": "2024-06-27 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/controlled-vocabulary/contributions/tipo_gestione_riscatto",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2022-12-22 00:00:00",
+    "MODIFIED_ON": "2024-01-17 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/controlled-vocabulary/contributions/tipo_gestione_ricongiunzione",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2022-12-22 00:00:00",
+    "MODIFIED_ON": "2024-01-17 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/onto/services/",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-01-16 00:00:00",
+    "MODIFIED_ON": "2024-01-17 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"catalogued\",\"published\"]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/domanda-rilascio-modello-a1/latest/domanda-rilascio-modello-a1.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-03-08 00:00:00",
+    "MODIFIED_ON": "2024-03-08 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/prestazione-naspi/latest/prestazione-naspi.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-06-13 00:00:00",
+    "MODIFIED_ON": "2024-06-28 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/pratica-rendita/latest/pratica-rendita.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/controlled-vocabulary/domesticWorkServices/tipo_parentela",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-05-20 00:00:00",
+    "MODIFIED_ON": "2024-09-04 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/controlled-vocabulary/domesticWorkServices/tipo_retribuzione",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": null,
+    "MODIFIED_ON": "2024-05-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/controlled-vocabulary/pensions/tipo_istanza",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": null,
+    "MODIFIED_ON": "2024-02-01 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/ordine-pagamento/latest/ordine-pagamento.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/onto/contributions/",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-01-16 00:00:00",
+    "MODIFIED_ON": "2024-01-17 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"catalogued\",\"published\"]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/controlled-vocabulary/pensions/tipo_fondo",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": null,
+    "MODIFIED_ON": "2024-02-01 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/lavoratore-domestico/latest/lavoratore-domestico.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/tipo-pensione/latest/tipo-pensione.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-03-08 00:00:00",
+    "MODIFIED_ON": "2024-03-08 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/controlled-vocabulary/contributions/tipo_riscatto_privato",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2022-12-22 00:00:00",
+    "MODIFIED_ON": "2024-01-17 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/controlled-vocabulary/relevantLegislation/tipo_accordo_modello_a1",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": null,
+    "MODIFIED_ON": "2024-03-05 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/onto/relevantLegislation/",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-03-06 00:00:00",
+    "MODIFIED_ON": "2024-03-06 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"catalogued\",\"published\"]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/onto/socialSafetyNet/",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-06-06 00:00:00",
+    "MODIFIED_ON": "2024-01-17 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"catalogued\",\"published\"]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/prodotto-pensionistico/latest/prodotto-pensionistico.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-03-08 00:00:00",
+    "MODIFIED_ON": "2024-03-08 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/prestazione-pensionistica/latest/prestazione-pensionistica.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-03-08 00:00:00",
+    "MODIFIED_ON": "2024-03-08 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/stato-di-accolta-domanda-naspi/latest/stato-di-accolta-domanda-naspi.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-06-13 00:00:00",
+    "MODIFIED_ON": "2024-06-27 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/onto/domesticWorkServices/",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-06-06 00:00:00",
+    "MODIFIED_ON": "2024-01-17 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\",\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/rapporto-lavoro-domestico-in-verifica/latest/rapporto-lavoro-domestico-in-verifica.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-06-10 00:00:00",
+    "MODIFIED_ON": "2024-06-10 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/pratica-ricongiunzione/latest/pratica-ricongiunzione.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 0,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/controlled-vocabulary/domesticWorkServices/tipo_permesso",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": null,
+    "MODIFIED_ON": "2024-05-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/controlled-vocabulary/domesticWorkServices/motivi_permesso",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": null,
+    "MODIFIED_ON": "2024-05-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/controlled-vocabulary/pensions/tipo_gestione",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": null,
+    "MODIFIED_ON": "2024-02-01 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/pratica-riscatto/latest/pratica-riscatto.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/controlled-vocabulary/domesticWorkServices/tipo_documento",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": null,
+    "MODIFIED_ON": "2024-05-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/rapporto-lavoro-domestico-cessato/latest/rapporto-lavoro-domestico-cessato.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-06-10 00:00:00",
+    "MODIFIED_ON": "2024-06-10 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/rapporto-lavoro-domestico-respinto/latest/rapporto-lavoro-domestico-respinto.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-06-10 00:00:00",
+    "MODIFIED_ON": "2024-06-10 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/categoria-pensione/latest/categoria-pensione.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-03-08 00:00:00",
+    "MODIFIED_ON": "2024-03-08 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/rapporto-lavoro-domestico-annullato/latest/rapporto-lavoro-domestico-annullato.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-06-10 00:00:00",
+    "MODIFIED_ON": "2024-06-10 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/controlled-vocabulary/contributions/tipo_ricongiunzione",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2022-12-22 00:00:00",
+    "MODIFIED_ON": "2024-01-17 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/trasformazione-rapporto-lavoro-domestico/latest/trasformazione-rapporto-lavoro-domestico.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-06-10 00:00:00",
+    "MODIFIED_ON": "2024-06-10 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/controlled-vocabulary/domesticWorkServices/tipo_contratto",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": null,
+    "MODIFIED_ON": "2024-05-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/controlled-vocabulary/domesticWorkServices/tipo_mansione_lavoratore_domestico",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": null,
+    "MODIFIED_ON": "2024-05-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/rapporto-lavoro-domestico/latest/rapporto-lavoro-domestico.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/contratto-di-lavoro-domestico/latest/contratto-di-lavoro-domestico.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/pratica-rilascio-modello-a1/latest/pratica-rilascio-modello-a1.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-03-08 00:00:00",
+    "MODIFIED_ON": "2024-03-08 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/controlled-vocabulary/domesticWorkServices/motivi_cessazione",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": null,
+    "MODIFIED_ON": "2024-05-20 00:00:00",
+    "HAS_ERRORS": 1,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/controlled-vocabulary/contributions/tipo_riscatto_pubblico",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2022-12-22 00:00:00",
+    "MODIFIED_ON": "2024-01-17 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/gestione-pensionistica/latest/gestione-pensionistica.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-03-08 00:00:00",
+    "MODIFIED_ON": "2024-03-08 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/fondo-pensionistico/latest/fondo-pensionistico.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-03-08 00:00:00",
+    "MODIFIED_ON": "2024-03-08 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/mandato-sdd/latest/mandato-sdd.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/esito-pagamento/latest/esito-pagamento.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-02-13 00:00:00",
+    "MODIFIED_ON": "2024-02-20 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/controlled-vocabulary/pensions/tipo_ente",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": null,
+    "MODIFIED_ON": "2024-02-01 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/onto/pensions/",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-03-06 00:00:00",
+    "MODIFIED_ON": "2024-03-06 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"catalogued\",\"published\"]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/proroga-rapporto-lavoro-domestico/latest/proroga-rapporto-lavoro-domestico.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-06-10 00:00:00",
+    "MODIFIED_ON": "2024-06-10 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/controlled-vocabulary/relevantLegislation/tipo_delegato",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": null,
+    "MODIFIED_ON": "2024-03-05 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/domanda-naspi/latest/domanda-naspi.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-06-13 00:00:00",
+    "MODIFIED_ON": "2024-06-27 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/rapporto-lavoro-domestico-attivo/latest/rapporto-lavoro-domestico-attivo.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-06-10 00:00:00",
+    "MODIFIED_ON": "2024-06-10 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/onto/core/",
+    "RESOURCE_TYPE": "ONTOLOGY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-01-16 00:00:00",
+    "MODIFIED_ON": "2024-01-17 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[\"published\",\"catalogued\"]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/stato-di-riesame-domanda-naspi/latest/stato-di-riesame-domanda-naspi.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-06-13 00:00:00",
+    "MODIFIED_ON": "2024-06-27 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/stato-di-ricorso-domanda-naspi/latest/stato-di-ricorso-domanda-naspi.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-06-13 00:00:00",
+    "MODIFIED_ON": "2024-06-27 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/stato-di-erogato-prestazione-naspi/latest/stato-di-erogato-prestazione-naspi.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-06-13 00:00:00",
+    "MODIFIED_ON": "2024-06-29 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/social-security/controlled-vocabulary/pensions/tipo_categoria_pensione",
+    "RESOURCE_TYPE": "CONTROLLED_VOCABULARY",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": null,
+    "MODIFIED_ON": "2024-03-07 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  },
+  {
+    "RESOURCE_URI": "https://w3id.org/italia/schemas/ente-istruttore/latest/ente-istruttore.oas3.yaml",
+    "RESOURCE_TYPE": "SCHEMA",
+    "RIGHT_HOLDER": "inps",
+    "ISSUED_ON": "2024-03-08 00:00:00",
+    "MODIFIED_ON": "2024-03-08 00:00:00",
+    "HAS_ERRORS": 0,
+    "HAS_WARNINGS": 1,
+    "STATUS": "[]",
+    "REPOSITORY_URL": "https://github.com/INPS-it/NDC"
+  }
+]
\ No newline at end of file
diff --git a/src/main/resources/db/migration/V9__semantic_content_stats.sql b/src/main/resources/db/migration/V9__semantic_content_stats.sql
index 7bdb851e..e0856c2a 100644
--- a/src/main/resources/db/migration/V9__semantic_content_stats.sql
+++ b/src/main/resources/db/migration/V9__semantic_content_stats.sql
@@ -5,9 +5,22 @@ create table SEMANTIC_CONTENT_STATS
     RESOURCE_URI     VARCHAR(255) NOT NULL,
     RESOURCE_TYPE    VARCHAR(64)  NOT NULL,
     RIGHT_HOLDER     VARCHAR(64)  NOT NULL,
-    ISSUED_ON        TIMESTAMP    NOT NULL,
-    MODIFIED_ON      TIMESTAMP    NOT NULL,
+    ISSUED_ON        TIMESTAMP,
+    MODIFIED_ON      TIMESTAMP,
     HAS_ERRORS       BOOLEAN      NOT NULL,
     HAS_WARNINGS     BOOLEAN      NOT NULL,
     STATUS           TEXT         NOT NULL
 ) ENGINE = InnoDB;
+
+CREATE VIEW LATEST_HARVESTER_RUN_BY_YEAR AS
+WITH LATEST_RUN_BY_YEAR AS (SELECT REPOSITORY_ID,
+                                   YEAR(STARTED) AS YEAR,
+                                   MAX(STARTED)  AS LATEST_STARTED
+                            FROM HARVESTER_RUN
+                            GROUP BY REPOSITORY_ID, YEAR(STARTED))
+SELECT HR.*
+FROM HARVESTER_RUN HR
+         JOIN LATEST_RUN_BY_YEAR LRBY
+              ON HR.REPOSITORY_ID = LRBY.REPOSITORY_ID
+                  AND YEAR(HR.STARTED) = LRBY.YEAR
+                  AND HR.STARTED = LRBY.LATEST_STARTED;
\ No newline at end of file