[Backend API] Implement endpoint for list of events

src/AzureOpenAIProxy.ApiApp/Endpoints/PlaygroundEndpoints.cs

@@ -1,3 +1,7 @@
+using Azure;
+
+using AzureOpenAIProxy.ApiApp.Services;
+
 using Microsoft.AspNetCore.Mvc;
 
 namespace AzureOpenAIProxy.ApiApp.Endpoints;
@@ -14,10 +18,24 @@ public static class PlaygroundEndpoints
     /// <returns>Returns <see cref="RouteHandlerBuilder"/> instance.</returns>
     public static RouteHandlerBuilder AddListEvents(this WebApplication app)
     {
-        var builder = app.MapGet(PlaygroundEndpointUrls.Events, () =>
+        // ASSUMPTION: User has already logged in
+        var builder = app.MapGet(PlaygroundEndpointUrls.Events, async (
+            IPlaygroundService service,
+            ILoggerFactory loggerFactory) =>
         {
-            // TODO: Issue #179 https://github.com/aliencube/azure-openai-sdk-proxy/issues/179
-            return Results.Ok();
+            var logger = loggerFactory.CreateLogger(nameof(AdminEventEndpoints));
+            logger.LogInformation("Received request to fetch events list");
+
+            try
+            {
+                var eventDetailsList = await service.GetEvents();
+                return Results.Ok(eventDetailsList);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"Error occurred while fetching events list");
+                return Results.Problem(ex.Message, statusCode: StatusCodes.Status500InternalServerError);
+            }
         })
         .Produces<List<EventDetails>>(statusCode: StatusCodes.Status200OK, contentType: "application/json")
         .Produces(statusCode: StatusCodes.Status401Unauthorized)

src/AzureOpenAIProxy.ApiApp/Program.cs

@@ -28,6 +28,12 @@
 // Add admin repositories
 builder.Services.AddAdminEventRepository();
 
+// Add playground services
+builder.Services.AddPlaygroundService();
+
+// Add playground repositories
+builder.Services.AddEventRepository();
+
 var app = builder.Build();
 
 app.MapDefaultEndpoints();

src/AzureOpenAIProxy.ApiApp/Repositories/EventRepository.cs

@@ -0,0 +1,71 @@
+using Azure.Data.Tables;
+
+using AzureOpenAIProxy.ApiApp.Configurations;
+
+namespace AzureOpenAIProxy.ApiApp.Repositories;
+
+/// <summary>
+/// This provides interfaces to the <see cref="EventRepository"/> class.
+/// </summary>
+public interface IEventRepository
+{
+    /// <summary>
+    /// Gets the list of events.
+    /// </summary>
+    /// <returns>Returns the list of events.</returns>
+    Task<List<EventDetails>> GetEvents();
+}
+
+public class EventRepository(TableServiceClient tableServiceClient, StorageAccountSettings storageAccountSettings) : IEventRepository
+{
+    private readonly TableServiceClient _tableServiceClient = tableServiceClient ?? throw new ArgumentNullException(nameof(tableServiceClient));
+    private readonly StorageAccountSettings _storageAccountSettings = storageAccountSettings ?? throw new ArgumentNullException(nameof(storageAccountSettings));
+
+    /// <inheritdoc/>
+    /// <remarks>
+    /// The results are sorted based on the following criteria:
+    /// Lexical order of event titles.
+    /// </remarks>
+    public async Task<List<EventDetails>> GetEvents()
+    {
+        TableClient tableClient = await GetTableClientAsync();
+
+        List<EventDetails> events = [];
+
+        await foreach(EventDetails eventDetails in tableClient.QueryAsync<EventDetails>(e => e.PartitionKey.Equals(PartitionKeys.EventDetails)).ConfigureAwait(false))
+        {
+            events.Add(eventDetails);
+        }
+
+        events.Sort((e1, e2) => e1.Title.CompareTo(e2.Title));
+
+        return events;
+    }
+
+    private async Task<TableClient> GetTableClientAsync()
+    {
+        TableClient tableClient = _tableServiceClient.GetTableClient(_storageAccountSettings.TableStorage.TableName);
+
+        await tableClient.CreateIfNotExistsAsync().ConfigureAwait(false);
+
+        return tableClient;
+    }
+}
+
+/// <summary>
+/// This represents the extension class for <see cref="IServiceCollection"/>
+/// </summary>
+public static class EventRepositoryExtensions
+{
+    /// <summary>
+    /// Adds the <see cref="EventRepository"/> instance to the service collection.
+    /// </summary>
+    /// <param name="services"><see cref="IServiceCollection"/> instance.</param>
+    /// <returns>Returns <see cref="IServiceCollection"/> instance.</returns>
+    public static IServiceCollection AddEventRepository(this IServiceCollection services)
+    {
+        services.AddScoped<IEventRepository, EventRepository>();
+
+        return services;
+    }
+}

src/AzureOpenAIProxy.ApiApp/Services/PlaygroundService.cs

@@ -0,0 +1,57 @@
+using AzureOpenAIProxy.ApiApp.Repositories;
+
+namespace AzureOpenAIProxy.ApiApp.Services;
+
+/// <summary>
+/// This provides interfaces to <see cref="PlaygroundService"/> class. 
+/// </summary>
+public interface IPlaygroundService
+{
+    /// <summary>
+    /// Get the list of deployment model.
+    /// </summary>
+    /// <returns>Returns the list of deployment models.</returns>
+    Task<List<DeploymentModelDetails>> GetDeploymentModels(string eventId);
+
+    /// <summary>
+    /// Get the list of events.
+    /// </summary>
+    /// <returns>Returns the list of events.</returns>
+    Task<List<EventDetails>> GetEvents();
+}
+
+public class PlaygroundService(IEventRepository eventRepository) : IPlaygroundService
+{
+    private readonly IEventRepository _eventRepository = eventRepository ?? throw new ArgumentNullException(nameof(eventRepository));
+    /// <inheritdoc/>
+    public async Task<List<DeploymentModelDetails>> GetDeploymentModels(string eventId)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <inheritdoc/>
+    public async Task<List<EventDetails>> GetEvents()
+    {
+        var result = await _eventRepository.GetEvents().ConfigureAwait(false);
+
+        return result;
+    }
+}
+
+/// <summary>
+/// This represents the extension class for <see cref="IServiceCollection"/>
+/// </summary>
+public static class PlaygroundServiceExtensions
+{
+    /// <summary>
+    /// Adds the <see cref="PlaygroundService"/> instance to the service collection.
+    /// </summary>
+    /// <param name="services"><see cref="IServiceCollection"/> instance.</param>
+    /// <returns>Returns <see cref="IServiceCollection"/> instance.</returns>
+    public static IServiceCollection AddPlaygroundService(this IServiceCollection services)
+    {
+        services.AddScoped<IPlaygroundService, PlaygroundService>();
+
+        return services;
+    }
+}

test/AzureOpenAIProxy.ApiApp.Tests/Repositories/EventRepositoryTests.cs

@@ -0,0 +1,120 @@
+using System.Linq.Expressions;
+
+using Azure;
+using Azure.Data.Tables;
+
+using AzureOpenAIProxy.ApiApp.Configurations;
+using AzureOpenAIProxy.ApiApp.Repositories;
+
+using FluentAssertions;
+
+using Microsoft.Extensions.DependencyInjection;
+
+using NSubstitute;
+using NSubstitute.ExceptionExtensions;
+
+namespace AzureOpenAIProxy.ApiApp.Tests.Repositories;
+
+public class EventRepositoryTests
+{
+    [Fact]
+    public void Given_ServiceCollection_When_AddEventRepository_Invoked_Then_It_Should_Contain_EventRepository()
+    {
+        // Arrange
+        var services = new ServiceCollection();
+
+        // Act
+        services.AddEventRepository();
+
+        // Assert
+        services.SingleOrDefault(p => p.ServiceType == typeof(IEventRepository)).Should().NotBeNull();
+    }
+
+    [Fact]
+    public void Given_Null_TableServiceClient_When_Creating_EventRepository_Then_It_Should_Throw_Exception()
+    {
+        // Arrange
+        var settings = Substitute.For<StorageAccountSettings>();
+        var tableServiceClient = default(TableServiceClient);
+
+        // Act
+        Action action = () => new EventRepository(tableServiceClient, settings);
+
+        // Assert
+        action.Should().Throw<ArgumentNullException>();
+    }
+
+    [Fact]
+    public void Given_Null_StorageAccountSettings_When_Creating_EventRepository_Then_It_Should_Throw_Exception()
+    {
+        // Arrange
+        var settings = default(StorageAccountSettings);
+        var tableServiceClient = Substitute.For<TableServiceClient>();
+
+        // Act
+        Action action = () => new EventRepository(tableServiceClient, settings);
+
+        // Assert
+        action.Should().Throw<ArgumentNullException>();
+    }
+
+    [Fact]
+    public async Task Given_Failure_In_Get_Entities_When_GetEvents_Invoked_Then_It_Should_Throw_Exception()
+    {
+        // Arrange
+        var settings = Substitute.For<StorageAccountSettings>();
+        var tableServiceClient = Substitute.For<TableServiceClient>();
+        var repository = new EventRepository(tableServiceClient, settings);
+
+        var tableClient = Substitute.For<TableClient>();
+        tableServiceClient.GetTableClient(Arg.Any<string>()).Returns(tableClient);
+        tableClient.QueryAsync(Arg.Any<Expression<Func<EventDetails, bool>>>()).Throws(new Exception("error occurred"));
+
+        // Act
+        Func<Task> func = repository.GetEvents;
+
+        // Assert
+        var assertion = await func.Should().ThrowAsync<Exception>();
+    }
+
+    [Fact]
+    public async Task Given_Exist_Events_When_GetEvents_Invoked_Then_It_Should_Return_EventDetails_List()
+    {
+        // Arrange
+        Random rand = new();
+        int listSize = rand.Next(1, 20);
+        Guid eventId = new();
+
+        var settings = Substitute.For<StorageAccountSettings>();
+        var tableServiceClient = Substitute.For<TableServiceClient>();
+        var repository = new EventRepository(tableServiceClient, settings);
+
+        var eventDetails = new EventDetails
+        {
+            RowKey = eventId.ToString(),
+            PartitionKey = PartitionKeys.EventDetails
+        };
+
+        List<EventDetails> events = [];
+
+        for(int i = 0; i < listSize; ++i)
+        {
+            events.Add(eventDetails);
+        }
+
+        var pages = Page<EventDetails>.FromValues(events, default, Substitute.For<Response>());
+        var asyncPages = AsyncPageable<EventDetails>.FromPages([pages]);
+
+        var tableClient = Substitute.For<TableClient>();
+        tableServiceClient.GetTableClient(Arg.Any<string>()).Returns(tableClient);
+        tableClient.QueryAsync(Arg.Any<Expression<Func<EventDetails, bool>>>()).Returns(asyncPages);
+
+        // Act
+        var result = await repository.GetEvents();
+
+        // Assert
+        result.Count.Should().Be(listSize);
+        result.First().Should().BeEquivalentTo(eventDetails);
+    }
+
+}

test/AzureOpenAIProxy.ApiApp.Tests/Services/PlaygroundServiceTests.cs

@@ -0,0 +1,93 @@
+using Azure;
+
+using AzureOpenAIProxy.ApiApp.Repositories;
+using AzureOpenAIProxy.ApiApp.Services;
+
+using FluentAssertions;
+
+using Microsoft.Extensions.DependencyInjection;
+
+using NSubstitute;
+using NSubstitute.ExceptionExtensions;
+
+namespace AzureOpenAIProxy.ApiApp.Tests.Services;
+
+public class PlaygroundServiceTests
+{
+    [Fact]
+    public void Given_ServiceCollection_When_AddPlaygroundService_Invoked_Then_It_Should_Contain_PlaygroundService()
+    {
+        // Arrange
+        var services = new ServiceCollection();
+
+        // Act
+        services.AddPlaygroundService();
+
+        // Assert
+        services.SingleOrDefault(p => p.ServiceType == typeof(IPlaygroundService)).Should().NotBeNull();
+    }
+
+    [Fact]
+    public void Given_Instance_When_GetDeploymentModels_Invoked_Then_It_Should_Throw_Exception()
+    {
+        // Arrange
+        string eventId = "test-id";
+        var repository = Substitute.For<IEventRepository>();
+        var service = new PlaygroundService(repository);
+
+        // Act
+        Func<Task> func = async () => await service.GetDeploymentModels(eventId);
+
+        // Assert
+        func.Should().ThrowAsync<NotImplementedException>();
+    }
+
+    [Fact]
+    public async Task Given_Failure_In_Get_Entities_When_GetEvents_Invoked_Then_It_Should_Throw_Exception()
+    {
+        // Arrange
+        var eventId = Guid.NewGuid();
+        var repository = Substitute.For<IEventRepository>();
+        var service = new PlaygroundService(repository);
+
+        repository.GetEvents().ThrowsAsync(new Exception("Error occurred"));
+
+        // Act
+        Func<Task> func = service.GetEvents;
+
+        // Assert
+        var assertion = await func.Should().ThrowAsync<Exception>();
+    }
+
+    [Fact]
+    public async Task Given_Exist_Events_When_GetEvents_Invoked_Then_It_Should_Return_EventDetails_List()
+    {
+        // Arrange
+        Random rand = new();
+        int listSize = rand.Next(1, 20);
+        Guid eventId = new();
+        var repository = Substitute.For<IEventRepository>();
+        var service = new PlaygroundService(repository);
+
+        var eventDetails = new EventDetails
+        {
+            RowKey = eventId.ToString()
+        };
+
+        List<EventDetails> events = [];
+        for(int i = 0; i < listSize; ++i)
+        {
+            events.Add(eventDetails);
+        }
+
+        repository.GetEvents().Returns(events);
+
+        // Act
+        var result = await service.GetEvents();
+
+        // Assert
+        result.Count.Should().Be(listSize);
+        result.First().Should().BeEquivalentTo(eventDetails);
+    }
+
+}