Phase 1: Replace GenericServices with Custom Services, MediatR, and FluentValidation

SampleWebApp.Core/Adapters/GenericServicesAdapter.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using AutoMapper;
+using MediatR;
+using SampleWebApp.Core.Common.Results;
+using SampleWebApp.Core.DTOs;
+using SampleWebApp.Core.Handlers.Posts.Commands;
+using SampleWebApp.Core.Handlers.Posts.Queries;
+
+namespace SampleWebApp.Core.Adapters
+{
+    public class GenericServicesAdapter
+    {
+        private readonly IMediator _mediator;
+        private readonly IMapper _mapper;
+
+        public GenericServicesAdapter(IMediator mediator, IMapper mapper)
+        {
+            _mediator = mediator;
+            _mapper = mapper;
+        }
+
+        public async Task<IQueryable<SimplePostDto>> GetAllPosts()
+        {
+            var query = new GetPostsQuery();
+            var result = await _mediator.Send(query);
+            return result.AsQueryable();
+        }
+
+        public async Task<IQueryable<SimplePostDto>> GetPostsByBlogId(int blogId)
+        {
+            var query = new GetPostsQuery { BlogId = blogId };
+            var result = await _mediator.Send(query);
+            return result.AsQueryable();
+        }
+
+        public async Task<ISuccessOrErrors<PostDto>> GetPostDetail(int id)
+        {
+            try
+            {
+                var query = new GetPostByIdQuery { Id = id };
+                var result = await _mediator.Send(query);
+
+                if (result == null)
+                {
+                    return SuccessOrErrors<PostDto>.FailSingleError("Post not found");
+                }
+
+                return SuccessOrErrors<PostDto>.Success(result);
+            }
+            catch (Exception ex)
+            {
+                return SuccessOrErrors<PostDto>.FailSingleError(ex.Message);
+            }
+        }
+
+        public async Task<ISuccessOrErrors<PostDto>> CreatePost(PostDto dto)
+        {
+            try
+            {
+                var command = new CreatePostCommand { Post = dto };
+                var result = await _mediator.Send(command);
+
+                if (!result.IsValid)
+                {
+                    return SuccessOrErrors<PostDto>.FailSingleError(string.Join(", ", result.Errors));
+                }
+
+                dto.PostId = result.CreatedId;
+                return SuccessOrErrors<PostDto>.Success(dto, result.SuccessMessage);
+            }
+            catch (Exception ex)
+            {
+                return SuccessOrErrors<PostDto>.FailSingleError(ex.Message);
+            }
+        }
+
+        public async Task<ISuccessOrErrors> UpdatePost(PostDto dto)
+        {
+            try
+            {
+                var command = new UpdatePostCommand { Post = dto };
+                var result = await _mediator.Send(command);
+
+                if (!result.IsValid)
+                {
+                    return SuccessOrErrors.FailSingleError(string.Join(", ", result.Errors));
+                }
+
+                return SuccessOrErrors.Success(result.SuccessMessage);
+            }
+            catch (Exception ex)
+            {
+                return SuccessOrErrors.FailSingleError(ex.Message);
+            }
+        }
+
+        public async Task<ISuccessOrErrors> DeletePost(int id)
+        {
+            try
+            {
+                var command = new DeletePostCommand { Id = id };
+                var result = await _mediator.Send(command);
+
+                if (!result.IsValid)
+                {
+                    return SuccessOrErrors.FailSingleError(string.Join(", ", result.Errors));
+                }
+
+                return SuccessOrErrors.Success(result.SuccessMessage);
+            }
+            catch (Exception ex)
+            {
+                return SuccessOrErrors.FailSingleError(ex.Message);
+            }
+        }
+
+        public async Task<PostDto> GetCreateDto()
+        {
+            return await Task.FromResult(new PostDto());
+        }
+
+        public async Task<PostDto> ResetDto(PostDto dto)
+        {
+            return await Task.FromResult(dto);
+        }
+    }
+}

