[DRAFT] feat: new client based on RestSharp

OSLC4Net_SDK/Directory.Packages.props

@@ -17,9 +17,11 @@
     <!-- depedencyManagement / convergence -->
     <PackageVersion Include="System.Net.Http" Version="4.3.4" />
     <PackageVersion Include="System.Text.RegularExpressions" Version="4.3.1" />
+    <PackageVersion Include="System.Text.Json" Version="9.0.0" />
     <!-- Main deps -->
     <PackageVersion Include="dotNetRdf.Core" Version="3.3.0" />
     <PackageVersion Include="Antlr3.Runtime" Version="3.5.1" />
+    <PackageVersion Include="RestSharp" Version="112.1.0" />
     <!-- conneg support &c for System.Net.Http -->
     <PackageVersion Include="Microsoft.AspNet.WebApi.Client" Version="6.0.0" />
     <!-- Test deps -->

OSLC4Net_SDK/OSLC4Net.Client.RestSharp/IOslcClient.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Threading.Tasks;
+using OSLC4Net.Core.Model;
+
+namespace OSLC4Net.Client.RestSharp;
+
+public interface IOslcClient
+{
+    Task<IOslcResponse<T>> GetResourceAsync<T>(Uri resource) where T : IResource, new();
+}

OSLC4Net_SDK/OSLC4Net.Client.RestSharp/IOslcResponse.cs

@@ -0,0 +1,43 @@
+using System;
+using OSLC4Net.Core.Model;
+
+namespace OSLC4Net.Client.RestSharp;
+
+/// <summary>
+///     Interface for responses for OSLC resource requests.
+/// </summary>
+/// <typeparam name="T"></typeparam>
+public interface IOslcResponse<T> where T : IResource
+{
+    Uri Uri { get; }
+
+    OslcResponseStatus Status { get; }
+}
+
+public enum OslcResponseStatus
+{
+    Success,
+    SuccessNoResource,
+    AuthnFault,
+    ClientNonAuthnFault,
+    ServerFault
+}
+
+/// <summary>
+///     Interface for a successful OSLC resource request containing a resource in the response.
+/// </summary>
+/// <typeparam name="T"></typeparam>
+public interface IOslcResourceResponse<T> : IOslcResponse<T> where T : IResource
+{
+    T Resource { get; }
+}
+
+
+/// <summary>
+///     Interface for a successful OSLC resource request containing a resource in the response.
+/// </summary>
+/// <typeparam name="T"></typeparam>
+public interface IOslcAuthNeededResponse<T> : IOslcResponse<T> where T : IResource
+{
+
+}

OSLC4Net_SDK/OSLC4Net.Client.RestSharp/OSLC4Net.Client.RestSharp.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.1</TargetFramework>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="RestSharp" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\OSLC4Net.Core.DotNetRdfProvider\OSLC4Net.Core.DotNetRdfProvider.csproj" />
+  </ItemGroup>
+
+</Project>

OSLC4Net_SDK/OSLC4Net.Client.RestSharp/OslcClientSharp.cs

