Goffo.Http 1.0.0

READ ME

Goffo.Http

Library that helps with generating urls using HttpClient

How to use

1. Create a class for your Web Api Service and inherit from AbstractWebApiService
2. If using Interface have it inherit from IWebApiService else have the created class inherit
3. Use the WebApiUriService to help generate your uri string (optional)
4. Use the AbstractWebApiService Endpoint methods (optional)

Example Web Api Service Class

using Goffo.Http.Base;
using Goffo.Http.Library.Models;
using Goffo.Http.Services;
using System.Net.Http.Json;

namespace Goffo.Http.Console.WebApiServices;
public class EmployeeWebApiService : AbstractWebApiService, IEmployeeWebApiService
{
    public EmployeeWebApiService(IHttpClientFactory httpClientFactory) : base(httpClientFactory)
    {
        EmployeeHttpClient = httpClientFactory.CreateClient("EmployeeHttpClient");
        Endpoint = "Employees";
    }

    internal HttpClient EmployeeHttpClient { get; init; }

    public async Task<IEnumerable<EmployeeModel>> GetEmployeesAsync()
    {
        Uri = WebApiUriService.GetApiUri(EmployeeHttpClient, Endpoint);
        var output = await GetAsync<EmployeeModel>(EmployeeHttpClient, Endpoint, Uri);

        if (output is null)
        {
            throw GetApiNullOutputException();
        }

        return output;
    }
    public async Task<EmployeeModel> GetEmployeeByIdAsync(int id)
    {
        Uri = WebApiUriService.GetApiUri(EmployeeHttpClient, Endpoint, id.ToString());
        var output = await GetByIdAsync<EmployeeModel>(EmployeeHttpClient, Endpoint, Uri);

        if (output is null)
        {
            throw GetApiNullOutputException();
        }

        return output;
    }
    public async Task<EmployeeModel> CreateEmployeeAsync(EmployeeModel employee)
    {
        Uri = WebApiUriService.GetApiUri(EmployeeHttpClient, Endpoint);
        HttpContent content = await PostAsync(EmployeeHttpClient, Endpoint, Uri, employee);
        EmployeeModel? output = await content.ReadFromJsonAsync<EmployeeModel>();

        if (output is null)
        {
            throw GetApiNullOutputException();
        }

        return output;
    }
    public async Task<EmployeeModel> UpdateEmployeeAsync(EmployeeModel employee)
    {
        Uri = WebApiUriService.GetApiUri(EmployeeHttpClient, Endpoint, employee.Id.ToString());
        
        HttpContent content = await PutAsync(EmployeeHttpClient, Endpoint, Uri, employee);
        
        EmployeeModel? output = await content.ReadFromJsonAsync<EmployeeModel>();
        
        if (output is null)
        {
            throw GetApiNullOutputException();
        }
        
        return output;
    }
    public async Task<EmployeeModel> DeleteEmployeeAsync(int id)
    {
        Uri = WebApiUriService.GetApiUri(EmployeeHttpClient, Endpoint, id.ToString());

        var output = await DeleteAsync<EmployeeModel>(EmployeeHttpClient, Endpoint, Uri);
        
        if(output is null)
        {
            throw GetApiNullOutputException();
        }

        return new EmployeeModel();
    }

}

Example Web Api Service Interface

using Goffo.Http.Base;
using Goffo.Http.Library.Models;

namespace Goffo.Http.Console.WebApiServices;
public interface IEmployeeWebApiService : IWebApiService
{
    Task<EmployeeModel> CreateEmployeeAsync(EmployeeModel employee);
    Task<EmployeeModel> DeleteEmployeeAsync(int id);
    Task<EmployeeModel> GetEmployeeByIdAsync(int id);
    Task<IEnumerable<EmployeeModel>> GetEmployeesAsync();
    Task<EmployeeModel> UpdateEmployeeAsync(EmployeeModel employee);
}

Example of how to use in an Application

using Goffo.Http.Console.WebApiServices;
using Goffo.Http.Extensions;
using Goffo.Http.Library.Extensions;
using Goffo.Http.Library.Models;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

