OSLC4Net_SDK/Examples/OSLC4NetExamples.Server.NetCoreApi/OSLC4NetExamples.Server.NetCoreApi.http (3)

1-2: Consider adding HTTPS configuration for production.

The HTTP configuration is acceptable for development. However, for production deployments, you should consider adding an HTTPS variant of the host address.

Consider adding:

@OSLC4NetExamples.Server.NetCoreApi_HostAddress = http://localhost:5065
+# For production
+@OSLC4NetExamples.Server.NetCoreApi_HostAddress_Prod = https://localhost:7065

---

3-3: Consider removing the trailing slash from the endpoint URL.

The trailing slash in /weatherforecast/ might cause unnecessary redirects in some frameworks. Consider using /weatherforecast instead.

-GET {{OSLC4NetExamples.Server.NetCoreApi_HostAddress}}/weatherforecast/
+GET {{OSLC4NetExamples.Server.NetCoreApi_HostAddress}}/weatherforecast

---

3-6: Add test cases for different response formats.

Since this is part of an OSLC implementation, consider adding test cases for different response formats (e.g., RDF/XML, Turtle, JSON-LD) to ensure content negotiation works correctly.

Consider adding:

### Get weather forecast in RDF/XML
GET {{OSLC4NetExamples.Server.NetCoreApi_HostAddress}}/weatherforecast
Accept: application/rdf+xml

### Get weather forecast in Turtle
GET {{OSLC4NetExamples.Server.NetCoreApi_HostAddress}}/weatherforecast
Accept: text/turtle

### Get weather forecast in JSON-LD
GET {{OSLC4NetExamples.Server.NetCoreApi_HostAddress}}/weatherforecast
Accept: application/ld+json

OSLC4Net_SDK/Examples/OSLC4NetExamples.Server.NetCoreApi/WeatherForecast.cs (2)

1-4: Consider adding XML documentation comments.

Since this is an example/demo class that others might learn from, adding XML documentation comments would help explain its purpose and usage.

 namespace OSLC4NetExamples.Server.NetCoreApi;

+/// <summary>
+/// Represents a daily weather forecast with temperature readings and conditions.
+/// </summary>
 public class WeatherForecast

---

11-11: Consider adding validation for the Summary property.

While nullable strings are acceptable, you might want to add validation for maximum length or content requirements.

-    public string? Summary { get; set; }
+    private string? summary;
+    public string? Summary
+    {
+        get => summary;
+        set
+        {
+            if (value?.Length > 100)
+                throw new ArgumentException("Summary cannot exceed 100 characters");
+            summary = value;
+        }
+    }

OSLC4Net_SDK/OSLC4Net.Server.Providers/OslcRdfInputFormatter.cs (1)

6-12: Add XML documentation for public API.

Add XML documentation to describe the formatter's purpose, supported media types, and behavior.

Add this documentation:

