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

SampleWebApp.Core/Adapters/GenericServicesAdapter.cs

@@ -0,0 +1,148 @@
+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>> GetAllPostsAsync()
+        {
+            var query = new GetPostsQuery();
+            var result = await _mediator.Send(query);
+            return result.AsQueryable();
+        }
+
+        public async Task<IQueryable<SimplePostDto>> GetPostsByBlogIdAsync(int blogId)
+        {
+            var query = new GetPostsQuery { BlogId = blogId };
+            var result = await _mediator.Send(query);
+            return result.AsQueryable();
+        }
+
+        public async Task<ISuccessOrErrors<PostDto>> GetPostDetailAsync(int id)
+        {
+            try
+            {
+                var query = new GetPostByIdQuery(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>> GetPostForEditAsync(int id)
+        {
+            try
+            {
+                var query = new GetPostForEditQuery(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<PostDto> GetPostForCreateAsync()
+        {
+            var query = new GetPostForCreateQuery();
+            return await _mediator.Send(query);
+        }
+
+        public async Task<ISuccessOrErrors> CreatePostAsync(PostDto dto)
+        {
+            try
+            {
+                var command = new CreatePostCommand(dto);
+                var result = await _mediator.Send(command);
+
+                if (result.IsValid)
+                {
+                    return SuccessOrErrors.Success(result.SuccessMessage);
+                }
+
+                var errors = SuccessOrErrors.FailSingleError(result.Errors.FirstOrDefault()?.ErrorMessage ?? "Unknown error");
+                return errors;
+            }
+            catch (Exception ex)
+            {
+                return SuccessOrErrors.FailSingleError(ex.Message);
+            }
+        }
+
+        public async Task<ISuccessOrErrors> UpdatePostAsync(PostDto dto)
+        {
+            try
+            {
+                var command = new UpdatePostCommand(dto);
+                var result = await _mediator.Send(command);
+
+                if (result.IsValid)
+                {
+                    return SuccessOrErrors.Success(result.SuccessMessage);
+                }
+
+                var errors = SuccessOrErrors.FailSingleError(result.Errors.FirstOrDefault()?.ErrorMessage ?? "Unknown error");
+                return errors;
+            }
+            catch (Exception ex)
+            {
+                return SuccessOrErrors.FailSingleError(ex.Message);
+            }
+        }
+
+        public async Task<ISuccessOrErrors> DeletePostAsync(int id)
+        {
+            try
+            {
+                var command = new DeletePostCommand(id);
+                var result = await _mediator.Send(command);
+
+                if (result.IsValid)
+                {
+                    return SuccessOrErrors.Success(result.SuccessMessage);
+                }
+
+                var errors = SuccessOrErrors.FailSingleError(result.Errors.FirstOrDefault()?.ErrorMessage ?? "Unknown error");
+                return errors;
+            }
+            catch (Exception ex)
+            {
+                return SuccessOrErrors.FailSingleError(ex.Message);
+            }
+        }
+    }
+}

SampleWebApp.Core/Common/BaseDto.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace SampleWebApp.Core.Common
+{
+    public abstract class BaseDto
+    {
+        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> where TResponse : class
+    {
+    }
+}

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,34 @@
+using System.Collections.Generic;
+
+namespace SampleWebApp.Core.Common.Results
+{
+    public class CreateResult : OperationResult
+    {
+        public int CreatedId { get; private set; }
+
+        private CreateResult() { }
+
+        public static CreateResult Success(string message, int createdId = 0)
+        {
+            return new CreateResult
+            {
+                SuccessMessage = message,
+                CreatedId = createdId
+            };
+        }
+
+        public new static CreateResult Failure(string errorMessage, string propertyName = null)
+        {
+            var result = new CreateResult();
+            result.Errors.Add(new ValidationError(propertyName, errorMessage));
+            return result;
+        }
+
+        public new static CreateResult Failure(IEnumerable<ValidationError> errors)
+        {
+            var result = new CreateResult();
+            result.Errors.AddRange(errors);
+            return result;
+        }
+    }
+}

SampleWebApp.Core/Common/Results/DeleteResult.cs

@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+
+namespace SampleWebApp.Core.Common.Results
+{
+    public class DeleteResult : OperationResult
+    {
+        private DeleteResult() { }
+
+        public new static DeleteResult Success(string message = null)
+        {
+            return new DeleteResult { SuccessMessage = message };
+        }
+
+        public new static DeleteResult Failure(string errorMessage, string propertyName = null)
+        {
+            var result = new DeleteResult();
+            result.Errors.Add(new ValidationError(propertyName, errorMessage));
+            return result;
+        }
+
+        public new static DeleteResult Failure(IEnumerable<ValidationError> errors)
+        {
+            var result = new DeleteResult();
+            result.Errors.AddRange(errors);
+            return result;
+        }
+    }
+}

SampleWebApp.Core/Common/Results/OperationResult.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace SampleWebApp.Core.Common.Results
+{
+    public class OperationResult
+    {
+        public bool IsValid => !Errors.Any();
+        public string SuccessMessage { get; protected set; }
+        public List<ValidationError> Errors { get; protected set; } = new List<ValidationError>();
+
+        protected OperationResult() { }
+
+        public static OperationResult Success(string message = null)
+        {
+            return new OperationResult { SuccessMessage = message };
+        }
+
+        public static OperationResult Failure(string errorMessage, string propertyName = null)
+        {
+            var result = new OperationResult();
+            result.Errors.Add(new ValidationError(propertyName, errorMessage));
+            return result;
+        }
+
+        public static OperationResult Failure(IEnumerable<ValidationError> errors)
+        {
+            var result = new OperationResult();
+            result.Errors.AddRange(errors);
+            return result;
+        }
+
+        public void AddError(string errorMessage, string propertyName = null)
+        {
+            Errors.Add(new ValidationError(propertyName, errorMessage));
+        }
+
+        public string ErrorsAsHtml()
+        {
+            return string.Join("<br/>", Errors.Select(e => e.ErrorMessage));
+        }
+    }
+
+    public class ValidationError
+    {
+        public string PropertyName { get; }
+        public string ErrorMessage { get; }
+
+        public ValidationError(string propertyName, string errorMessage)
+        {
+            PropertyName = propertyName;
+            ErrorMessage = errorMessage;
+        }
+    }
+}

SampleWebApp.Core/Common/Results/PagedResult.cs

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