netcore-blueprint 0.0.16 → 0.0.18

package/Modules/ItemModule/ItemModule.API/Controllers/Public/ItemController.cs

@@ -0,0 +1,65 @@
+using AutoMapper;
+using ItemModule.Core.Dtos.Admin;
+using ItemModule.Core.Entities;
+using ItemModule.Core.Interfaces.API;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using Shared.Core.Shared.Models;
+using System.Diagnostics;
+
+namespace ItemModule.API.Controllers.Public
+{
+    /// <summary>
+    /// Item Controller
+    /// </summary>
+    [Route("rest/v{version:apiVersion}/items")]
+    [Produces("application/json")]
+    [ApiController]
+    public class ItemController : Controller
+    {
+        private readonly IMapper _mapper;
+        private ILogger _logger;
+        private readonly IItemService _itemService;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="logger"></param>
+        /// <param name="mapper"></param>
+        /// <param name="itemService"></param>
+        public ItemController(
+            ILogger<ItemController> logger,
+            IMapper mapper,
+            IItemService itemService)
+        {
+            _mapper = mapper;
+            _logger = logger;
+            _itemService = itemService;
+        }
+
+        /// <summary>
+        /// Get items
+        /// </summary>
+        /// <param name="pagingParams"></param>
+        /// <returns></returns>
+        [HttpGet]
+        [ProducesResponseType(typeof(PagerData<ItemResponseDto>), StatusCodes.Status200OK)]
+        public async Task<IActionResult> GetItems([FromQuery] PagingParams pagingParams)
+        {
+            _logger.LogInformation($"Start getting items");
+            var stopwatch = Stopwatch.StartNew();
+
+            PagerData<Item> items = await _itemService.GetItemsAsync(pagingParams);
+            PagerData<ItemResponseDto> itemResponse = _mapper.Map<PagerData<ItemResponseDto>>(items);
+
+            // Add custom headers
+            Response.Headers.Append("X-WP-Total", items.TotalRecords.ToString());
+
+            stopwatch.Stop();
+            _logger.LogInformation($"Getting items done in {stopwatch.ElapsedMilliseconds}");
+
+            return Ok(itemResponse.Items);
+        }
+    }
+}

package/Modules/ItemModule/ItemModule.API/ItemModule.API.csproj

@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Folder Include="Controllers\Admin\" />
+  </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="16.0.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Authorization" Version="10.0.2" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc" Version="2.3.9" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\ItemModule.Core\ItemModule.Core.csproj" />
+    <ProjectReference Include="..\ItemModule.Infrastructure\ItemModule.Infrastructure.csproj" />
+    <ProjectReference Include="..\Shared.Core\Shared.Core.csproj" />
+  </ItemGroup>
+
+</Project>

package/Modules/ItemModule/ItemModule.API/ItemModule.cs

@@ -0,0 +1,24 @@
+using ItemModule.API.Controllers.Public;
+using ItemModule.API.Mappers;
+using ItemModule.Core;
+using ItemModule.Infrastructure;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Shared.Core.Interfaces.Modules;
+using System.Reflection;
+
+namespace ItemModule.API
+{
+    public class ItemModule : IModule
+    {
+        public string Name => "Item";
+        public void Register(IServiceCollection services, IConfiguration config)
+        {
+            ItemCoreDependencyInjection.AddModule(services);
+            ItemInfraDependencyInjection.AddModule(services);
+        }
+
+        public Assembly ApiAssembly => typeof(ItemController).Assembly;
+        public Assembly MappingAssembly => typeof(DtoItemMappingProfile).Assembly;
+    }
+}

package/Modules/ItemModule/ItemModule.API/Mappers/DtoItemMappingProfile.cs

@@ -0,0 +1,26 @@
+using AutoMapper;
+using ItemModule.Core.Dtos.Admin;
+using ItemModule.Core.Entities;
+using Shared.Core.Shared.Models;
+
+namespace ItemModule.API.Mappers
+{
+    /// <summary>
+    /// DtoItemMappingProfile
+    /// </summary>
+    public class DtoItemMappingProfile : Profile
+    {
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public DtoItemMappingProfile()
+        {
+            CreateMap<Item, ItemRequestDto>().ReverseMap();
+
+            CreateMap<PagerData<Item>, PagerData<ItemResponseDto>>().ReverseMap();
+
+            CreateMap<Item, ItemResponseDto>()
+                .ReverseMap();
+        }
+    }
+}

package/Modules/ItemModule/ItemModule.Core/Dtos/Admin/ItemRequestDto.cs