+/// <summary>
+/// Formats RDF input according to OSLC specifications.
+/// </summary>
+/// <remarks>
+/// Supports the following media types:
+/// - application/rdf+xml
+/// - text/turtle
+/// </remarks>
 public class OslcRdfInputFormatter : TextInputFormatter
 {
+    /// <summary>
+    /// Reads the request body and converts it to the specified type.
+    /// </summary>
+    /// <param name="context">The input formatter context.</param>
+    /// <param name="encoding">The encoding used to read the request body.</param>
+    /// <returns>A task that returns the formatted input.</returns>
+    /// <exception cref="InputFormatterException">Thrown when the input cannot be parsed.</exception>
     public override async Task<InputFormatterResult> ReadRequestBodyAsync(...)

OSLC4Net_SDK/Examples/OSLC4NetExamples.Server.NetCoreApi/Program.cs (2)

1-2: Consider adding explicit imports for clarity.

While the code works due to implicit imports, consider adding explicit imports for better code maintainability and clarity:

+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
 using OSLC4Net.Server.Providers;

---

13-14: Review Swagger configuration for development environment.

Swagger is configured but commented out in the pipeline. If this is intended for development purposes, consider moving the Swagger configuration to a development-only service registration.

-builder.Services.AddEndpointsApiExplorer();
-builder.Services.AddSwaggerGen();

+if (builder.Environment.IsDevelopment())
+{
+    builder.Services.AddEndpointsApiExplorer();
+    builder.Services.AddSwaggerGen();
+}

Also applies to: 21-22

OSLC4Net_SDK/Examples/OSLC4NetExamples.Server.NetCoreApi/Controllers/WeatherForecastController.cs (2)

4-7: Consider improving API documentation and routing.

The controller should have:

1. XML documentation to describe its purpose and endpoints
2. A more specific base route that reflects the OSLC service nature (e.g., [Route("api/[controller]")] or [Route("services/[controller]")])

 namespace OSLC4NetExamples.Server.NetCoreApi.Controllers;
+/// <summary>
+/// Controller providing weather forecast data and OSLC service provider information.
+/// </summary>
 [ApiController]
-[Route("[controller]")]
+[Route("api/[controller]")]
 public class WeatherForecastController : ControllerBase

---

9-19: Enhance configuration management and logging.

Consider the following improvements:

1. Move the weather summaries to application configuration (appsettings.json)
2. Add logging statements in the action methods for better observability

Would you like me to provide an example of how to implement these improvements?

OSLC4Net_SDK/Examples/OSLC4NetExamples.Server.NetCoreApi/Dockerfile (1)

25-25: Consider adding build output verification.

The publish command could benefit from additional flags to ensure consistent builds:

-RUN dotnet publish "./OSLC4NetExamples.Server.NetCoreApi.csproj" -c $BUILD_CONFIGURATION -o /app/publish /p:UseAppHost=false
+RUN dotnet publish "./OSLC4NetExamples.Server.NetCoreApi.csproj" -c $BUILD_CONFIGURATION -o /app/publish /p:UseAppHost=false --no-restore --no-build --verify-no-changes

OSLC4Net_SDK/Examples/OSLC4NetExamples.Server.NetCoreApi/Properties/launchSettings.json (2)

31-41: Document container port mappings and limit port exposure

The current configuration publishes all ports ("publishAllPorts": true), which might expose unnecessary services. Consider:

1. Explicitly documenting the port mappings (8080/8081) in the repository's README
2. Only exposing the required ports in the Dockerfile instead of publishing all ports

Example Dockerfile port configuration:

EXPOSE 8080
EXPOSE 8081

---

44-50: Review authentication requirements

The current configuration allows anonymous access to all endpoints. Consider:

1. Implementing appropriate authentication middleware for securing endpoints
2. Defining CORS policies if the API will be accessed from different origins

Example authentication configuration in Program.cs:

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer();

app.UseAuthentication();
app.UseAuthorization();

OSLC4Net_SDK/Directory.Packages.props (2)

13-13: Consider moving Azure Containers Tools package to "Examples only" section.

The package is specifically for container support in the example API project, so it would be more organized to move it under the "Examples only" section with other example-specific dependencies.

---

43-43: Review Swashbuckle.AspNetCore version and placement.

Two suggestions:

1. Consider upgrading to the latest stable version (6.5.0) for better compatibility with .NET 8
2. Move this package to the "Examples only" section since it's specifically for the API example

OSLC4Net_SDK/OSLC4Net.Core.DotNetRdfProvider/RdfXmlMediaTypeFormatter.cs (4)

425-430: Add XML documentation for the public method.

The implementation looks good, but since this method is now public, it should include XML documentation describing its purpose, parameters, and return value.

Add documentation like this:

+    /// <summary>
+    /// Determines whether the specified type implements or inherits from a generic type.
+    /// </summary>
+    /// <param name="genericType">The generic type to check against.</param>
+    /// <param name="typeToTest">The type to test.</param>
+    /// <returns>True if typeToTest implements or inherits from genericType; otherwise, false.</returns>
     public static bool ImplementsGenericType(Type genericType, Type typeToTest)

---

Line range hint 432-450: Add XML documentation for the public method.

The implementation is solid, but since this method is now public, it should include XML documentation describing its purpose, parameters, and return value.

Add documentation like this:

+    /// <summary>
+    /// Determines whether the specified type implements or inherits from a generic type, with control over generic type resolution.
+    /// </summary>
+    /// <param name="genericType">The generic type to check against.</param>
+    /// <param name="typeToTest">The type to test.</param>
+    /// <param name="isParentGeneric">If true, resolves generic type definitions before comparison.</param>
+    /// <returns>True if typeToTest implements or inherits from genericType; otherwise, false.</returns>
     public static bool ImplementsGenericType(Type genericType, Type typeToTest, bool isParentGeneric)

---

Line range hint 452-470: Fix potential infinite loop and null reference issues.

The implementation has critical issues that need to be addressed:

1. Missing null check for parentType
2. No exit condition if genericType is not found in the type hierarchy
3. Could lead to infinite loop or NullReferenceException

Apply this fix:

     public static Type[] GetChildClassParameterArguments(Type genericType, Type typeToTest)
     {
         var isParentGeneric = genericType.IsGenericType;
 
         while (true)
         {
             var parentType = typeToTest.BaseType;
+            if (parentType == null)
+            {
+                throw new ArgumentException($"Type {typeToTest} does not inherit from {genericType}");
+            }
+
             var parentToTest = isParentGeneric && parentType.IsGenericType
                 ? parentType.GetGenericTypeDefinition()
                 : parentType;
 
             if (parentToTest == genericType)
             {
                 return typeToTest.GetGenericArguments();
             }
 
             typeToTest = parentType;
         }
     }

Also add XML documentation:

+    /// <summary>
+    /// Gets the generic type arguments from a derived type that inherits from a specific generic base type.
+    /// </summary>
+    /// <param name="genericType">The generic base type.</param>
+    /// <param name="typeToTest">The derived type to extract arguments from.</param>
+    /// <returns>An array of Type objects representing the generic arguments.</returns>
+    /// <exception cref="ArgumentException">Thrown when typeToTest does not inherit from genericType.</exception>
     public static Type[] GetChildClassParameterArguments(Type genericType, Type typeToTest)

---

Line range hint 477-487: Add XML documentation for the public class.

The implementation is correct, but since this class is now public, it should include XML documentation explaining its purpose and behavior.

Add documentation like this:

+    /// <summary>
+    /// A StreamWriter that prevents the underlying stream from being closed when Close() is called.
+    /// This is particularly useful when working with dotNetRDF writers that attempt to close the output stream.
+    /// </summary>
     public class NonClosingStreamWriter : StreamWriter
     {
+        /// <summary>
+        /// Initializes a new instance of the NonClosingStreamWriter class.
+        /// </summary>
+        /// <param name="stream">The stream to write to.</param>
         public NonClosingStreamWriter(Stream stream)
             : base(stream)
         {
         }
 
+        /// <summary>
+        /// Overrides the Close method to prevent closing the underlying stream.
+        /// Instead, it only flushes the buffer to ensure all data is written.
+        /// </summary>
         public override void Close()

OSLC4Net_SDK/OSLC4Net.Server.Providers/OslcRdfOutputFormatter.cs (5)

37-39: Remove Unused Variable buffer to Clean Up Code

The buffer variable is instantiated but never used within the WriteResponseBodyAsync method. This may be leftover code and can be safely removed to clean up the code.

Apply this diff to remove the unused variable:

- var buffer = new StringBuilder();

---

47-51: Use Strongly-Typed Access Instead of Reflection to Enhance Performance

The code uses reflection with GetProperty and GetValue to access the Resource and Properties properties. Relying on string literals for property names can lead to runtime errors if property names change and can impact performance. Consider using strongly-typed access or interfaces to improve reliability and efficiency.

---

60-61: Address the FIXME: Configure Subject URI Based on Service Provider Info

There's a FIXME comment indicating that the subject URI for the collection should be set by the app based on service provider information. Implementing this will enhance flexibility and ensure correct URI construction.

Would you like assistance in updating the code to set the subject URI based on the service provider configuration? I can help generate the necessary code or open a GitHub issue to track this task.

---

112-113: Complete the TODO: Set the Default Content Type

There's a TODO comment indicating the need to set a default content type. This ensures that the formatter can handle responses even when the content type is not specified in the context.

Would you like assistance in setting the default content type? I can help suggest appropriate defaults or open a GitHub issue to track this task.

---

168-176: Evaluate the Necessity of AsMsNetType Extension Method

The comment on line 170 suggests reconsidering the need for the AsMsNetType extension method. If this method doesn't provide significant value or duplicates existing functionality, consider removing it to simplify the codebase.

Configuration used: CodeRabbit UI
Review profile: CHILL

#!/bin/bash
# Description: Verify framework compatibility between projects
# Expected: Find TargetFramework in the referenced project file

rg -A 1 "<TargetFramework>" "OSLC4Net_SDK/OSLC4Net.Server.Providers/OSLC4Net.Server.Providers.csproj"

#!/bin/bash
# Check target frameworks in both projects
echo "=== Server.Providers Framework ==="
rg "<TargetFramework>" "OSLC4Net_SDK/OSLC4Net.Server.Providers/OSLC4Net.Server.Providers.csproj"

echo -e "\n=== NetCoreApi Framework ==="
rg "<TargetFramework>" "OSLC4Net_SDK/Examples/OSLC4NetExamples.Server.NetCoreApi/OSLC4NetExamples.Server.NetCoreApi.csproj"

#!/bin/bash
# Description: Verify Docker configuration files exist
# Expected: Find Dockerfile and .dockerignore in the correct location

# Check for Dockerfile
fd -p Dockerfile$ "$(dirname "OSLC4Net_SDK/Examples/OSLC4NetExamples.Server.NetCoreApi")/.."

# Check for .dockerignore
fd -p .dockerignore$ "$(dirname "OSLC4Net_SDK/Examples/OSLC4NetExamples.Server.NetCoreApi")/.."

#!/bin/bash
# Let's verify Docker setup with a more precise search
# Check for Dockerfile in the specific project directory
find OSLC4Net_SDK/Examples/OSLC4NetExamples.Server.NetCoreApi -name "Dockerfile" -type f

# Check for Dockerfile in the parent directories as per DockerfileContext
find OSLC4Net_SDK -maxdepth 2 -name "Dockerfile" -type f

# Check for .dockerignore
find OSLC4Net_SDK -maxdepth 2 -name ".dockerignore" -type f

# Let's also check the content of any Dockerfile if it exists
if [ -f OSLC4Net_SDK/Examples/OSLC4NetExamples.Server.NetCoreApi/Dockerfile ]; then
    cat OSLC4Net_SDK/Examples/OSLC4NetExamples.Server.NetCoreApi/Dockerfile
fi

#!/bin/bash
# Description: Check if package versions are defined in Directory.Packages.props
# Expected: Find version entries for both packages

rg -A 1 "Microsoft\.VisualStudio\.Azure\.Containers\.Tools\.Targets|Swashbuckle\.AspNetCore" "Directory.Packages.props"

#!/bin/bash
# Let's first check if Directory.Packages.props exists and its content
fd "Directory.Packages.props"

# Also check for other common package version management files
fd "Directory.Build.props"
fd "global.json"

# Let's also check the project file itself for version specifications
cat "OSLC4Net_SDK/Examples/OSLC4NetExamples.Server.NetCoreApi/OSLC4NetExamples.Server.NetCoreApi.csproj"

#!/bin/bash
# Let's check the content of Directory.Packages.props since we confirmed it exists
cat "OSLC4Net_SDK/Directory.Packages.props"

# Also check the root Directory.Build.props as it might contain version information
cat "OSLC4Net_SDK/Directory.Build.props"

 builder.Services.AddControllers(options =>
 {
     options.InputFormatters.Insert(0, new OslcRdfInputFormatter());
     options.OutputFormatters.Insert(0, new OslcRdfOutputFormatter());
+    options.RespectBrowserAcceptHeader = true;
+    options.ReturnHttpNotAcceptable = true;
 });

ENTRYPOINT ["dotnet", "OSLC4NetExamples.Server.NetCoreApi.dll"]
+HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
+    CMD curl -f http://localhost:8080/health || exit 1

#!/bin/bash
# Check for health endpoint implementation
rg -l "health" "Examples/OSLC4NetExamples.Server.NetCoreApi/"

#!/bin/bash
# Check .dockerignore content and common build artifacts
if [ -f .dockerignore ]; then
    echo "Content of .dockerignore:"
    cat .dockerignore
else
    echo "Warning: .dockerignore file not found"
fi

# Check for common build output directories that should be ignored
fd -t d "^(bin|obj|TestResults)$"

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

OSLC4Net_SDK/OSLC4Net.Server.Providers/OslcRdfOutputFormatter.cs (4)

37-38: Remove unused StringBuilder

The buffer variable is created but never used. The commented out code at line 116 suggests it was part of an earlier implementation.

- var buffer = new StringBuilder();

---

31-117: Consider breaking down the WriteResponseBodyAsync method

The method is handling multiple responsibilities including type checking, graph creation, and response writing. Consider extracting the graph creation logic into separate methods for better maintainability.

Example refactoring:

+ private IGraph CreateGraphFromFilteredResource(object value, Type type, HttpContext httpContext)
+ {
+     // Extract filtered resource handling logic here
+ }

+ private IGraph CreateGraphFromEnumerable(object value)
+ {
+     // Extract enumerable handling logic here
+ }

public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context,
    Encoding selectedEncoding)
{
    var httpContext = context.HttpContext;
    var type = context.ObjectType;
    var value = context.Object;
    
    IGraph graph;
    if (ImplementsGenericType(typeof(FilteredResource<>), type))
    {
-        // Current filtered resource handling logic
+        graph = CreateGraphFromFilteredResource(value, type, httpContext);
    }
    else if (InheritedGenericInterfacesHelper.ImplementsGenericInterface(
                 typeof(IEnumerable<>), value.GetType()))
    {
-        // Current enumerable handling logic
+        graph = CreateGraphFromEnumerable(value);
    }
    // ... rest of the method
}

---

112-114: Address the TODO comment about default content type

The TODO comment suggests that default content type handling needs to be implemented. This should be addressed to ensure robust content type handling.

Would you like me to help implement the default content type handling? We can:

1. Set a default content type in the constructor
2. Use it when the context's content type is null/empty

---

132-138: Extract duplicate RdfXmlWriter configuration

The RdfXmlWriter configuration is duplicated. Consider extracting it to a separate method.

+ private RdfXmlWriter CreateRdfXmlWriter()
+ {
+     return new RdfXmlWriter
+     {
+         UseDtd = false,
+         PrettyPrintMode = false,
+         CompressionLevel = 20
+     };
+ }

- var rdfXmlWriter = new RdfXmlWriter
- {
-     UseDtd = false, PrettyPrintMode = false, CompressionLevel = 20
- };
+ var rdfXmlWriter = CreateRdfXmlWriter();

Also applies to: 155-161

Configuration used: CodeRabbit UI
Review profile: CHILL

OSLC4Net_SDK/Examples/OSLC4NetExamples.Server.NetCoreApi/Controllers/WeatherForecastController.cs (1)

4-19: Consider moving hardcoded values to configuration.

The static weather summaries array should be moved to configuration for better maintainability and flexibility.

Consider applying this change:

-    private static readonly string[] Summaries = new[]
-    {
-        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
-    };
+    private readonly string[] _summaries;
+
+    public WeatherForecastController(ILogger<WeatherForecastController> logger, IConfiguration configuration)
+    {
+        _logger = logger;
+        _summaries = configuration.GetSection("WeatherSummaries").Get<string[]>() ?? 
+            throw new InvalidOperationException("Weather summaries configuration is required");
+    }

OSLC4Net_SDK/OSLC4Net.Core.sln (1)

41-42: Consider organizing OSLC4Net.Server.Providers in a solution folder.

The project appears to be a core provider implementation but is not organized within any solution folder. Consider creating a new "Providers" solution folder or placing it in an appropriate existing folder to maintain a clean solution structure.

Configuration used: CodeRabbit UI
Review profile: CHILL

OSLC4Net_SDK/Examples/OSLC4NetExamples.Server.NetCoreApi/Controllers/CatalogController.cs (1)

11-13: Same route-template caveat

Remove the leading slash to keep route composition flexible.

OSLC4Net_SDK/Examples/OSLC4NetExamples.Server.NetCoreApi/Controllers/ProviderController.cs (2)

7-8: Avoid absolute template paths in [Route] attributes

Prefixing the route template with / makes it absolute and bypasses any route prefixes configured at higher levels (e.g., MapControllerRoute, versioning prefixes).
Prefer a relative template ("services/provider") unless you explicitly want to opt-out of all future route composition.

-[Route("/services/provider")]
+[Route("services/provider")]

---

8-19: logger is injected but never used

Dead‐code parameters are misleading and will trigger CA1801/IDE0060 warnings.
Either use the logger (recommended) or remove the constructor parameter.

-public class ProviderController(ILogger<ProviderController> logger) : ControllerBase
+public class ProviderController(ILogger<ProviderController> logger) : ControllerBase
 {
     [HttpGet]
     [Route("{id}")]
-    public OSLC4Net.Core.Model.ServiceProvider GetProvider(string id)
+    public OSLC4Net.Core.Model.ServiceProvider GetProvider(string id)
     {
-        var sp = new OSLC4Net.Core.Model.ServiceProvider();
-        sp.SetAbout(new Uri(Request.GetEncodedUrl()));
-        sp.SetDescription("test me");
-        return sp;
+        var sp = new OSLC4Net.Core.Model.ServiceProvider();
+        sp.SetAbout(new Uri(Request.GetEncodedUrl()));
+        sp.SetDescription("Example Service Provider");   // TODO: replace with real data
+
+        logger.LogDebug("Returned ServiceProvider for id {Id}", id);
+        return sp;
     }
 }

OSLC4Net_SDK/Examples/OSLC4NetExamples.Server.NetCoreApi/Controllers/RootServicesController.cs (2)

7-9: Absolute [Route] template limits composition

Same remark as for ProviderController: use a relative template unless you intentionally bypass parent prefixes.

---

41-47: Consider FileContentResult for correct content-type/headers

Returning Content() forces the whole payload into memory as a string.
FileContentResult with a byte[] allows streaming large RDF documents and sets the Content-Length header.

OSLC4Net_SDK/Examples/OSLC4NetExamples.Server.NetCoreApi/Models/RootServicesDto.cs (2)

198-211: XML declaration is never emitted

doc.WriteContentTo(xmlWriter) writes only the root element; XmlWriterSettings.OmitXmlDeclaration = false is ignored because no WriteStartDocument() call exists.
Use doc.Save(xmlWriter) or call xmlWriter.WriteStartDocument() first.

-doc.WriteContentTo(xmlWriter);
+xmlWriter.WriteStartDocument();
+doc.WriteContentTo(xmlWriter);

---

138-144: Duplicate namespace maintenance

The record already maintains Namespaces but you hard-code the same URIs here.
Consider iterating over Namespaces to avoid drift.

OSLC4Net_SDK/Tests/OSLC4NetExamples.Server.Tests/Models/RootServicesDtoTests.cs (3)

20-22: Remove Console.WriteLine from tests

Unit-test output pollutes CI logs. Use ITestOutputHelper if diagnostics are required.

---

50-56: File path resolution brittle

File.ReadAllText("TestData/…") depends on the working directory.
Use Path.Combine(AppContext.BaseDirectory, "TestData", "rootservices.rdf") or embed the files as resources.

---

82-107: Repeated serialization pattern could be extracted

The boilerplate could live in a helper to reduce cognitive load and duplication.

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

OSLC4Net_SDK/OSLC4Net.Server.Providers/OslcRdfOutputFormatter.cs (3)

147-168: ⚠️ Potential issue

Media-type comparison should be case-insensitive

HTTP header values are case-insensitive. requestedType.Equals(...) defaults to ordinal, so "application/rdf+xml" vs "Application/RDF+XML" will miss.

-if (requestedType.Equals(OslcMediaType.APPLICATION_RDF_XML))
+if (requestedType.Equals(OslcMediaType.APPLICATION_RDF_XML, StringComparison.OrdinalIgnoreCase))
 ...
-else if (requestedType.Equals(OslcMediaType.TEXT_TURTLE))
+else if (requestedType.Equals(OslcMediaType.TEXT_TURTLE, StringComparison.OrdinalIgnoreCase))

---

134-137: ⚠️ Potential issue

context.ContentType may be null – add a default

A null ContentType hits new MediaType(contentType) inside SerializeGraph, throwing.
Set a safe default (e.g., APPLICATION_RDF_XML) when the header is missing:

-var contentType = context.ContentType;
+var contentType = StringSegment.IsNullOrEmpty(context.ContentType)
+    ? OslcMediaType.APPLICATION_RDF_XML_TYPE.MediaType
+    : context.ContentType;

---

69-78: ⚠️ Potential issue

portNum nullable handling is unsafe

Request.Host.Port returns int?. When it is null your current logic falls through to ":" + portNum, producing ":" and corrupting the URI.
Use .HasValue (or pattern-matching) before comparisons:

-var portNum = httpContext.Request.Host.Port;
-string? portString;
-if (portNum == 80 || portNum == 443)
-{
-    portString = "";
-}
-else
-{
-    portString = ":" + portNum;
-}
+int? portNum = httpContext.Request.Host.Port;
+string portString = portNum is null || portNum is 80 or 443
+    ? string.Empty
+    : $":{portNum.Value}";

OSLC4Net_SDK/OSLC4Net.Server.Providers/OslcRdfOutputFormatter.cs (1)

37-39: Remove dead buffer allocation

var buffer = new StringBuilder(); is never used (remaining WriteAsync call is commented out). Drop the variable to save a needless allocation and keep the method focused.

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

OSLC4Net_SDK/OSLC4Net.Server.Providers/OslcRdfOutputFormatter.cs (3)

48-49: Add null check for contentType to prevent exceptions.

The contentType variable may be null if not provided in the context, which would cause an exception when passed to the MediaType constructor.

---

101-110: Handle nullable portNum to prevent null reference exceptions.

The portNum obtained from httpContext.Request.Host.Port is nullable and should be checked before comparison.

---

173-175: Respect the negotiated encoding.

The HttpResponseStreamWriter is hardcoded to use UTF-8, ignoring the negotiated encoding passed to WriteResponseBodyAsync.

OSLC4Net_SDK/OSLC4Net.Server.Providers/OslcRdfOutputFormatter.cs (3)

41-41: Remove commented code.

The commented logger declaration should be removed if not needed, or uncommented if logging is required.

-        // var logger = serviceProvider.GetRequiredService<ILogger<OslcRdfOutputFormatter>>();

---

65-65: Address the TODO: Make pretty print configurable.

The pretty print setting is currently hardcoded. Consider making this configurable through options or request headers.

Would you like me to generate an implementation that makes the pretty print setting configurable?

---

172-172: Address the TODO: Deal with namespaces.

The namespace handling is not implemented. This could affect RDF serialization quality and compactness.

Would you like me to generate an implementation for proper namespace handling in RDF serialization?

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

OSLC4Net_SDK/OSLC4Net.Core.DotNetRdfProvider/Extensions.cs (1)

31-34: Optimize attribute existence check for better performance.

The current implementation creates an array and checks its length, which is inefficient. Use IsDefined method for better performance when only checking attribute existence.

 public static bool IsOslcSingleton(this Type type)
 {
-    return type.GetCustomAttributes(typeof(OslcResourceShape), false).Length > 0;
+    return type.IsDefined(typeof(OslcResourceShape), false);
 }

OSLC4Net_SDK/OSLC4Net.Server.Providers/OslcRdfInputFormatter.cs (2)

44-52: Replace switch expression with a dictionary for better maintainability.

The switch expression for format mapping could be replaced with a static dictionary to improve performance and maintainability, following the "Avoid Complex Units" guideline.

+private static readonly Dictionary<string, RdfFormat> MediaTypeToFormatMap = new()
+{
+    [OslcMediaType.APPLICATION_RDF_XML] = RdfFormat.RdfXml,
+    [OslcMediaType.TEXT_TURTLE] = RdfFormat.Turtle,
+    [OslcMediaType.APPLICATION_NTRIPLES] = RdfFormat.NTriples,
+    [OslcMediaType.APPLICATION_JSON_LD] = RdfFormat.JsonLd
+};

-var format = requestedType switch
-{
-    OslcMediaType.APPLICATION_RDF_XML => RdfFormat.RdfXml,
-    OslcMediaType.TEXT_TURTLE => RdfFormat.Turtle,
-    OslcMediaType.APPLICATION_NTRIPLES => RdfFormat.NTriples,
-    OslcMediaType.APPLICATION_JSON_LD => RdfFormat.JsonLd,
-    _ => throw new ArgumentOutOfRangeException(nameof(requestedType),
-        "Unknown RDF format"),
-};
+if (!MediaTypeToFormatMap.TryGetValue(requestedType, out var format))
+{
+    throw new ArgumentOutOfRangeException(nameof(requestedType), "Unknown RDF format");
+}

---

4-5: Address incomplete implementation indicated by TODO comments.

The TODO and REVISIT comments indicate that RDFS reasoning and schema loading are not fully implemented, which could affect the correctness of RDF processing.

The reasoning configuration and schema loading appear to be placeholders. This could lead to incomplete RDF processing or unexpected behavior in production.

Would you like me to help design a configuration system for RDFS reasoning and schema loading, or create an issue to track this implementation?

Also applies to: 132-136, 168-172

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

OSLC4Net_SDK/OSLC4Net.Server.Providers/OslcRdfOutputFormatter.cs (3)

29-29: Remove or implement commented UTF-16 encoding support.

The commented code for UTF-16 encoding should either be removed or properly implemented. Keeping commented-out code reduces maintainability and violates the DRY principle.

-        // SupportedEncodings.Add(Encoding.Unicode);

---

38-38: Remove or implement commented logger code.

Either implement proper logging or remove the commented code to maintain code cleanliness.

-        // var logger = serviceProvider.GetRequiredService<ILogger<OslcRdfOutputFormatter>>();

---

169-169: Address TODO: Implement namespace handling.

The TODO comment indicates missing namespace handling functionality that should be implemented or tracked in an issue.

Would you like me to help implement namespace handling or create an issue to track this requirement?

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

OSLC4Net_SDK/OSLC4Net.Server.Providers/OslcRdfInputFormatter.cs (5)

22-24: Remove Activator.CreateInstance to follow dependency injection best practices.

The constructor uses Activator.CreateInstance<DotNetRdfHelper>() which circumvents the dependency injection container and violates the Dependency Inversion Principle from SOLID guidelines.

---

34-78: Break down this method to improve maintainability.

This method is 44 lines long, violating the "Write Short Units of Code" principle (should be ≤15 lines). It handles multiple responsibilities: validation, format detection, URI resolution, deserialization, and object conversion.

---

56-60: Improve URI resolution robustness and error handling.

The comment explicitly states this needs improvement, and the current implementation lacks proper error handling for URI parsing failures. The ToSafeUri() extension method may mask exceptions that should be handled explicitly.

---

80-109: Reduce complexity and eliminate reflection usage.

This method violates multiple maintainability principles:

• Heavy use of reflection with GetType(), GetProperty(), GetMethod() calls
• Complex branching logic reducing readability
• Mixed responsibilities (type checking, conversion, collection handling)

---

131-136: Eliminate code duplication in reasoning logic.

The RDFS reasoning code is duplicated between DeserializeRdfTriplesAsync and DeserializeRdfQuadsAsync methods, violating the DRY principle.

Also applies to: 166-171

OSLC4Net_SDK/OSLC4Net.Server.Providers/OslcRdfInputFormatter.cs (2)

111-139: Consider making async method truly asynchronous.

The method is marked async but doesn't perform any asynchronous operations. The RDF parsing operations are synchronous, making the async keyword misleading.

Either remove async/await or use asynchronous parsing if available:

-private static async Task<IGraph> DeserializeRdfTriplesAsync(StreamReader streamReader,
+private static Task<IGraph> DeserializeRdfTriplesAsync(StreamReader streamReader,
     RdfFormat format, Uri baseUri)
 {
     // ... existing synchronous code ...
-    return graph;
+    return Task.FromResult(graph);
 }

---

26-30: Consider adding validation for media type constants.

The code directly uses OslcMediaType constants without verifying they are valid media type strings. If these constants are malformed, MediaTypeHeaderValue.Parse() will throw exceptions during formatter initialization.

Add validation or use try-parse methods:

-SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse(OslcMediaType.APPLICATION_RDF_XML));
-SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse(OslcMediaType.TEXT_TURTLE));
-SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse(OslcMediaType.APPLICATION_JSON_LD));
-SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse(OslcMediaType.APPLICATION_NTRIPLES));
+AddSupportedMediaType(OslcMediaType.APPLICATION_RDF_XML);
+AddSupportedMediaType(OslcMediaType.TEXT_TURTLE);
+AddSupportedMediaType(OslcMediaType.APPLICATION_JSON_LD);
+AddSupportedMediaType(OslcMediaType.APPLICATION_NTRIPLES);

