Dev

src/Application/Application.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
     <RootNamespace>CodeClinic.Application</RootNamespace>
     <AssemblyName>CodeClinic.Application</AssemblyName>
   </PropertyGroup>
@@ -12,7 +12,7 @@
     <PackageReference Include="FluentValidation" Version="8.6.0" />
     <PackageReference Include="FluentValidation.DependencyInjectionExtensions" Version="8.6.0" />
     <PackageReference Include="MediatR.Extensions.Microsoft.DependencyInjection" Version="8.0.0" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="3.1.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="5.0.0" />
   </ItemGroup>
 
   <ItemGroup>

src/Application/Categories/Commands/CreateCategory/CreateCategoryCommand.cs

@@ -0,0 +1,15 @@
+using MediatR;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CodeClinic.Application.Categories.Commands.CreateCategory
+{
+    public  class CreateCategoryCommand : IRequest<int>
+   {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public string Description { get; set; }
+
+    }
+}

src/Application/Categories/Commands/CreateCategory/CreateCategoryCommandHandler.cs

@@ -0,0 +1,33 @@
+using CodeClinic.Application.Common.Interfaces;
+using CodeClinic.Domain.Entities;
+using MediatR;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CodeClinic.Application.Categories.Commands.CreateCategory
+{
+    public class CreateCategoryCommandHandler : IRequestHandler<CreateCategoryCommand, int>
+    {
+        private readonly IApplicationDbContext _context;
+
+        public CreateCategoryCommandHandler(IApplicationDbContext context)
+        {
+            _context = context;
+        }
+        public async Task<int> Handle(CreateCategoryCommand request, CancellationToken cancellationToken)
+        {
+            var category = new Category
+            {
+                Name = request.Name,
+                Description = request.Description,
+
+            };
+
+            _context.Categories.Add(category);
+
+          await  _context.SaveChangesAsync(cancellationToken);
+
+            return category.Id;
+        }
+    }
+}

src/Application/Categories/Commands/CreateCategory/CreateCategoryCommandValidator.cs

@@ -0,0 +1,35 @@
+using CodeClinic.Application.Common.Interfaces;
+using FluentValidation;
+using Microsoft.EntityFrameworkCore;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CodeClinic.Application.Categories.Commands.CreateCategory
+{
+    public class CreateCategoryCommandValidator : AbstractValidator<CreateCategoryCommand>
+    {
+        private readonly IApplicationDbContext _context;
+
+        public CreateCategoryCommandValidator(IApplicationDbContext context)
+        {
+            RuleFor(n => n.Name)
+                .MaximumLength(50)
+                .WithMessage("Name should not be greater than 50 characters")
+                .NotNull().NotEmpty().WithMessage("Name is required")
+                .MustAsync(BeUnique).WithMessage("Category must be Unique");
+
+            RuleFor(d => d.Description)
+                .MaximumLength(500).WithMessage("Description should be short") ;
+            _context = context;
+        }
+
+        public async Task<bool> BeUnique(CreateCategoryCommand request,string name,CancellationToken cancellationToken)
+        {
+            return await _context
+                .Categories
+                .Where(n => n.Id != request.Id)
+                .AllAsync(n => n.Name != request.Name);
+        }
+    }
+}

src/Application/Categories/Commands/DeleteCategory/DeleteCategoryCommand.cs

@@ -0,0 +1,13 @@
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Linq;
+using System.Text;
+
+namespace CodeClinic.Application.Categories.Commands.DeleteCategory
+{
+    public  class DeleteCategoryCommand :IRequest
+    {
+        public int Id { get; set; }
+    }
+}

src/Application/Categories/Commands/DeleteCategory/DeleteCategoryCommandHandler.cs