@@ -0,0 +1,152 @@
+using System;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using OSLC4Net.Core.Model;
+using RestSharp;
+using RestSharp.Authenticators;
+
+namespace OSLC4Net.Client.RestSharp;
+
+/// <summary>
+///     RestSharp based OSLC client
+/// </summary>
+// TODO: consider a base class for all RestSharp clients but without auth
+public abstract class OslcClientSharpBase : IOslcClient
+{
+    protected RestClient Client { get; set; } = null!;
+
+    public async Task<IOslcResponse<T>> GetResourceAsync<T>(Uri resourceUri)
+        where T : IResource, new()
+    {
+        var request = PrepareGetRequest<T>(resourceUri);
+
+        return WrapOslcResponse<T>(resourceUri, await Client.GetAsync(request));
+    }
+
+    private static IOslcResponse<T> WrapOslcResponse<T>(Uri resourceUri, RestResponse response)
+        where T : IResource, new()
+    {
+        if (RestSharpResponseFactory.ResponseStatusFrom(response) == OslcResponseStatus.Success)
+        {
+            return new OslcResourceResponseSharp<T>(resourceUri, response);
+        }
+
+        throw new NotImplementedException();
+    }
+
+    private static RestRequest PrepareGetRequest<T>(Uri resource) where T : IResource
+    {
+        return new RestRequest(resource);
+    }
+}
+
+// no auth
+public abstract class OslcClientSharpPublic : OslcClientSharpBase
+{
+    /// <inheritdoc />
+    protected OslcClientSharpPublic(RestClient? client = null)
+    {
+        Client = client ?? new RestClient();
+    }
+}
+
+public abstract class OslcClientSharpBasic : OslcClientSharpBase
+{
+    public OslcClientSharpBasic(string username, string password, RestClientOptions? options = null)
+    {
+        var restClientOptions = options ?? new RestClientOptions();
+        restClientOptions.Authenticator = new HttpBasicAuthenticator(username, password);
+
+        Client = new RestClient(restClientOptions);
+    }
+}
+
+// TODO: implement an ASP.NET Core server to test the dance
+public abstract class OslcClientSharpOauth10a : OslcClientSharpBase
+{
+    public OslcClientSharpOauth10a(string key, string secret, string accessToken,
+        string accessTokenSecret, RestClientOptions? options = null)
+    {
+        var restClientOptions = options ?? new RestClientOptions
+        {
+            Authenticator = OAuth1Authenticator.ForProtectedResource(key, secret,
+                accessToken, accessTokenSecret)
+        };
+
+        Client = new RestClient(restClientOptions);
+    }
+}
+
+public interface IResponseSharp
+{
+    public RestResponse RestSharpResponse { get; }
+}
+
+internal class ResponseSharpMixin<T> : IResponseSharp where T : IResource, new()
+{
+    // TODO: implement IRestSerializer based on our MediaFormatter
+    // https://restsharp.dev/docs/advanced/serialization#custom
+    private readonly Lazy<T> _resourceDeserialized = new(() => new T());
+
+    public OslcResponseStatus Status =>
+        RestSharpResponseFactory.ResponseStatusFrom(RestSharpResponse);
+
+    /// <inheritdoc />
+    public RestResponse RestSharpResponse { get; }
+
+    public T DeserializeResource()
+    {
+        Debug.Assert(_resourceDeserialized.Value != null, "_resourceDeserialized.Value != null");
+        return _resourceDeserialized.Value;
+    }
+
+    public static ResponseSharpMixin<TT> From<TT>(RestResponse restSharpResponse)
+        where TT : IResource, new()
+    {
+        throw new NotImplementedException();
+    }
+}
+
+public class OslcResourceResponseSharp<T> : IResponseSharp, IOslcResourceResponse<T>
+    where T : IResource, new()
+{
+    public OslcResourceResponseSharp(Uri uri, RestResponse restSharpResponse)
+    {
+        Uri = uri;
+        Mixin = ResponseSharpMixin<T>.From<T>(restSharpResponse);
+    }
+
+    private ResponseSharpMixin<T> Mixin { get; }
+
+    public Uri Uri { get; }
+
+    // TODO
+    /// <inheritdoc />
+    public OslcResponseStatus Status => Mixin.Status;
+
+    public T Resource => Mixin.DeserializeResource();
+
+    public RestResponse RestSharpResponse => Mixin.RestSharpResponse;
+}
+
+public class RestSharpResponseFactory
+{
+    public static OslcResponseStatus ResponseStatusFrom(RestResponse response)
+    {
+        return (int)response.StatusCode switch
+        {
+            > 0 and < 200 => OslcResponseStatus.SuccessNoResource,
+            200 => OslcResponseStatus.Success,
+            // TODO: introduce "technical"/intermediate statuses
+            > 200 and < 400 => OslcResponseStatus.SuccessNoResource,
+            400 or (>= 402 and < 500) => OslcResponseStatus.ClientNonAuthnFault,
+            // 403 is an authz fault, need to think what to do with it. In theory, nothing,
+            // because a non-logged in used should get 401 and a logged in has nothing
+            // to do other than to ask for access.
+            // But maybe worth introducing OslcResponseStatus.AuthzFault
+            401 => OslcResponseStatus.AuthnFault,
+            >= 500 and <= 599 => OslcResponseStatus.ServerFault,
+            _ => throw new ArgumentOutOfRangeException()
+        };
+    }
+}