+private void AddSupportedMediaType(string mediaType)
+{
+    if (MediaTypeHeaderValue.TryParse(mediaType, out var parsed))
+    {
+        SupportedMediaTypes.Add(parsed);
+    }
+    else
+    {
+        throw new ArgumentException($"Invalid media type: {mediaType}");
+    }
+}

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

OSLC4Net_SDK/OSLC4Net.Server.Providers/OslcRdfOutputFormatter.cs (5)

44-45: Add null check for ContentType to prevent exceptions.

The context.ContentType could be null, which would cause issues when calling ToString() and passing to new MediaType().

Apply this diff to handle null ContentType:

-var contentType = context.ContentType.ToString();
-var requestedMediaType = new MediaType(contentType);
+var contentType = context.ContentType?.ToString();
+if (string.IsNullOrEmpty(contentType))
+{
+    contentType = OslcMediaType.APPLICATION_RDF_XML;
+}
+var requestedMediaType = new MediaType(contentType);

---

97-106: Handle nullable Port to prevent null reference exceptions.

The httpContext.Request.Host.Port returns a nullable integer. Direct comparison without null checking can cause issues.

Apply this diff to properly handle nullable port:

var portNum = httpContext.Request.Host.Port;
string? portString;
-if (portNum == 80 || portNum == 443)
+if (!portNum.HasValue || portNum == 80 || portNum == 443)
{
    portString = "";
}
else
{
-    portString = ":" + portNum;
+    portString = ":" + portNum.Value;
}