SampleWebApp.Core/Common/BaseDto.cs

@@ -0,0 +1,14 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace SampleWebApp.Core.Common
+{
+    public abstract class BaseDto
+    {
+        [Key]
+        public int Id { get; set; }
+    }
+
+    public abstract class BaseDto<TEntity> : BaseDto where TEntity : class
+    {
+    }
+}

SampleWebApp.Core/Common/Commands/BaseCommand.cs

@@ -0,0 +1,8 @@
+using MediatR;
+
+namespace SampleWebApp.Core.Common.Commands
+{
+    public abstract class BaseCommand<TResponse> : IRequest<TResponse>
+    {
+    }
+}

SampleWebApp.Core/Common/Queries/BaseQuery.cs

@@ -0,0 +1,8 @@
+using MediatR;
+
+namespace SampleWebApp.Core.Common.Queries
+{
+    public abstract class BaseQuery<TResponse> : IRequest<TResponse> where TResponse : class
+    {
+    }
+}

SampleWebApp.Core/Common/Results/CreateResult.cs

@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+
+namespace SampleWebApp.Core.Common.Results
+{
+    public class CreateResult
+    {
+        public bool IsValid => Errors.Count == 0;
+        public string SuccessMessage { get; private set; }
+        public List<string> Errors { get; private set; }
+        public int CreatedId { get; private set; }
+
+        private CreateResult()
+        {
+            Errors = new List<string>();
+        }
+
+        public static CreateResult Success(string message, int createdId = 0)
+        {
+            return new CreateResult
+            {
+                SuccessMessage = message,
+                CreatedId = createdId
+            };
+        }
+
+        public static CreateResult Fail(string error)
+        {
+            var result = new CreateResult();
+            result.Errors.Add(error);
+            return result;
+        }
+
+        public static CreateResult Fail(IEnumerable<string> errors)
+        {
+            var result = new CreateResult();
+            result.Errors.AddRange(errors);
+            return result;
+        }
+    }
+}

SampleWebApp.Core/Common/Results/DeleteResult.cs

@@ -0,0 +1,38 @@
+using System.Collections.Generic;
+
+namespace SampleWebApp.Core.Common.Results
+{
+    public class DeleteResult
+    {
+        public bool IsValid => Errors.Count == 0;
+        public string SuccessMessage { get; private set; }
+        public List<string> Errors { get; private set; }
+
+        private DeleteResult()
+        {
+            Errors = new List<string>();
+        }
+
+        public static DeleteResult Success(string message)
+        {
+            return new DeleteResult
+            {
+                SuccessMessage = message
+            };
+        }
+
+        public static DeleteResult Fail(string error)
+        {
+            var result = new DeleteResult();
+            result.Errors.Add(error);
+            return result;
+        }
+
+        public static DeleteResult Fail(IEnumerable<string> errors)
+        {
+            var result = new DeleteResult();
+            result.Errors.AddRange(errors);
+            return result;
+        }
+    }
+}

SampleWebApp.Core/Common/Results/PagedResult.cs

@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+
+namespace SampleWebApp.Core.Common.Results
+{
+    public class PagedResult<T> where T : class
+    {
+        public IEnumerable<T> Items { get; set; }
+        public int TotalCount { get; set; }
+        public int Page { get; set; }
+        public int PageSize { get; set; }
+        public int TotalPages => (TotalCount + PageSize - 1) / PageSize;
+        public bool HasPreviousPage => Page > 1;
+        public bool HasNextPage => Page < TotalPages;
+
+        public PagedResult()
+        {
+            Items = new List<T>();
+        }
+
+        public PagedResult(IEnumerable<T> items, int totalCount, int page, int pageSize)
+        {
+            Items = items;
+            TotalCount = totalCount;
+            Page = page;
+            PageSize = pageSize;
+        }
+    }
+}