netcore-blueprint 0.0.1 → 0.0.3

package/BlueprintTemplate/Shared.Infrastructure/Services/Mongo/MongoItemInfra.cs

@@ -0,0 +1,117 @@
+using Microsoft.Extensions.Logging;
+using MongoDB.Driver;
+using Shared.Core.Entities;
+using Shared.Core.Exceptions;
+using Shared.Core.Interfaces.SPI;
+using Shared.Core.Shared.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Text;
+
+namespace Shared.Infrastructure.Services.Mongo
+{
+    public class MongoItemInfra<T> : IItemInfra<T> where T : BaseEntity
+    {
+        public readonly IMongoCollection<T> _dbSet;
+        public readonly ILogger<MongoItemInfra<T>> _logger;
+
+        public MongoItemInfra(
+            IMongoDatabase database,
+            ILogger<MongoItemInfra<T>> logger)
+        {
+            _dbSet = database.GetCollection<T>(typeof(T).Name.ToLower());
+            _logger = logger;
+        }
+        public async Task AddItemAsync(T item)
+        {
+            try
+            {
+                await _dbSet.InsertOneAsync(item);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error while adding an item.");
+                throw Errors.CannotQueryError;
+            }
+        }
+
+        public async Task DeleteItemsAsync(List<Guid> ids)
+        {
+            try
+            {
+                // Build a filter to match all the IDs in the list
+                var filter = Builders<T>.Filter.In("Id", ids);
+
+                // Delete all matching documents
+                var result = await _dbSet.DeleteManyAsync(filter);
+                _logger.LogInformation($"Deleted {result.DeletedCount} items with the provided IDs.");
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, $"Error while deleting items with IDs: {string.Join(", ", ids)}");
+                throw Errors.CannotQueryError;
+            }
+        }
+
+        public async Task<T> GetItemByIdAsync(Guid id, params Expression<Func<T, object>>[] includes)
+        {
+            try
+            {
+                return await _dbSet.Find(Builders<T>.Filter.Eq("Id", id)).FirstOrDefaultAsync();
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, $"Error while fetching item with Id {id}");
+                throw Errors.CannotQueryError;
+            }
+        }
+
+        public async Task<PagerData<T>> GetItemsAsync(
+            PagingParams pagingParams,
+            params Expression<Func<T, object>>[] includes)
+        {
+            try
+            {
+                int skipValues = (pagingParams.Page - 1) * pagingParams.Per_Page;
+                var filter = Builders<T>.Filter.Empty;
+
+                var totalRecords = await _dbSet.CountDocumentsAsync(filter);
+                var items = await _dbSet
+                    .Find(filter)
+                    .Sort(Builders<T>.Sort.Descending("Id")) // Sort by descending Id, adjust field as needed
+                    .Skip(skipValues)
+                    .Limit(pagingParams.Per_Page)
+                    .ToListAsync();
+
+                return new PagerData<T>
+                {
+                    Items = items,
+                    TotalRecords = (int)totalRecords
+                };
+            }
+            catch (Exception ex)
+            {
+                // You can add logging here if needed
+                throw Errors.CannotQueryError;
+            }
+        }
+
+        public async Task UpdateItemAsync(T item)
+        {
+            try
+            {
+                var id = typeof(T).GetProperty("Id")?.GetValue(item);
+                if (id == null)
+                    throw Errors.CannotFindTheItem;
+
+                await _dbSet.ReplaceOneAsync(Builders<T>.Filter.Eq("Id", id), item);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error while updating an item.");
+                throw Errors.CannotQueryError;
+            }
+        }
+    }
+}

package/BlueprintTemplate/Shared.Infrastructure/Services/MySQL/MySQLItemInfra.cs