---

67-163: Refactor complex method to improve maintainability.

This 96-line method violates the Single Responsibility Principle and the "Building Maintainable Software" guideline to keep methods short. Consider extracting logic into smaller, focused methods.

Extract methods like:

• BuildRequestUri(HttpContext httpContext, HttpRequest httpRequest)
• ConvertFilteredResourceToGraph(Type type, object value, HttpContext httpContext, HttpRequest httpRequest)
• ConvertResponseInfoToGraph(object value, string descriptionAbout, string responseInfoAbout)
• ConvertEnumerableToGraph(object value)

---

169-171: Respect the negotiated encoding instead of hard-coding UTF-8.

The method receives selectedEncoding parameter from ASP.NET Core content negotiation but ignores it.

Apply this diff:

var responseStreamWriter = new HttpResponseStreamWriter(
    httpContextResponse.BodyWriter.AsStream(),
-    Encoding.UTF8);
+    selectedEncoding ?? Encoding.UTF8);

---

46-58: Use case-insensitive comparison for media types.

HTTP headers can vary in case. The current switch expression is case-sensitive.

Apply this diff to ensure case-insensitive matching:

-var requestedType = $"{requestedMediaType.Type}/{requestedMediaType.SubType}";
+var requestedType = $"{requestedMediaType.Type}/{requestedMediaType.SubType}".ToLowerInvariant();

