LibraryApp/Program.cs - master - rumina-v/database

LibraryApp/Program.cs
288 строк8 KB
Viktoria Rumina
Add solution files
04 июн 2026, 12:13
04 июн 2026, 12:1373cfef0
using LibraryApp.Abstractions;
using LibraryApp.Data;
using LibraryApp.Entities;
using LibraryApp.Repositories;
using LibraryApp.Services;
using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);

// DbContext
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseNpgsql(builder.Configuration.GetConnectionString("DefaultConnection")));

// Repositories
builder.Services.AddScoped<IReaderRepository, ReaderRepository>();
builder.Services.AddScoped<IReaderProfileRepository, ReaderProfileRepository>();
builder.Services.AddScoped<IBookRepository, BookRepository>();
builder.Services.AddScoped<ILoanRepository, LoanRepository>();

// Services
builder.Services.AddScoped<IReaderService, ReaderService>();
builder.Services.AddScoped<IReaderProfileService, ReaderProfileService>();
builder.Services.AddScoped<IBookService, BookService>();
builder.Services.AddScoped<ILoanService, LoanService>();

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

var app = builder.Build();

app.UseSwagger();
app.UseSwaggerUI();

app.MapGet("/", () => Results.Ok("LibraryApp is running"));

// ===================== READERS =====================

app.MapGet("/readers", async (IReaderService service) =>
{
    var readers = await service.GetAllAsync();
    return Results.Ok(readers);
});

app.MapGet("/readers/{id:int}", async (int id, IReaderService service) =>
{
    var reader = await service.GetByIdAsync(id);
    return reader is null ? Results.NotFound() : Results.Ok(reader);
});

app.MapPost("/readers", async (Reader reader, IReaderService service) =>
{
    try
    {
        var created = await service.AddAsync(reader);
        return Results.Created($"/readers/{created.Id}", created);
    }
    catch (Exception ex)
    {
        return Results.BadRequest(ex.Message);
    }
});

app.MapPut("/readers/{id:int}", async (int id, Reader reader, IReaderService service) =>
{
    try
    {
        var updated = await service.UpdateAsync(id, reader);
        return updated is null ? Results.NotFound() : Results.Ok(updated);
    }
    catch (Exception ex)
    {
        return Results.BadRequest(ex.Message);
    }
});

app.MapDelete("/readers/{id:int}", async (int id, IReaderService service) =>
{
    try
    {
        var deleted = await service.DeleteAsync(id);
        return deleted ? Results.NoContent() : Results.NotFound();
    }
    catch (Exception ex)
    {
        return Results.BadRequest(ex.Message);
    }
});

app.MapGet("/readers/overdue", async (IReaderService service) =>
{
    var readers = await service.GetReadersWithOverdueBooksAsync();
    return Results.Ok(readers);
});

app.MapGet("/readers/top/{count:int}", async (int count, IReaderService service) =>
{
    var readers = await service.GetTopReadersByLoansCountAsync(count);
    return Results.Ok(readers);
});

// ===================== READER PROFILES =====================

app.MapGet("/profiles", async (IReaderProfileService service) =>
{
    var profiles = await service.GetAllAsync();
    return Results.Ok(profiles);
});

app.MapGet("/profiles/{id:int}", async (int id, IReaderProfileService service) =>
{
    var profile = await service.GetByIdAsync(id);
    return profile is null ? Results.NotFound() : Results.Ok(profile);
});

app.MapPost("/profiles", async (ReaderProfile profile, IReaderProfileService service) =>
{
    try
    {
        var created = await service.AddAsync(profile);
        return Results.Created($"/profiles/{created.Id}", created);
    }
    catch (Exception ex)
    {
        return Results.BadRequest(ex.Message);
    }
});

app.MapPut("/profiles/{id:int}", async (int id, ReaderProfile profile, IReaderProfileService service) =>
{
    try
    {
        var updated = await service.UpdateAsync(id, profile);
        return updated is null ? Results.NotFound() : Results.Ok(updated);
    }
    catch (Exception ex)
    {
        return Results.BadRequest(ex.Message);
    }
});