@@ -0,0 +1,132 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Shared.Core.Entities;
+using Shared.Core.Enums;
+using Shared.Core.Exceptions;
+using Shared.Core.Interfaces.SPI;
+using Shared.Core.Shared.Models;
+using System.Linq.Expressions;
+
+namespace Shared.Infrastructure.Services.MySQL
+{
+    public class MySQLItemInfra<T> : IItemInfra<T> where T : BaseEntity
+    {
+        public readonly DbContext _dbContext;
+        public readonly DbSet<T> _dbSet;
+        public ILogger _logger;
+        public MySQLItemInfra
+        (
+            MyDbContext dbContext,
+            ILogger<MySQLItemInfra<T>> logger
+        )
+        {
+            _dbContext = dbContext;
+            _logger = logger;
+            _dbSet = _dbContext.Set<T>();
+        }
+        public async Task AddItemAsync(T item)
+        {
+            try
+            {
+                _dbSet.Add(item);
+                await _dbContext.SaveChangesAsync();
+            }
+            catch (Exception)
+            {
+                _logger.LogError($"Cannot add an item");
+                throw Errors.CannotQueryError;
+            }
+        }
+
+        public async Task DeleteItemsAsync(List<Guid> ids)
+        {
+            try
+            {
+                List<T> items = _dbSet.Where(p => ids.Contains(p.Id)).ToList();
+                items.ForEach(i => i.Status = EntityStatus.Active);
+                _dbSet.UpdateRange(items);
+                await _dbContext.SaveChangesAsync();
+            }
+            catch (Exception)
+            {
+                _logger.LogError($"Cannot delete items");
+                throw Errors.CannotQueryError;
+            }
+        }
+
+        public virtual async Task<T?> GetItemByIdAsync(Guid id, params Expression<Func<T, object>>[] includes)
+        {
+            try
+            {
+                IQueryable<T> query = _dbSet;
+
+                // Apply includes dynamically
+                foreach (var include in includes)
+                {
+                    query = query.Include(include);
+                }
+
+                return await query.FirstOrDefaultAsync(p => p.Id == id);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Cannot get item with ID: {Id}", id);
+                throw Errors.CannotQueryError;
+            }
+        }
+
+        public virtual async Task<PagerData<T>> GetItemsAsync(
+            PagingParams pagingParams,
+            params Expression<Func<T, object>>[] includes)
+        {
+            try
+            {
+                int skipValues = (pagingParams.Page - 1) * pagingParams.Per_Page;
+                IQueryable<T> query = _dbSet
+                    .Where(p => p.Status == EntityStatus.Active)
+                    .OrderByDescending(p => p.Id);
+
+                // Apply includes dynamically
+                if (includes != null)
+                {
+                    foreach (var include in includes)
+                    {
+                        query = query.Include(include);
+                    }
+                }
+
+                List<T> items = await query
+                    .Skip(skipValues)
+                    .Take(pagingParams.Per_Page)
+                    .ToListAsync();
+
+                PagerData<T> pagerData = new PagerData<T>
+                {
+                    Items = items,
+                    TotalRecords = (await query.ToListAsync()).Count()
+                };
+
+                return pagerData;
+            }
+            catch (Exception)
+            {
+                _logger.LogError($"Cannot get items");
+                throw Errors.CannotQueryError;
+            }
+        }
+
+        public async Task UpdateItemAsync(T item)
+        {
+            try
+            {
+                _dbSet.Update(item);
+                await _dbContext.SaveChangesAsync();
+            }
+            catch (Exception)
+            {
+                _logger.LogError($"Cannot update an item");
+                throw Errors.CannotQueryError;
+            }
+        }
+    }
+}

package/BlueprintTemplate/Shared.Infrastructure/Services/RepositoryFactory.cs

@@ -0,0 +1,36 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Shared.Core.Entities;
+using Shared.Core.Interfaces.SPI;
+using Shared.Infrastructure.Services.Mongo;
+using Shared.Infrastructure.Services.MySQL;
+
+namespace Shared.Infrastructure.Services
+{
+    public class RepositoryFactory<T> : IRepositoryFactory<T> where T : BaseEntity
+    {
+        private readonly string _databaseType;
+        private readonly IServiceProvider _serviceProvider;
+
+        public RepositoryFactory(IConfiguration configuration, IServiceProvider serviceProvider)
+        {
+            _databaseType = configuration["Database:Type"]!;
+            _serviceProvider = serviceProvider;
+        }
+
+        public IItemInfra<T> CreateItemRepository()
+        {
+            var dbType = _databaseType.ToLower();
+            var entityType = typeof(T);
+
+            Type implementationType = dbType switch
+            {
+                "mysql" => typeof(MySQLItemInfra<>).MakeGenericType(entityType),
+                "mongodb" => typeof(MongoItemInfra<>).MakeGenericType(entityType),
+                _ => throw new ArgumentException("Invalid database type")
+            };
+
+            return (IItemInfra<T>)ActivatorUtilities.CreateInstance(_serviceProvider, implementationType);
+        }
+    }
+}

