Erlend Skutlaberg

.gitignore

@@ -368,4 +368,6 @@ FodyWeavers.xsd
 */**/obj/Release   
 */Migrations
 /exercise.wwwapi/appsettings.json
+
 /exercise.wwwapi/appsettings.Development.json
+

exercise.webapi/DTO/AuthorDTO.cs

@@ -0,0 +1,25 @@
+using System;
+using exercise.webapi.Models;
+
+namespace exercise.webapi.DTO;
+
+public class AuthorDTO
+{
+    public int Id {get; set;}
+    public string FirstName {get;set;}
+    public string LastName {get;set;}
+    public string Email {get;set;}
+    public ICollection<Tuple<string, string>> PublisherBooks {get;set;} = new List<Tuple<string, string>>();
+
+    public AuthorDTO(Author author)
+    {
+        Id = author.Id;
+        FirstName = author.FirstName;
+        LastName = author.LastName;
+        Email = author.Email;
+        foreach (Book b in author.Books)
+        {
+            PublisherBooks.Add(new Tuple<string, string>(b.Title, b.Publisher.Name));
+        }
+    }
+}

exercise.webapi/DTO/AuthorGetBookDTO.cs

@@ -0,0 +1,21 @@
+using System;
+using exercise.webapi.Models;
+
+namespace exercise.webapi.DTO;
+
+public class AuthorGetBookDTO
+{
+
+    public int Id {get; set;}
+    public string FirstName {get;set;}
+    public string LastName {get;set;}
+    public string Email {get;set;}
+
+    public AuthorGetBookDTO(Author author)
+    {
+        Id = author.Id;
+        FirstName = author.FirstName;
+        LastName = author.LastName;
+        Email = author.Email;
+    }
+}

exercise.webapi/DTO/AuthorPostDTO.cs

@@ -0,0 +1,8 @@
+using System;
+
+namespace exercise.webapi.DTO;
+
+public class AuthorPostDTO
+{
+    public int Id {get; set;}
+}

exercise.webapi/DTO/BookDTO.cs

@@ -0,0 +1,28 @@
+using System;
+using exercise.webapi.Models;
+
+namespace exercise.webapi.DTO;
+
+public class BookDTO
+{
+    public int Id { get; set; }
+    public string Title { get; set; }
+
+    public int AuthorId { get; set; }
+    public string PublisherName {get; set;}
+    public AuthorGetBookDTO Author { get; set; }
+
+
+    public BookDTO(Book book)
+    {
+        Id = book.Id;
+        Title = book.Title;
+        AuthorId = book.AuthorId;
+        PublisherName = book.Publisher.Name;
+        Author = new AuthorGetBookDTO(book.Author);
+
+
+
+
+    }
+}

exercise.webapi/DTO/BookGetAuthorDTO.cs

@@ -0,0 +1,16 @@
+using System;
+using exercise.webapi.Models;
+
+namespace exercise.webapi.DTO;
+
+public class BookGetAuthorDTO
+{
+    public int Id {get;set;}
+    public string Title {get;set;}
+
+    public BookGetAuthorDTO(Book b)
+    {
+        Id = b.Id;
+        Title = b.Title;
+    }
+}

exercise.webapi/DTO/CreateBookDTO.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace exercise.webapi.DTO;
+
+public class CreateBookDTO
+{
+    public string Title { get; set; }
+
+    public int AuthorId { get; set; }
+}

exercise.webapi/DTO/PublisherGetDTO.cs

@@ -0,0 +1,23 @@
+using System;
+using exercise.webapi.Models;
+
+namespace exercise.webapi.DTO;
+
+public class PublisherGetDTO
+{
+
+    public int Id {get;set;}
+    public string Name {get;set;}
+    public List<BookDTO> Books {get;set;} = new List<BookDTO>();
+
+
+    public PublisherGetDTO(Publisher p)
+    {
+        Id = p.Id;
+        Name = p.Name;
+        foreach (Book b in p.Books)
+        {
+            Books.Add(new BookDTO(b));
+        }
+    }
+}