@@ -0,0 +1,35 @@
+using CodeClinic.Application.Common.Exceptions;
+using CodeClinic.Application.Common.Interfaces;
+using CodeClinic.Domain.Entities;
+using MediatR;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CodeClinic.Application.Categories.Commands.DeleteCategory
+{
+    public class DeleteCategoryCommandHandler : IRequestHandler<DeleteCategoryCommand>
+    {
+        private readonly IApplicationDbContext _context;
+
+        public DeleteCategoryCommandHandler(IApplicationDbContext context)
+        {
+            _context = context;
+
+        }
+
+        public async Task<Unit> Handle(DeleteCategoryCommand request, CancellationToken cancellationToken)
+        {
+
+            var entity = await _context.Categories.FindAsync(request.Id);
+
+            if (entity == null) throw new NotFoundException(nameof(Category), request.Id);
+
+            _context.Categories.Remove(entity);
+
+            await _context.SaveChangesAsync(cancellationToken);
+
+            return Unit.Value;
+        }
+    }
+}

src/Application/Categories/Commands/DeleteCategory/DeleteCategoryCommandValidator.cs

@@ -0,0 +1,16 @@
+using FluentValidation;
+
+namespace CodeClinic.Application.Categories.Commands.DeleteCategory
+{
+    public class DeleteCategoryCommandValidator : AbstractValidator<DeleteCategoryCommand>
+    {
+        public DeleteCategoryCommandValidator()
+        {
+
+
+            RuleFor(c => c.Id).NotNull()
+                .NotEmpty().WithMessage("Id Cannot be null");
+        }
+
+    }
+}

src/Application/Categories/Commands/UpdateCategory/UpdateCategoryCommand.cs

@@ -0,0 +1,14 @@
+using MediatR;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CodeClinic.Application.Categories.Commands.UpdateCategory
+{
+    public class UpdateCategoryCommand : IRequest
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public string Description { get; set; }
+    }
+}

src/Application/Categories/Commands/UpdateCategory/UpdateCategoryCommandHandler.cs

@@ -0,0 +1,35 @@
+using CodeClinic.Application.Common.Exceptions;
+using CodeClinic.Application.Common.Interfaces;
+using CodeClinic.Domain.Entities;
+using MediatR;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CodeClinic.Application.Categories.Commands.UpdateCategory
+{
+    public partial class UpdateCategoryCommandHandler : IRequestHandler<UpdateCategoryCommand>
+    {
+        private readonly IApplicationDbContext _context;
+
+        public UpdateCategoryCommandHandler(IApplicationDbContext context)
+        {
+            _context = context;
+        }
+        public async Task<Unit> Handle(UpdateCategoryCommand request, CancellationToken cancellationToken)
+        {
+            var categoryUpdate = await _context.Categories.FindAsync(request.Id);
+            if (categoryUpdate == null)
+                throw new NotFoundException(nameof(Category), request.Id);
+
+
+            categoryUpdate.Name = request.Name;
+            categoryUpdate.Description = request.Description;
+
+            _context.Categories.Update(categoryUpdate);
+
+           await _context.SaveChangesAsync(cancellationToken);
+
+            return Unit.Value;
+        }
+    }
+}

src/Application/Categories/Commands/UpdateCategory/UpdateCategoryCommandValidator.cs

@@ -0,0 +1,35 @@
+using CodeClinic.Application.Common.Interfaces;
+using FluentValidation;
+using Microsoft.EntityFrameworkCore;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CodeClinic.Application.Categories.Commands.UpdateCategory
+{
+
+    public partial class UpdateCategoryCommandHandler
+    {
+        public class UpdateCategoryCommandValidator : AbstractValidator<UpdateCategoryCommand>
+        {
+            private readonly IApplicationDbContext _context;
+
+            public UpdateCategoryCommandValidator(IApplicationDbContext context)
+            {
+                RuleFor(n => n.Name)
+                .MaximumLength(50)
+                .WithMessage("Name should not be greater than 50 characters")
+                .NotNull().NotEmpty().WithMessage("Name is required")
+                .MustAsync(BeUniqueName).WithMessage("Category must be Unique");
+
+                _context = context;
+            }
+            public async Task<bool> BeUniqueName(UpdateCategoryCommand model, string name, CancellationToken cancellationToken)
+            {
+                return await _context.Categories
+                    .Where(l => l.Id != model.Id)
+                    .AllAsync(l => l.Name != name);
+            }
+        }
+    }
+}