package/BlueprintTemplate/Shared.Infrastructure/Shared.Infrastructure.csproj

@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <ProjectReference Include="..\Shared.Core\Shared.Core.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="9.0.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="9.0.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="MongoDB.Driver" Version="3.6.0" />
+    <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="9.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Migrations\" />
+  </ItemGroup>
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

package/BlueprintTemplate/Shared.Infrastructure/SharedDependencyInjection.cs

@@ -0,0 +1,19 @@
+using Microsoft.Extensions.DependencyInjection;
+using Shared.Core.Interfaces.SPI;
+using Shared.Infrastructure.Services;
+
+namespace Shared.Infrastructure
+{
+    public static class SharedDependencyInjection
+    {
+        public static IServiceCollection AddSharedInfrastructure(
+            this IServiceCollection services)
+        {
+            services.AddScoped(
+                typeof(IRepositoryFactory<>),
+                typeof(RepositoryFactory<>));
+
+            return services;
+        }
+    }
+}

package/BlueprintTemplate/User.API/Controllers/Admin/UserController.cs

@@ -0,0 +1,153 @@
+using AutoMapper;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using Shared.Core.Shared.Models;
+using System.Diagnostics;
+using UserModule.Core.Dtos.Admin;
+using UserModule.Core.Entities;
+using UserModule.Core.Interfaces.API;
+
+namespace UserModule.API.Controllers.Admin
+{
+    /// <summary>
+    /// User Controller
+    /// </summary>
+    [Route("rest/v{version:apiVersion}/users")]
+    [Produces("application/json")]
+    [ApiController]
+    public class UserController : Controller
+    {
+        private readonly IMapper _mapper;
+        private ILogger _logger;
+        private readonly IUserService _userService;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="logger"></param>
+        /// <param name="mapper"></param>
+        /// <param name="userService"></param>
+        public UserController(
+            ILogger<UserController> logger,
+            IMapper mapper,
+            IUserService userService)
+        {
+            _mapper = mapper;
+            _logger = logger;
+            _userService = userService;
+        }
+
+        /// <summary>
+        /// Get users
+        /// </summary>
+        /// <param name="pagingParams"></param>
+        /// <returns></returns>
+        [HttpGet]
+        //[Authorize(Roles = "Admin")]
+        [ProducesResponseType(typeof(PagerData<UserResponseDto>), StatusCodes.Status200OK)]
+        public async Task<IActionResult> GetUsers([FromQuery] PagingParams pagingParams)
+        {
+            _logger.LogInformation($"Start getting users");
+            var stopwatch = Stopwatch.StartNew();
+
+            PagerData<User> users = await _userService.GetItemsAsync(pagingParams);
+            PagerData<UserResponseDto> userResponse = _mapper.Map<PagerData<UserResponseDto>>(users);
+
+            // Add custom headers
+            Response.Headers.Append("X-WP-Total", users.TotalRecords.ToString());
+
+            stopwatch.Stop();
+            _logger.LogInformation($"Getting users done in {stopwatch.ElapsedMilliseconds}");
+
+            return Ok(userResponse.Items);
+        }
+
+        /// <summary>
+        /// Get user by Id
+        /// </summary>
+        /// <param name="userId"></param>
+        /// <returns></returns>
+        [HttpGet("{userId}")]
+        //[Authorize(Roles = "Admin")]
+        [ProducesResponseType(typeof(UserResponseDto), StatusCodes.Status200OK)]
+        public async Task<IActionResult> GetUserById(Guid userId)
+        {
+            _logger.LogInformation($"Start getting a user with Id = {userId}");
+            var stopwatch = Stopwatch.StartNew();
+
+            User user = await _userService.GetItemByIdAsync(userId);
+            UserResponseDto userResponseDto = _mapper.Map<UserResponseDto>(user);
+
+            stopwatch.Stop();
+            _logger.LogInformation($"Getting an user done in {stopwatch.ElapsedMilliseconds}");
+
+            return Ok(userResponseDto);
+        }
+
+        /// <summary>
+        /// Update User
+        /// </summary>
+        /// <param name="userRequestDto"></param>
+        /// <returns></returns>
+        [HttpPut]
+        //[Authorize(Roles = "Admin")]
+        [ProducesResponseType(typeof(UserResponseDto), StatusCodes.Status200OK)]
+        public async Task<IActionResult> UpdateUser([FromBody] UserRequestDto userRequestDto)
+        {
+            _logger.LogInformation($"Start update a user");
+            var stopwatch = Stopwatch.StartNew();
+
+            User user = _mapper.Map<User>(userRequestDto);
+            await _userService.UpdateItemAsync(user);
+
+            stopwatch.Stop();
+            _logger.LogInformation($"Updating a user done in {stopwatch.ElapsedMilliseconds}");
+
+            return Ok();
+        }
+
+        /// <summary>
+        /// Delete User
+        /// </summary>
+        /// <param name="userIds"></param>
+        /// <returns></returns>
+        [HttpDelete]
+        [Authorize(Roles = "Admin")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public async Task<IActionResult> DeleteUser([FromBody] List<Guid> userIds)
+        {
+            _logger.LogInformation($"Start deleting a User");
+            Stopwatch stopwatch = Stopwatch.StartNew();
+
+            await _userService.DeleteItemsAsync(userIds);
+
+            stopwatch.Stop();
+            _logger.LogInformation($"Deleting a User done in {stopwatch.ElapsedMilliseconds}");
+
+            return Ok();
+        }
+
+        /// <summary>
+        /// Create user
+        /// </summary>
+        /// <param name="userRequestDto"></param>
+        /// <returns></returns>
+        [HttpPost]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public async Task<IActionResult> CreateUser([FromBody] UserRequestDto userRequestDto)
+        {
+            _logger.LogInformation($"Start creating a user");
+            var stopwatch = Stopwatch.StartNew();
+
+            User user = _mapper.Map<User>(userRequestDto);
+            await _userService.AddItemAsync(user);
+
+            stopwatch.Stop();
+            _logger.LogInformation($"Creating a user done in {stopwatch.ElapsedMilliseconds}");
+
+            return Ok();
+        }
+    }
+}

package/BlueprintTemplate/User.API/Mappers/DtoUserMappingProfile.cs

@@ -0,0 +1,27 @@
+using AutoMapper;
+using Shared.Core.Shared.Models;
+using UserModule.Core.Dtos.Admin;
+using UserModule.Core.Entities;
+
+namespace UserModule.API.Mappers
+{
+    /// <summary>
+    /// DtoUserMappingProfile
+    /// </summary>
+    public class DtoUserMappingProfile : Profile
+    {
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public DtoUserMappingProfile()
+        {
+            CreateMap<User, UserRequestDto>().ReverseMap();
+
+            CreateMap<PagerData<User>, PagerData<UserResponseDto>>().ReverseMap();
+
+            CreateMap<User, UserResponseDto>()
+                .ForMember(dest => dest.Role, opt => opt.MapFrom(src => src.Role.ToString()))
+                .ReverseMap();
+        }
+    }
+}

package/BlueprintTemplate/User.API/UserModule.API.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <ProjectReference Include="..\User.Core\UserModule.Core.csproj" />
+    <ProjectReference Include="..\Shared.Core\Shared.Core.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Controllers\Public\" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Asp.Versioning.Mvc" Version="8.1.1" />
+    <PackageReference Include="Asp.Versioning.Mvc.ApiExplorer" Version="8.1.1" />
+    <PackageReference Include="AutoMapper" Version="13.0.1" />
+    <PackageReference Include="Microsoft.AspNetCore.Authorization" Version="10.0.2" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc" Version="2.3.9" />
+  </ItemGroup>
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

package/BlueprintTemplate/User.Core/Dtos/Admin/UserRequestDto.cs

@@ -0,0 +1,12 @@
+using Shared.Core.Dtos.Requests;
+
+namespace UserModule.Core.Dtos.Admin
+{
+    public class UserRequestDto : BaseRequestDto
+    {
+        public string? Name { get; set; }
+        public string? Email { get; set; }
+        public string? Picture { get; set; }
+        public string? Role { get; set; }
+    }
+}

package/BlueprintTemplate/User.Core/Dtos/Admin/UserResponseDto.cs

@@ -0,0 +1,12 @@
+using Shared.Core.Dtos.Responses;
+
+namespace UserModule.Core.Dtos.Admin
+{
+    public class UserResponseDto : BaseResponseDto
+    {
+        public string? Name { get; set; }
+        public string? Email { get; set; }
+        public string? Picture { get; set; }
+        public string? Role { get; set; }
+    }
+}

package/BlueprintTemplate/User.Core/Entities/User.cs

@@ -0,0 +1,13 @@
+using Shared.Core.Entities;
+using UserModule.Core.Enums;
+
+namespace UserModule.Core.Entities
+{
+    public class User : BaseEntity
+    {
+        public string? Name { get; set; }
+        public string? Email { get; set; }
+        public string? Picture { get; set; }
+        public UserRole Role { get; set; }
+    }
+}

package/BlueprintTemplate/User.Core/Enums/UserRole.cs

@@ -0,0 +1,8 @@
+namespace UserModule.Core.Enums
+{
+    public enum UserRole
+    {
+        User,
+        Admin
+    }
+}

package/BlueprintTemplate/User.Core/Interfaces/API/IUserService.cs

@@ -0,0 +1,9 @@
+using Shared.Core.Interfaces.API;
+using UserModule.Core.Entities;
+
+namespace UserModule.Core.Interfaces.API
+{
+    public interface IUserService : IItemService<User>
+    {
+    }
+}

package/BlueprintTemplate/User.Core/Interfaces/SPI/IUserInfra.cs

@@ -0,0 +1,9 @@
+using Shared.Core.Interfaces.SPI;
+using UserModule.Core.Entities;
+
+namespace UserModule.Core.Interfaces.SPI
+{
+    public interface IUserInfra : IItemInfra<User>
+    {
+    }
+}

package/BlueprintTemplate/User.Core/Services/UserService.cs

@@ -0,0 +1,20 @@
+using Microsoft.Extensions.Logging;
+using Shared.Core.Interfaces.SPI;
+using Shared.Core.Services;
+using UserModule.Core.Entities;
+using UserModule.Core.Interfaces.API;
+using UserModule.Core.Interfaces.SPI;
+
+namespace UserModule.Core.Services
+{
+    public class UserService : ItemService<User>, IUserService
+    {
+        private readonly IUserInfra _userInfra;
+        public UserService(ILogger<UserService> logger,
+            IRepositoryFactory<User> repositoryFactory,
+            IUserInfra userInfra) : base(logger, repositoryFactory)
+        {
+            _userInfra = userInfra;
+        }
+    }
+}

package/BlueprintTemplate/User.Core/UserModule.Core.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <ProjectReference Include="..\Shared.Core\Shared.Core.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Dtos\Public\" />
+  </ItemGroup>
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

package/BlueprintTemplate/User.Infrastructure/Database/ItemConfiguration.cs

@@ -0,0 +1,27 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using UserModule.Core.Entities;
+
+namespace UserModule.Infrastructure.Database
+{
+    public class ItemConfiguration : IEntityTypeConfiguration<User>
+    {
+        public void Configure(EntityTypeBuilder<User> builder)
+        {
+            // Table
+            builder.ToTable("Users");
+
+            // Primary key
+            builder.HasKey(x => x.Id);
+
+            // BaseEntity (nếu có)
+            builder.Property(x => x.Id)
+                   .IsRequired();
+
+            // 👉 Các field khác cấu hình khi entity đã ổn định
+            // Ví dụ:
+            // builder.Property(x => x.Email).IsRequired().HasMaxLength(255);
+            // builder.HasIndex(x => x.Email).IsUnique();
+        }
+    }
+}