exercise.webapi/Data/DataContext.cs

@@ -24,9 +24,11 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
 
             modelBuilder.Entity<Author>().HasData(seeder.Authors);
             modelBuilder.Entity<Book>().HasData(seeder.Books);
+            modelBuilder.Entity<Publisher>().HasData(seeder.Publishers);
 
         }
         public DbSet<Author> Authors { get; set; }
         public DbSet<Book> Books { get; set; }
+        public DbSet<Publisher> Publishers {get;set;}
     }
 }

exercise.webapi/Data/Seeder.cs

@@ -77,16 +77,29 @@ public class Seeder
             "Leopards"
         };
 
+        private List<string> _publisher = new List<string>()
+        {
+            "Hot Taco", "Beer", "Hotsauce inc.", "Git Gabble"
+        };
+
         private List<Author> _authors = new List<Author>();
         private List<Book> _books = new List<Book>();
+        private List<Publisher> _publishers = new List<Publisher>();
 
         public Seeder()
         {
 
             Random authorRandom = new Random();
             Random bookRandom = new Random();
+            Random publisherRandom = new Random();
 
-
+            for (int z = 1; z < 50; z++)
+            {
+                Publisher p = new Publisher();
+                p.Id = z;
+                p.Name = $"{_firstword[publisherRandom.Next(_firstword.Count)]} {_publisher[publisherRandom.Next(_publisher.Count)]}";
+                _publishers.Add(p);
+            }
 
             for (int x = 1; x < 250; x++)
             {
@@ -105,13 +118,17 @@ public Seeder()
                 book.Id = y;
                 book.Title = $"{_firstword[bookRandom.Next(_firstword.Count)]} {_secondword[bookRandom.Next(_secondword.Count)]} {_thirdword[bookRandom.Next(_thirdword.Count)]}";
                 book.AuthorId = _authors[authorRandom.Next(_authors.Count)].Id;
+                book.PublisherId = _publishers[publisherRandom.Next(_publishers.Count)].Id;
                 //book.Author = authors[book.AuthorId-1];
                 _books.Add(book);
             }
 
+
+
 
         }
         public List<Author> Authors { get { return _authors; } }
         public List<Book> Books { get { return _books; } }
+        public List<Publisher> Publishers {get {return _publishers;}}
     }
 }

exercise.webapi/Endpoints/AuthorApi.cs

@@ -0,0 +1,43 @@
+using System;
+using exercise.webapi.DTO;
+using exercise.webapi.Models;
+using exercise.webapi.Payload;
+using exercise.webapi.Repository;
+using Microsoft.AspNetCore.Mvc;
+
+namespace exercise.webapi.Endpoints;
+
+public static class AuthorApi
+{
+
+    public static void ConfigureAuthorApi(this WebApplication app)
+    {
+        var author = app.MapGroup("/author");
+
+        author.MapGet("/{id}", GetAuthor);
+        author.MapGet("/", GetAuthors);
+
+
+    }
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public static async Task<IResult> GetAuthor(IAuthorRepository authorRepository, int id)
+    {
+        Payload<AuthorDTO> payload = await authorRepository.GetAuthor(id);
+
+        if (!payload.GoodResponse)
+        {
+            return TypedResults.NotFound(payload.Message);
+        }
+
+        return TypedResults.Ok(payload.Data);
+    }
+
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public static async Task<IResult> GetAuthors(IAuthorRepository authorRepository)
+    {
+        Payload<IEnumerable<AuthorDTO>> payload = await authorRepository.GetAuthors();
+
+        return TypedResults.Ok(payload.Data);
+    }
+}

exercise.webapi/Endpoints/BookApi.cs

@@ -1,5 +1,8 @@
-using exercise.webapi.Models;
+using exercise.webapi.DTO;
+using exercise.webapi.Models;
+using exercise.webapi.Payload;
 using exercise.webapi.Repository;