namespace Goffo.Http.Console;
public class App
{
    private readonly IHost _host;

    public App()
    {
        _host = Host.CreateDefaultBuilder()
            .ConfigureLogging(logger =>
            {
                logger.ClearProviders();
                logger.AddDebug();
                logger.AddConsole();
            })
            .ConfigureServices((context, services) =>
            {
                services.AddHttpClient("EmployeeHttpClient", client =>
                {
                    client.BaseAddress = new Uri("https://localhost:7177/api/");
                });
                services.RegisterGoffoHttp();
                services.RegisterHttpLibrary();
                services.AddScoped<IEmployeeWebApiService, EmployeeWebApiService>();
            })
            .Build();
    }

    internal IEmployeeWebApiService EmployeeWebApiService => _host.Services.GetRequiredService<IEmployeeWebApiService>();

    public async Task<IEnumerable<EmployeeModel>> GetEmployeesAsync()
    {
        return await EmployeeWebApiService.GetEmployeesAsync();
    }

    public async Task<EmployeeModel> GetEmployeeByIdAsync(int id)
    {
        return await EmployeeWebApiService.GetEmployeeByIdAsync(id);
    }

    public async Task<EmployeeModel> CreateEmployeeAsync(EmployeeModel employee)
    {
        return await EmployeeWebApiService.CreateEmployeeAsync(employee);
    }

    public async Task<EmployeeModel> UpdateEmployeeAsync(EmployeeModel employee)
    {
        return await EmployeeWebApiService.UpdateEmployeeAsync(employee);
    }

    public async Task<EmployeeModel> DeleteEmployeeAsync(int id)
    {
       return await EmployeeWebApiService.DeleteEmployeeAsync(id);
    }
}

Program.cs

using Goffo.Http.Console;
using Goffo.Http.Library.Models;

App app = new();

Console.WriteLine("App is running...");
Console.WriteLine();

IEnumerable<EmployeeModel> employees = await app.GetEmployeesAsync();

foreach (EmployeeModel employee in employees)
{
    Console.WriteLine(employee.Id);
    Console.WriteLine(employee.FirstName);
    Console.WriteLine(employee.LastName);
    Console.WriteLine(employee.EmailAddress);
    Console.WriteLine();
}

int employeeId = 3;
EmployeeModel employeeById = await app.GetEmployeeByIdAsync(employeeId);

Console.WriteLine(employeeById.Id);
Console.WriteLine(employeeById.FirstName);
Console.WriteLine(employeeById.LastName);
Console.WriteLine(employeeById.EmailAddress);
Console.WriteLine();

EmployeeModel createdEmployee = new()
{
    FirstName = "John",
    LastName = "Doe",
    EmailAddress = "john.doe@jdoe.com"
};

EmployeeModel createdEmployeeReturned = await app.CreateEmployeeAsync(createdEmployee);

Console.WriteLine(createdEmployeeReturned.Id);

Console.WriteLine();

EmployeeModel updateEmployee = new()
{
    FirstName = "Jane",
    LastName = "Doe",
    EmailAddress = "jane.doe@fakemail.com"
};

EmployeeModel updatedEmployeeReturned = await app.UpdateEmployeeAsync(updateEmployee);

Console.WriteLine(updateEmployee.Id);
Console.WriteLine(updateEmployee.FirstName);
Console.WriteLine(updateEmployee.LastName);
Console.WriteLine(updateEmployee.EmailAddress);
Console.WriteLine();


int deleteEmployeeId = updateEmployee.Id;

EmployeeModel deletedEmployeeReturned = await app.DeleteEmployeeAsync(deleteEmployeeId);

Console.WriteLine(deletedEmployeeReturned.Id);
Console.WriteLine(deletedEmployeeReturned.FirstName);
Console.WriteLine(deletedEmployeeReturned.LastName);
Console.WriteLine(deletedEmployeeReturned.EmailAddress);
Console.WriteLine();

Console.ReadLine();