Skip to content
Snippets Groups Projects
Select Git revision
  • e85c05db7ad57817163d5038c909a2f5b0bd90f1
  • master default protected
  • gitkeep
  • dev protected
  • Issue/2449-GuidPidSlugToProjectSettings
  • Issue/2309-docs
  • Issue/2355-topLevelOrg
  • Issue/2328-noFailOnLog
  • Hotfix/2371-fixGitLabinRCV
  • Issue/2287-guestRole
  • Fix/xxxx-activateGitlab
  • Test/xxxx-enablingGitLab
  • Issue/2349-gitlabHttps
  • Issue/2259-updatePids
  • Issue/2101-gitLabResTypeUi
  • Hotfix/2202-fixNaNQuota
  • Issue/2246-quotaResoval
  • Issue/2221-projectDateCreated
  • Hotfix/2224-quotaSizeAnalytics
  • Fix/xxxx-resourceVisibility
  • Issue/2000-gitlabResourcesAPI
  • v4.4.3
  • v4.4.2
  • v4.4.1
  • v4.4.0
  • v4.3.4
  • v4.3.3
  • v4.3.2
  • v4.3.1
  • v4.3.0
  • v4.2.8
  • v4.2.7
  • v4.2.6
  • v4.2.5
  • v4.2.4
  • v4.2.3
  • v4.2.2
  • v4.2.1
  • v4.2.0
  • v4.1.1
  • v4.1.0
41 results

Project.csproj

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    StructuralData.cs 7.12 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 VDS.RDF;
    
    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 } },
            };
            _adminApi = new AdminApi(_apiConfiguration);
        }
    
        /// <summary>
        /// Converts the given entries to linked data graphs.
        /// </summary>
        /// <param name="entries">The entries to convert.</param>
        /// <returns>An enumerable collection of graphs representing the linked data.</returns>
        public abstract Task<IEnumerable<IGraph>> ConvertToLinkedDataAsync(IEnumerable<S> entries);
    
        /// <summary>
        /// Retrieves all entries of type <typeparamref name="S"/>.
        /// </summary>
        /// <returns>A task that represents the asynchronous operation. The task result contains an enumerable of all entries.</returns>
        public abstract Task<IEnumerable<S>> GetAll();
    
        /// <summary>
        /// Migrates the data, optionally in a dummy mode where changes are not persisted.
        /// </summary>
        /// <param name="dummyMode">If set to <c>true</c>, the migration is simulated but not executed.</param>
        /// <returns>A task representing the asynchronous 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 = await ConvertToLinkedDataAsync(await GetAll());
            if (!dummyMode)
            {
                await StoreGraphs(graphs);
            }
        }
    
        /// <summary>
        /// Stores the given graphs in the underlying data store.
        /// </summary>
        /// <param name="graphs">The graphs to be stored.</param>
        /// <returns>A task representing the asynchronous operation.</returns>
        public async Task StoreGraphs(IEnumerable<IGraph> graphs)
        {
            var formatEnum = RdfFormat.TextTurtle;
            var format = "text/turtle";
    
            foreach (var graph in graphs)
            {
                Console.WriteLine($" ({graph.BaseUri})");
    
                try
                {
                    var rdfWriter = MimeTypesHelper.GetWriter(format);
                    var content = VDS.RDF.Writing.StringWriter.Write(graph, rdfWriter);
    
                    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();
                }
            }
        }
    
        /// <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)
                    )
                );
            }
        }
    }