var ctx = new SerializationContext
{
    Format = requestedType switch
    {
-        OslcMediaType.APPLICATION_RDF_XML => RdfFormat.RdfXml,
-        OslcMediaType.TEXT_TURTLE => RdfFormat.Turtle,
-        OslcMediaType.APPLICATION_NTRIPLES => RdfFormat.NTriples,
-        OslcMediaType.APPLICATION_JSON_LD => RdfFormat.JsonLd,
+        var t when t.Equals(OslcMediaType.APPLICATION_RDF_XML, StringComparison.OrdinalIgnoreCase) => RdfFormat.RdfXml,
+        var t when t.Equals(OslcMediaType.TEXT_TURTLE, StringComparison.OrdinalIgnoreCase) => RdfFormat.Turtle,
+        var t when t.Equals(OslcMediaType.APPLICATION_NTRIPLES, StringComparison.OrdinalIgnoreCase) => RdfFormat.NTriples,
+        var t when t.Equals(OslcMediaType.APPLICATION_JSON_LD, StringComparison.OrdinalIgnoreCase) => RdfFormat.JsonLd,
        _ => throw new ArgumentOutOfRangeException(nameof(requestedType),
            "Unknown RDF format"),
    },

OSLC4Net_SDK/Tests/OSLC4NetExamples.Server.Tests.AspireHost/Program.cs (1)

1-1: Remove unused import.

The System.Net namespace is imported but not used in this file.

-using System.Net;
-
var builder = DistributedApplication.CreateBuilder(args);

OSLC4Net_SDK/Tests/OSLC4NetExamples.Server.Tests/RefimplAspireFixture.cs (2)

7-7: Address TODO comment about test collection organization.

Consider implementing the suggested refimpl-aspire collection for better test organization.

Would you like me to help implement the collection-based fixture approach or create an issue to track this improvement?

---

39-42: Consider making timeout values configurable.

Hard-coded timeout values (300s for startup, 5s delay) might not be suitable for all environments and could cause test flakiness.

Consider extracting these to configuration:

+private const int StartupTimeoutSeconds = 300;
+private const int StartupDelaySeconds = 5;

-await app.StartAsync().WaitAsync(TimeSpan.FromSeconds(300)).ConfigureAwait(true);
+await app.StartAsync().WaitAsync(TimeSpan.FromSeconds(StartupTimeoutSeconds)).ConfigureAwait(true);

// Wait a bit for the application to fully start
-await Task.Delay(TimeSpan.FromSeconds(5)).ConfigureAwait(true);
+await Task.Delay(TimeSpan.FromSeconds(StartupDelaySeconds)).ConfigureAwait(true);

OSLC4Net_SDK/Tests/OSLC4NetExamples.Server.Tests/TestOslcNetCoreApi.cs (2)

31-37: Fix inconsistent indentation.

The constructor has inconsistent indentation that deviates from C# coding standards.

-    public TestOslcNetCoreApi(RefimplAspireFixture aspireFixture) 
-        {
+    public TestOslcNetCoreApi(RefimplAspireFixture aspireFixture)
+    {
        _aspireFixture = aspireFixture;
        
        // Create HTTP client for direct API testing
        _httpClient = new HttpClient();
    }

---

61-61: Replace Console.WriteLine with proper test output mechanism.

Using Console.WriteLine in tests is not recommended. Consider using xUnit's ITestOutputHelper for test output.

Add ITestOutputHelper to the constructor and use it for output:

+private readonly ITestOutputHelper _output;

-public TestOslcNetCoreApi(RefimplAspireFixture aspireFixture)
+public TestOslcNetCoreApi(RefimplAspireFixture aspireFixture, ITestOutputHelper output)
{
    _aspireFixture = aspireFixture;
+    _output = output;

-Console.WriteLine($"Actual XML content: {content}");
+_output.WriteLine($"Actual XML content: {content}");

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro