Skip to content
Snippets Groups Projects
Select Git revision
  • 9f71f0eaec155609e84b2a659904c66ad94d9b50
  • master default protected
  • develop protected
  • feature/up-conv-test
  • jst
  • fabian
  • ITAConvolution_v2024a
  • VA_v2023b
  • VA_v2023a
  • VA_v2022a
  • before_cmake_rework
  • v2021.a
  • v2020.a
  • v2019.a
  • v2018.b
  • v2018.a
  • v2017.c
  • v2017.d
  • v2017.b
  • v2017.a
  • v2016.a
21 results

ITAUniformPartitionedConvolutionTest.cpp

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    StructuralData.cs 8.66 KiB
    using Coscine.ApiClient;
    using Coscine.ApiClient.Core.Api;
    using Coscine.ApiClient.Core.Client;
    using Coscine.ApiClient.Core.Model;
    using Microsoft.Extensions.Configuration;
    using SQL2Linked.Models.ConfigurationModels;
    using SQL2Linked.Utils;
    using System.Globalization;
    using VDS.RDF;
    using VDS.RDF.Parsing;
    
    namespace SQL2Linked;
    
    /// <summary>
    /// Provides an abstract base class for handling structural data transformations and migrations.
    /// </summary>
    /// <typeparam name="S">The type of data to be transformed or migrated.</typeparam>
    /// <remarks>
    /// This class is partially shared between this script and the Trellis Migrator script.
    /// </remarks>
    public abstract class StructuralData<S>
    {
        private readonly string _adminToken;
        protected readonly Configuration _apiConfiguration;
        protected readonly AdminApi _adminApi;
        protected readonly PidConfiguration _pidConfiguration; // Comes from the API Client, not from the application's own configuration
    
        /// <summary>
        /// Initializes a new instance of the <see cref="StructuralData{S}"/> class.
        /// </summary>
        public StructuralData()
        {
            // Retrieve the configuration settings for the PID ePIC API from the API Client
            var apiConfiguration = ApiConfigurationUtil.RetrieveApiConfiguration();
            _pidConfiguration = apiConfiguration.GetSection(PidConfiguration.Section).Get<PidConfiguration>() ?? new();
    
            // Ensiure that the prefix is not null or empty.
            ArgumentException.ThrowIfNullOrWhiteSpace(_pidConfiguration.Prefix, nameof(_pidConfiguration.Prefix));
    
            // Generate an admin token for the API Client
            var jwtConfiguration = ApiConfigurationUtil.RetrieveJwtConfiguration();
            _adminToken = ApiConfigurationUtil.GenerateAdminToken(jwtConfiguration);
            _apiConfiguration = new Configuration()
            {
                BasePath = "http://localhost:7206/coscine",
                ApiKeyPrefix = { { "Authorization", "Bearer" } },
                ApiKey = { { "Authorization", _adminToken } },
                Timeout = 300000, // 5 minutes
            };
            _adminApi = new AdminApi(_apiConfiguration);
        }
    
        /// <summary>
        /// Asynchronously converts a collection of entries into linked data graphs.
        /// </summary>
        /// <param name="entries">A collection of entries of type <typeparamref name="S"/> to convert.</param>
        /// <typeparam name="S">The type of the entries to be converted into linked data graphs.</typeparam>
        /// <returns>An asynchronous enumerable (<see cref="IAsyncEnumerable{IGraph}"/>) of graphs, where each graph represents the linked data derived from an entry.</returns>
        public abstract IAsyncEnumerable<IGraph> ConvertToLinkedDataAsync(IAsyncEnumerable<S> entries);
    
        /// <summary>
        /// Asynchronously retrieves all entries of type <typeparamref name="S"/>.
        /// </summary>
        /// <typeparam name="S">The type of the entries to retrieve.</typeparam>
        /// <returns>An <see cref="IAsyncEnumerable{S}"/> representing an asynchronous stream of entries.</returns>
        public abstract IAsyncEnumerable<S> GetAll();
    
        /// <summary>
        /// Asynchronously migrates data, with an option to simulate the migration process without making any changes (dummy mode).
        /// </summary>
        /// <param name="dummyMode">If set to <c>true</c>, the method simulates the migration process without executing any changes to the data store.</param>
        /// <returns>A task representing the asynchronous migration operation.</returns>
        public async Task Migrate(bool dummyMode)
        {
            var spacer = new string('-', 35);
            Console.WriteLine($"\n{spacer}\n{typeof(S).Name}\n{spacer}");
            var graphs = ConvertToLinkedDataAsync(GetAll());
            if (!dummyMode)
            {
                await StoreGraphs(graphs);
            }
        }
    
        /// <summary>
        /// Asynchronously stores a collection of RDF graphs in the underlying data store.
        /// </summary>
        /// <param name="graphs">An asynchronous enumerable of RDF graphs (<see cref="IAsyncEnumerable{IGraph}"/>) to be stored.</param>
        /// <returns>A task representing the asynchronous operation of storing the graphs.</returns>
        public async Task StoreGraphs(IAsyncEnumerable<IGraph> graphs)
        {
            var formatEnum = RdfFormat.TextTurtle;
            var format = "text/turtle";
    
            await foreach (var graph in graphs)
            {
                Console.WriteLine($" ({graph.BaseUri})");
    
                try
                {
                    var rdfWriter = MimeTypesHelper.GetWriter(format);
                    var content = VDS.RDF.Writing.StringWriter.Write(graph, rdfWriter);
    
                    if (graph is PatchGraph patchGraph)
                    {
                        var patchOperations = new List<RdfPatchOperationDto>
                        {
                            new(RdfPatchOperationType.A, new RdfDefinitionForManipulationDto(content, formatEnum))
                        };
    
                        await _adminApi.PatchMetadataAsync(
                            graph.BaseUri.AbsoluteUri,
                            new RdfPatchDocumentDto(patchOperations)
                        );
                    }
                    else
                    {
                        await _adminApi.UpdateMetadataGraphAsync(
                            graph.BaseUri.AbsoluteUri,
                            new MetadataUpdateAdminParameters(new RdfDefinitionForManipulationDto(content, formatEnum))
                        );
                    }
    
                    Console.WriteLine($" - Graph {graph.BaseUri} added successfully");
                    Console.WriteLine();
                }
                catch (Exception e)
                {
                    Console.Error.WriteLine($"Error on ({graph.BaseUri}):");
                    Console.Error.WriteLine(e);
                    Console.Error.WriteLine(e.InnerException);
                    Console.Error.WriteLine();
                }
            }
        }
    
        public void AddModifiedDate(IGraph graph, Uri rootUri)
        {
            AssertToGraphLiteralNode(
                graph,
                rootUri,
                RdfUris.DcTermsModified,
                DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture),
                new Uri(XmlSpecsHelper.XmlSchemaDataTypeDateTime)
            );
        }
    
        /// <summary>
        /// Asserts a triple to the graph with a URI node object.
        /// </summary>
        /// <param name="graph">The graph to assert to.</param>
        /// <param name="graphSubject">The subject URI of the triple.</param>
        /// <param name="graphPredicate">The predicate URI of the triple.</param>
        /// <param name="graphObject">The object URI of the triple.</param>
        public void AssertToGraphUriNode(IGraph graph, Uri graphSubject, Uri graphPredicate, Uri? graphObject)
        {
            if (graphObject != null)
            {
                graph.Assert(
                    new Triple(
                        graph.CreateUriNode(graphSubject),
                        graph.CreateUriNode(graphPredicate),
                        graph.CreateUriNode(graphObject)
                    )
                );
            }
        }
    
        /// <summary>
        /// Asserts a triple to the graph with a literal node object.
        /// </summary>
        /// <param name="graph">The graph to assert to.</param>
        /// <param name="graphSubject">The subject URI of the triple.</param>
        /// <param name="graphPredicate">The predicate URI of the triple.</param>
        /// <param name="graphObject">The literal object of the triple.</param>
        /// <param name="objectType">The data type URI of the literal object, if any.</param>
        public void AssertToGraphLiteralNode(IGraph graph, Uri graphSubject, Uri graphPredicate, string? graphObject, Uri? objectType = null)
        {
            if (graphObject != null)
            {
                graph.Assert(
                    new Triple(
                        graph.CreateUriNode(graphSubject),
                        graph.CreateUriNode(graphPredicate),
                        objectType is not null ? graph.CreateLiteralNode(graphObject, objectType) : graph.CreateLiteralNode(graphObject)
                    )
                );
            }
        }
    
        /// <summary>
        /// Asserts a triple to the graph with a blank node subject and a URI node object.
        /// </summary>
        /// <param name="graph">The graph to assert to.</param>
        /// <param name="graphSubject">The blank node subject of the triple.</param>
        /// <param name="graphPredicate">The predicate URI of the triple.</param>
        /// <param name="graphObject">The object URI of the triple.</param>
        public void AssertToGraphBlankAndUriNode(IGraph graph, IBlankNode graphSubject, Uri graphPredicate, Uri? graphObject)
        {
            if (graphObject != null)
            {
                graph.Assert(
                    new Triple(
                        graphSubject,
                        graph.CreateUriNode(graphPredicate),
                        graph.CreateUriNode(graphObject)
                    )
                );
            }
        }
    }