@@ -0,0 +1,8 @@
+using Shared.Core.Dtos.Requests;
+
+namespace ItemModule.Core.Dtos.Admin
+{
+    public class ItemRequestDto : BaseRequestDto
+    {
+    }
+}

package/Modules/ItemModule/ItemModule.Core/Dtos/Admin/ItemResponseDto.cs

@@ -0,0 +1,8 @@
+using Shared.Core.Dtos.Responses;
+
+namespace ItemModule.Core.Dtos.Admin
+{
+    public class ItemResponseDto : BaseResponseDto
+    {
+    }
+}

package/Modules/ItemModule/ItemModule.Core/Entities/Item.cs

@@ -0,0 +1,8 @@
+using Shared.Core.Entities;
+
+namespace ItemModule.Core.Entities
+{
+    public class Item : BaseEntity
+    {
+    }
+}

package/Modules/ItemModule/ItemModule.Core/Interfaces/API/IItemService.cs

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

package/Modules/ItemModule/ItemModule.Core/Interfaces/SPI/IItemInfra.cs

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

package/Modules/ItemModule/ItemModule.Core/ItemCoreDependencyInjection.cs

@@ -0,0 +1,19 @@
+using ItemModule.Core.Interfaces.API;
+using ItemModule.Core.Services;
+using Microsoft.Extensions.DependencyInjection;
+using Shared.Core.Interfaces.API;
+using Shared.Core.Services;
+
+namespace ItemModule.Core
+{
+    public static class ItemCoreDependencyInjection
+    {
+        public static IServiceCollection AddModule(
+             this IServiceCollection services)
+        {
+            services.AddScoped(typeof(IItemService<>), typeof(ItemService<>));
+            services.AddScoped<IItemService, ItemService>();
+            return services;
+        }
+    }
+}

package/Modules/ItemModule/ItemModule.Core/ItemModule.Core.csproj

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

package/Modules/ItemModule/ItemModule.Core/Services/ItemService.cs

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

package/Modules/ItemModule/ItemModule.Infrastructure/Database/ItemConfiguration.cs

@@ -0,0 +1,22 @@
+using ItemModule.Core.Entities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ItemModule.Infrastructure.Database
+{
+    internal class ItemConfiguration : IEntityTypeConfiguration<Item>
+    {
+        public void Configure(EntityTypeBuilder<Item> builder)
+        {
+            // Table
+            builder.ToTable("Items");
+
+            // Primary key
+            builder.HasKey(x => x.Id);
+
+            // BaseEntity (nếu có)
+            builder.Property(x => x.Id)
+                   .IsRequired();
+        }
+    }
+}

package/Modules/ItemModule/ItemModule.Infrastructure/Database/Seeder.cs

@@ -0,0 +1,21 @@
+using ItemModule.Core.Entities;
+using Microsoft.EntityFrameworkCore;
+using Shared.Core.Enums;
+using Shared.Core.Interfaces.SPI;
+
+namespace ItemModule.Infrastructure.Database
+{
+    public class Seeder : IModuleSeeder
+    {
+        public void Seed(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<Item>().HasData(
+                new Item
+                {
+                    Id = Guid.Parse("11111111-1111-1111-1111-111111111111"),
+                    Status = EntityStatus.Active,
+                }
+            );
+        }
+    }
+}

package/Modules/ItemModule/ItemModule.Infrastructure/ItemInfraDependencyInjection.cs

@@ -0,0 +1,21 @@
+using ItemModule.Core.Interfaces.SPI;
+using ItemModule.Infrastructure.Database;
+using ItemModule.Infrastructure.Services;
+using Microsoft.Extensions.DependencyInjection;
+using Shared.Core.Interfaces.SPI;
+using Shared.Infrastructure.Services.MySQL;
+
+namespace ItemModule.Infrastructure
+{
+    public static class ItemInfraDependencyInjection
+    {
+        public static IServiceCollection AddModule(
+            this IServiceCollection services)
+        {
+            services.AddScoped<IModuleSeeder, Seeder>();
+            services.AddScoped<IItemInfra, MySQLItemInfra>();
+            services.AddScoped(typeof(IItemInfra<>), typeof(MySQLItemInfra<>));
+            return services;
+        }
+    }
+}

package/Modules/ItemModule/ItemModule.Infrastructure/ItemModule.Infrastructure.csproj

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

package/Modules/ItemModule/ItemModule.Infrastructure/Services/MySQLItemInfra.cs