src/Application/Categories/Queries/GetCategoryDetail/CategoryDetailVm.cs

@@ -0,0 +1,34 @@
+using AutoMapper;
+using CodeClinic.Application.Categories.Queries.GetCategoryList;
+using CodeClinic.Application.Common.Mappings;
+using CodeClinic.Application.Issues.Queries.GetIssueList;
+using CodeClinic.Domain.Entities;
+using System;
+using System.Collections.Generic;
+
+namespace CodeClinic.Application.Categories.Queries.GetCategory
+{
+    public class CategoryDetailVm : IMapFrom<Category>
+    {
+        public int CategoryId { get; set; }
+        public string CategoryName { get; set; }
+        public string CategoryDescription { get; set; }
+
+        public DateTime DateCreated { get; set; }
+
+        public string LastModifiedBy { get; set; }
+
+        public DateTime? LastModified { get; set; }
+        public IList<IssueTicketDto> IssuesTickets { get; set; } = new List<IssueTicketDto>();
+
+
+
+        public void Mapping(Profile profile)
+        {
+            profile.CreateMap<Category, CategoryDetailVm>()
+                .ForMember(d => d.CategoryId, opt => opt.MapFrom(s => s.Id))
+                .ForMember(c=> c.CategoryName , cd=> cd.MapFrom(c=> c.Name))
+                .ForMember(c=> c.CategoryDescription,op=> op.MapFrom(d=> d.Description));
+        }
+    }
+}

src/Application/Categories/Queries/GetCategoryDetail/GetCategoryDetailQuery.cs

@@ -0,0 +1,50 @@
+using AutoMapper;
+using AutoMapper.QueryableExtensions;
+using CodeClinic.Application.Common.Exceptions;
+using CodeClinic.Application.Common.Interfaces;
+using CodeClinic.Application.Issues.Queries.GetIssueList;
+using CodeClinic.Domain.Entities;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CodeClinic.Application.Categories.Queries.GetCategory
+{
+    public class GetCategoryDetailQuery:IRequest<CategoryDetailVm>
+    {
+        public int Id { get;  set; }
+    }
+
+    public class GetCategoryDetailQueryHandler : IRequestHandler<GetCategoryDetailQuery, CategoryDetailVm>
+    {
+        private readonly IApplicationDbContext _context;
+        private readonly IMapper _mapper;
+
+        public GetCategoryDetailQueryHandler(IApplicationDbContext context,IMapper mapper)
+        {
+            _context = context;
+            _mapper = mapper;
+        }
+        public async Task<CategoryDetailVm> Handle(GetCategoryDetailQuery request, CancellationToken cancellationToken)
+        {
+            var viewModel = await _context.Categories
+                .ProjectTo<CategoryDetailVm>(_mapper.ConfigurationProvider)
+                .FirstOrDefaultAsync(p => p.CategoryId == request.Id, cancellationToken);
+
+            if (viewModel == null) throw new NotFoundException(nameof(Category), request.Id);
+
+            var issueTicketList = await _context.IssueTickets.ProjectTo<IssueTicketDto>(_mapper.ConfigurationProvider)
+                .Where(c => c.CategoryId == request.Id).ToListAsync();
+
+
+            viewModel.IssuesTickets = issueTicketList;
+            return viewModel;
+        }
+    }
+
+}

src/Application/Categories/Queries/GetCategoryList/CategoryDto.cs

@@ -0,0 +1,21 @@
+using AutoMapper;
+using CodeClinic.Application.Common.Mappings;
+using CodeClinic.Application.Issues.Queries.GetIssueList;
+using CodeClinic.Domain.Entities;
+using System.Collections.Generic;
+
+namespace CodeClinic.Application.Categories.Queries.GetCategoryList
+{
+    public class CategoryDto : IMapFrom<Category>
+    {
+        public int CategoryId { get; set; }
+        public string Name { get; set; }
+        public string Description { get; set; }
+
+        public void Mapping(Profile profile)
+        {
+            profile.CreateMap<Category, CategoryDto>()
+                .ForMember(i => i.CategoryId, op => op.MapFrom(s => s.Id));
+        }
+    }
+}