app.MapDelete("/profiles/{id:int}", async (int id, IReaderProfileService service) =>
{
    var deleted = await service.DeleteAsync(id);
    return deleted ? Results.NoContent() : Results.NotFound();
});

app.MapGet("/profiles/without-phone", async (IReaderProfileService service) =>
{
    var profiles = await service.GetProfilesWithoutPhoneAsync();
    return Results.Ok(profiles);
});

app.MapGet("/profiles/by-city/{city}", async (string city, IReaderProfileService service) =>
{
    var profiles = await service.GetProfilesByCityAsync(city);
    return Results.Ok(profiles);
});

// ===================== BOOKS =====================

app.MapGet("/books", async (IBookService service) =>
{
    var books = await service.GetAllAsync();
    return Results.Ok(books);
});

app.MapGet("/books/{id:int}", async (int id, IBookService service) =>
{
    var book = await service.GetByIdAsync(id);
    return book is null ? Results.NotFound() : Results.Ok(book);
});

app.MapPost("/books", async (Book book, IBookService service) =>
{
    try
    {
        var created = await service.AddAsync(book);
        return Results.Created($"/books/{created.Id}", created);
    }
    catch (Exception ex)
    {
        return Results.BadRequest(ex.Message);
    }
});

app.MapPut("/books/{id:int}", async (int id, Book book, IBookService service) =>
{
    try
    {
        var updated = await service.UpdateAsync(id, book);
        return updated is null ? Results.NotFound() : Results.Ok(updated);
    }
    catch (Exception ex)
    {
        return Results.BadRequest(ex.Message);
    }
});

app.MapDelete("/books/{id:int}", async (int id, IBookService service) =>
{
    var deleted = await service.DeleteAsync(id);
    return deleted ? Results.NoContent() : Results.NotFound();
});

app.MapGet("/books/available", async (IBookService service) =>
{
    var books = await service.GetAvailableBooksAsync();
    return Results.Ok(books);
});

app.MapGet("/books/popular/{count:int}", async (int count, IBookService service) =>
{
    var books = await service.GetMostPopularBooksAsync(count);
    return Results.Ok(books);
});

// ===================== LOANS =====================

app.MapGet("/loans", async (ILoanService service) =>
{
    var loans = await service.GetAllAsync();
    return Results.Ok(loans);
});

app.MapGet("/loans/{id:int}", async (int id, ILoanService service) =>
{
    var loan = await service.GetByIdAsync(id);
    return loan is null ? Results.NotFound() : Results.Ok(loan);
});

app.MapPost("/loans", async (Loan loan, ILoanService service) =>
{
    try
    {
        var created = await service.AddAsync(loan);
        return Results.Created($"/loans/{created.Id}", created);
    }
    catch (Exception ex)
    {
        return Results.BadRequest(ex.Message);
    }
});

app.MapPut("/loans/{id:int}", async (int id, Loan loan, ILoanService service) =>
{
    try
    {
        var updated = await service.UpdateAsync(id, loan);
        return updated is null ? Results.NotFound() : Results.Ok(updated);
    }
    catch (Exception ex)
    {
        return Results.BadRequest(ex.Message);
    }
});

app.MapDelete("/loans/{id:int}", async (int id, ILoanService service) =>
{
    var deleted = await service.DeleteAsync(id);
    return deleted ? Results.NoContent() : Results.NotFound();
});

app.MapGet("/loans/overdue", async (ILoanService service) =>
{
    var loans = await service.GetOverdueLoansAsync();
    return Results.Ok(loans);
});

app.MapGet("/loans/active-by-reader/{readerId:int}", async (int readerId, ILoanService service) =>
{
    var loans = await service.GetActiveLoansByReaderIdAsync(readerId);
    return Results.Ok(loans);
});

app.MapPost("/loans/{loanId:int}/return", async (int loanId, ILoanService service) =>
{
    try
    {
        var loan = await service.ReturnBookAsync(loanId);
        return loan is null ? Results.NotFound() : Results.Ok(loan);
    }
    catch (Exception ex)
    {
        return Results.BadRequest(ex.Message);
    }
});

app.Run();