@@ -0,0 +1,16 @@
+using ItemModule.Core.Entities;
+using ItemModule.Core.Interfaces.SPI;
+using Microsoft.Extensions.Logging;
+using Shared.Infrastructure.Database;
+using Shared.Infrastructure.Services.MySQL;
+
+namespace ItemModule.Infrastructure.Services
+{
+    public class MySQLItemInfra : MySQLItemInfra<Item>, IItemInfra
+    {
+        public MySQLItemInfra(MyDbContext dbContext, ILogger<MySQLItemInfra> logger)
+        : base(dbContext, logger)
+        {
+        }
+    }
+}

package/bin/create-module.js

@@ -1,3 +1,5 @@
+#!/usr/bin/env node
+
 const fs = require('fs');
 const path = require('path');
 
@@ -8,59 +10,70 @@ if (!newModuleName) {
 }
 
 const sourceModuleName = "ItemModule";
-const templatePath = path.join(__dirname, "..", "BlueprintTemplate");
-const destinationRoot = process.cwd(); // project root
 
-if (!fs.existsSync(templatePath)) {
-  console.error(`❌ BlueprintTemplate not found: ${templatePath}`);
+// 🔥 NEW: Modules folder (not BlueprintTemplate)
+const modulesTemplateRoot = path.join(__dirname, "..", "Modules");
+const sourceModulePath = path.join(modulesTemplateRoot, sourceModuleName);
+
+// Project root where new module will be created
+const destinationRoot = process.cwd();
+const destinationModulePath = path.join(destinationRoot, newModuleName);
+
+if (!fs.existsSync(sourceModulePath)) {
+  console.error(`❌ Source module not found: ${sourceModulePath}`);
   process.exit(1);
 }
 
-// Find all ItemModule.* folders
-const sourceFolders = fs.readdirSync(templatePath, { withFileTypes: true })
-  .filter(d => d.isDirectory() && d.name.startsWith(sourceModuleName));
-
-if (sourceFolders.length === 0) {
-  console.error(`❌ No ItemModule templates found in: ${templatePath}`);
+if (fs.existsSync(destinationModulePath)) {
+  console.error(`❌ Destination module already exists: ${destinationModulePath}`);
   process.exit(1);
 }
 
-for (const dir of sourceFolders) {
-  const srcPath = path.join(templatePath, dir.name);
-  const destName = dir.name.replace(
-    new RegExp(sourceModuleName, 'g'),
-    newModuleName
-  );
-  const destPath = path.join(destinationRoot, destName);
-
-  if (fs.existsSync(destPath)) {
-    console.error(`❌ Destination already exists: ${destPath}`);
-    process.exit(1);
-  }
+console.log(`📦 Creating module: ${newModuleName}`);
+console.log(`📁 From template: ${sourceModulePath}`);
+console.log(`📁 To: ${destinationModulePath}`);
 
-  console.log(`📦 Copying ${dir.name} -> ${destName}`);
-  copyAndRenameFiles(srcPath, destPath, sourceModuleName, newModuleName);
-}
+copyAndRenameFiles(
+  sourceModulePath,
+  destinationModulePath,
+  sourceModuleName,
+  newModuleName
+);
 
 console.log(`🎉 Module "${newModuleName}" created successfully!`);
 
 // ===== CORE LOGIC =====
 
 function copyAndRenameFiles(src, dest, oldName, newName) {
-  if (fs.lstatSync(src).isDirectory()) {
+  const stat = fs.lstatSync(src);
+
+  if (stat.isDirectory()) {
     fs.mkdirSync(dest, { recursive: true });
+
     const entries = fs.readdirSync(src, { withFileTypes: true });
 
-    for (let entry of entries) {
+    for (const entry of entries) {
       const srcPath = path.join(src, entry.name);
-      const destName = entry.name.replace(new RegExp(oldName, 'g'), newName);
-      const destPath = path.join(dest, destName);
+
+      // 🔁 Rename folder/file if contains old module name
+      const renamed = entry.name.replace(
+        new RegExp(oldName, 'g'),
+        newName
+      );
+
+      const destPath = path.join(dest, renamed);
 
       copyAndRenameFiles(srcPath, destPath, oldName, newName);
     }
   } else {
     let content = fs.readFileSync(src, 'utf8');
-    content = content.replace(new RegExp(oldName, 'g'), newName);
+
+    // 🔁 Replace namespace + content
+    content = content.replace(
+      new RegExp(oldName, 'g'),
+      newName
+    );
+
     fs.writeFileSync(dest, content, 'utf8');
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "netcore-blueprint",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "A custom project blueprint",
   "main": "create.js",
   "bin": {
@@ -17,7 +17,7 @@
   "author": "",
   "license": "ISC",
   "files": [
-    "bin",
+    "Modules/**",
     "BlueprintTemplate/**"
   ]
 }