+using Microsoft.AspNetCore.Mvc;
 using static System.Reflection.Metadata.BlobBuilder;
 
 namespace exercise.webapi.Endpoints
@@ -8,13 +11,77 @@ public static class BookApi
     {
         public static void ConfigureBooksApi(this WebApplication app)
         {
-            app.MapGet("/books", GetBooks);
+            var books = app.MapGroup("/books");
+            books.MapGet("/", GetBooks);
+            books.MapGet("/{id}", GetBook);
+            books.MapPut("/{id}", UpdateAuthor);
+            books.MapDelete("/{id}", DeleteBook);
+            books.MapPost("/", CreateBook);
         }
 
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
         private static async Task<IResult> GetBooks(IBookRepository bookRepository)
         {
-            var books = await bookRepository.GetAllBooks();
-            return TypedResults.Ok(books);
+            Payload<IEnumerable<BookDTO>> payload  = await bookRepository.GetAllBooks();
+            return TypedResults.Ok(payload.Data);
+        }
+
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        private static async Task<IResult> GetBook(IBookRepository bookRepository, int id)
+        {
+            Payload<BookDTO> payload = await bookRepository.GetBook(id);
+            if (!payload.GoodResponse)
+            {
+                return TypedResults.NotFound(payload.Message);
+            }
+
+            return TypedResults.Ok(payload.Data);
+        }
+
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        private static async Task<IResult> UpdateAuthor(IBookRepository bookRepository, int bookId, AuthorPostDTO authorPost)
+        {
+            Payload<BookDTO> payload = await bookRepository.UpdateAuthor(bookId, authorPost);
+
+            if (!payload.GoodResponse)
+            {
+                return TypedResults.NotFound(payload.Message);
+            }
+
+            return TypedResults.Ok(payload.Data);
+        }
+
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        private static async Task<IResult> DeleteBook(IBookRepository bookRepository, int id)
+        {
+            Payload<BookDTO> payload = await bookRepository.DeleteBook(id);
+
+            if (!payload.GoodResponse)
+            {
+                return TypedResults.NotFound(payload.Message);
+            }
+
+            return TypedResults.Ok(payload.Data);
+        }
+
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        private static async Task<IResult> CreateBook(IBookRepository bookRepository, CreateBookDTO createBookDTO)
+        {
+            Payload<BookDTO> payload = await bookRepository.CreateBook(createBookDTO);
+
+            if (!payload.GoodResponse)
+            {
+                return TypedResults.NotFound(payload.Message);
+            }
+
+            return TypedResults.Ok(payload.Data);
+
+
         }
     }
 }

exercise.webapi/Endpoints/PublisherAPI.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Xml.Serialization;
+using exercise.webapi.DTO;
+using exercise.webapi.Payload;
+using exercise.webapi.Repository;
+using Microsoft.AspNetCore.Mvc;
+
+namespace exercise.webapi.Endpoints;
+
+public static class PublisherAPI
+{
+
+    public static void ConfigurePublisherApi(this WebApplication app)
+    {
+        var publisher = app.MapGroup("/publishers");
+
+        publisher.MapGet("/", GetPublishers);
+        publisher.MapGet("/{id}", GetPublisher);
+
+
+    }   
+
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public static async Task<IResult> GetPublishers(IPublisherRepository publisherRepository)
+    {
+        Payload<List<PublisherGetDTO>> payload = await publisherRepository.GetPublishers();
+
+        if (!payload.GoodResponse)
+        {
+            return TypedResults.NotFound(payload.Message);
+        }
+
+        return TypedResults.Ok(payload.Data);
+
+    } 
+
+
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public static async Task<IResult> GetPublisher(IPublisherRepository publisherRepository, int id)
+    {
+        Payload<PublisherGetDTO> payload = await publisherRepository.GetPublisher(id);
+
+        if (!payload.GoodResponse)
+        {
+            return TypedResults.NotFound(payload.Message);
+        }
+
+        return TypedResults.Ok(payload.Data);
+    }
+}