netcore-blueprint 1.0.17 → 1.0.20

package/BlueprintTemplate/.vs/Blueprint.API/v17/DocumentLayout.json

@@ -0,0 +1,12 @@
+{
+  "Version": 1,
+  "WorkspaceRootPath": "D:\\@Projects\\@@ Blueprint\\NetWebAPIBlueprint\\Blueprint\\BlueprintTemplate\\",
+  "Documents": [],
+  "DocumentGroupContainers": [
+    {
+      "Orientation": 0,
+      "VerticalTabListWidth": 256,
+      "DocumentGroups": []
+    }
+  ]
+}

package/BlueprintTemplate/Blueprint.API/Blueprint.API.csproj

@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="AutoMapper" Version="13.0.1" />
+    <PackageReference Include="AWSSDK.Extensions.NETCore.Setup" Version="3.7.301" />
+    <PackageReference Include="AWSSDK.S3" Version="3.7.410.12" />
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="8.0.10" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Versioning" Version="5.1.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.10">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="RabbitMQ.Client" Version="7.0.0" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.4.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Blueprint.Core\Blueprint.Core.csproj" />
+    <ProjectReference Include="..\Blueprint.Infra\Blueprint.Infra.csproj" />
+  </ItemGroup>
+
+</Project>

package/BlueprintTemplate/Blueprint.API/Blueprint.API.csproj.user

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ActiveDebugProfile>https</ActiveDebugProfile>
+    <Controller_SelectedScaffolderID>MvcControllerEmptyScaffolder</Controller_SelectedScaffolderID>
+    <Controller_SelectedScaffolderCategoryPath>root/Common/MVC/Controller</Controller_SelectedScaffolderCategoryPath>
+  </PropertyGroup>
+</Project>

package/BlueprintTemplate/Blueprint.API/Blueprint.API.http

@@ -0,0 +1,6 @@
+@Blueprint.API_HostAddress = http://localhost:5262
+
+GET {{Blueprint.API_HostAddress}}/weatherforecast/
+Accept: application/json
+
+###

package/BlueprintTemplate/Blueprint.API/Controllers/UserController.cs

@@ -0,0 +1,179 @@
+using AutoMapper;
+using Blueprint.Core.Entities;
+using Blueprint.Core.Models;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using System.Diagnostics;
+using Template.Core.Dtos.Requests;
+using Template.Core.Dtos.Responses;
+using Template.Core.Interfaces.API;
+
+namespace Template.API.Controllers
+{
+    /// <summary>
+    /// User Controller
+    /// </summary>
+    [Route("rest/v1.0/users")]
+    [ApiVersion("1.0")]
+    [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}")]
+        [ProducesResponseType(typeof(UserResponseDto), StatusCodes.Status200OK)]
+        public async Task<IActionResult> GetUserById(int 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>
+        /// Checking user login
+        /// </summary>
+        /// <param name="token"></param>
+        /// <returns></returns>
+        [HttpGet("check-user-login")]
+        [ProducesResponseType(typeof(UserResponseDto), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        public async Task<IActionResult> CheckUserLogin()
+        {
+            _logger.LogInformation($"Start checking user login");
+            var stopwatch = Stopwatch.StartNew();
+
+            string? authorizationHeader = Request.Headers["Authorization"].FirstOrDefault();
+            if (string.IsNullOrEmpty(authorizationHeader) || !authorizationHeader.StartsWith("Bearer "))
+            {
+                return Unauthorized("Authorization header missing or invalid.");
+            }
+
+            string token = authorizationHeader.Replace("Bearer ", string.Empty);
+
+            string newToken = await _userService.CheckUserLogin(token);
+
+            stopwatch.Stop();
+            _logger.LogInformation($"Checking user login done in {stopwatch.ElapsedMilliseconds}");
+
+            return Ok(newToken);
+        }
+
+        /// <summary>
+        /// Update User
+        /// </summary>
+        /// <param name="userRequestDto"></param>
+        /// <returns></returns>
+        [HttpPut]
+        [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]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public async Task<IActionResult> DeleteUser([FromBody] List<int> 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/Blueprint.API/Controllers/UserControllerAsync.cs

@@ -0,0 +1,51 @@
+using Blueprint.Core.Interfaces.SPI;
+using Microsoft.AspNetCore.Mvc;
+using System.Text.Json;
+using Template.Core.Dtos.Requests;
+
+namespace Blueprint.API.Controllers
+{
+    [Route("rest/v1.0/users-async")]
+    [ApiController]
+    public class UserControllerAsync: Controller
+    {
+        private readonly IRabbitMqService _rabbitMqService;
+        private readonly ILogger<UserControllerAsync> _logger;
+
+        public UserControllerAsync(IRabbitMqService rabbitMqService, ILogger<UserControllerAsync> logger)
+        {
+            _rabbitMqService = rabbitMqService;
+            _logger = logger;
+        }
+
+        [HttpPost]
+        public IActionResult CreateUser([FromBody] UserRequestDto userRequestDto)
+        {
+            _logger.LogInformation($"Start queuing a user creation request.");
+
+            // Serialize the user data as a message
+            string message = JsonSerializer.Serialize(userRequestDto);
+
+            // Publish the message to RabbitMQ
+            _rabbitMqService.PublishMessage("user-creation-queue", message);
+
+            _logger.LogInformation($"User creation request queued successfully.");
+            return Accepted("User creation request is being processed.");
+        }
+
+        [HttpDelete]
+        public IActionResult DeleteUser([FromBody] List<int> userIds)
+        {
+            _logger.LogInformation($"Start queuing a user deletion request.");
+
+            // Serialize the user IDs as a message
+            string message = JsonSerializer.Serialize(userIds);
+
+            // Publish the message to RabbitMQ
+            _rabbitMqService.PublishMessage("user-deletion-queue", message);
+
+            _logger.LogInformation($"User deletion request queued successfully.");
+            return Accepted("User deletion request is being processed.");
+        }
+    }
+}

package/BlueprintTemplate/Blueprint.API/Controllers/VersionController.cs

@@ -0,0 +1,43 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using System.Diagnostics;
+
+namespace Blueprint.API.Controllers
+{
+    /// <summary>
+    /// Version controller
+    /// </summary>
+    [Route("rest/v1.0/version")]
+    [ApiVersion("1.0")]
+    [Produces("application/json")]
+    [ApiController]
+    public class VersionController : Controller
+    {
+        private ILogger _logger;
+
+        public VersionController(ILogger<VersionController> logger)
+        {
+            _logger = logger;
+        }
+
+        /// <summary>
+        /// Get version
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet]
+        [Authorize(Roles = "User")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public string GetVersion()
+        {
+            _logger.LogInformation($"Start getting version");
+            var stopwatch = Stopwatch.StartNew();
+
+            string version = "1";
+
+            stopwatch.Stop();
+            _logger.LogInformation($"Getting version done in {stopwatch.ElapsedMilliseconds}");
+
+            return version;
+        }
+    }
+}

package/BlueprintTemplate/Blueprint.API/Controllers/WeatherForecastController.cs

@@ -0,0 +1,33 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace Blueprint.API.Controllers
+{
+    [ApiController]
+    [Route("[controller]")]
+    public class WeatherForecastController : ControllerBase
+    {
+        private static readonly string[] Summaries = new[]
+        {
+            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
+        };
+
+        private readonly ILogger<WeatherForecastController> _logger;
+
+        public WeatherForecastController(ILogger<WeatherForecastController> logger)
+        {
+            _logger = logger;
+        }
+
+        [HttpGet(Name = "GetWeatherForecast")]
+        public IEnumerable<WeatherForecast> Get()
+        {
+            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
+            {
+                Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
+                TemperatureC = Random.Shared.Next(-20, 55),
+                Summary = Summaries[Random.Shared.Next(Summaries.Length)]
+            })
+            .ToArray();
+        }
+    }
+}

package/BlueprintTemplate/Blueprint.API/Mappers/DtoMappingProfile.cs

@@ -0,0 +1,28 @@
+using AutoMapper;
+using Blueprint.Core.Entities;
+using Blueprint.Core.Models;
+using Template.Core.Dtos.Requests;
+using Template.Core.Dtos.Responses;
+
+namespace Blueprint.API.Mappers
+{
+    /// <summary>
+    /// DtoMappingProfile
+    /// </summary>
+    public class DtoMappingProfile : Profile
+    {
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public DtoMappingProfile()
+        {
+            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/Blueprint.API/Program.cs

@@ -0,0 +1,176 @@
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.IdentityModel.Tokens;
+using Blueprint.Infra.Database;
+using Blueprint.API.Mappers;
+using Microsoft.AspNetCore.Mvc.Versioning;
+using Microsoft.AspNetCore.Mvc;
+using Amazon.S3;
+using Template.Core.Interfaces.API;
+using Template.Core.Services;
+using Template.Core.Interfaces.SPI;
+using Template.Infra.Services;
+using Blueprint.Core.Interfaces.API;
+using Blueprint.Core.Interfaces.SPI;
+using Blueprint.Infra.Services;
+using MongoDB.Driver;
+using Blueprint.Core.Services;
+using Blueprint.API.Services;
+using System.Text.Json.Serialization;
+using System.Text;
+
+var builder = WebApplication.CreateBuilder(args);
+
+ConfigureThirdPartyServices();
+ConfigureServices();
+ConfigureSwagger();
+ConfigureDatabase();
+
+var app = builder.Build();
+
+ConfigureMiddleware(app);
+ApplyMigrations(app);
+
+app.Run();
+
+void ConfigureMiddleware(WebApplication app)
+{
+    // Configure the HTTP request pipeline.
+    if (app.Environment.IsDevelopment())
+    {
+        app.UseSwagger();
+        app.UseSwaggerUI();
+    }
+    app.UseCors("AllowAll");
+    app.UseHttpsRedirection();
+    app.UseAuthentication();
+    app.UseAuthorization();
+    app.MapControllers();
+}
+
+void ConfigureSwagger()
+{
+    // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
+    builder.Services.AddEndpointsApiExplorer();
+    builder.Services.AddSwaggerGen();
+}
+
+void ConfigureServices()
+{
+    // Add services to the container.
+    builder.Services.AddCors(options =>
+    {
+        options.AddPolicy("AllowAll", policy =>
+        {
+            policy.AllowAnyOrigin() // Allow requests from any origin
+                  .AllowAnyHeader() // Allow any headers
+                  .AllowAnyMethod() // Allow any HTTP methods
+                  .WithExposedHeaders("X-WP-Total");
+        });
+    });
+    //Add Authen
+    builder.Services.AddAuthentication(options =>
+    {
+        options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
+        options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
+    })
+    .AddJwtBearer(options =>
+    {
+        options.RequireHttpsMetadata = false;
+        options.SaveToken = true;
+        options.TokenValidationParameters = new TokenValidationParameters
+        {
+            ValidateIssuerSigningKey = false,
+            ValidateIssuer = false,
+            ValidateAudience = false,
+            ValidateLifetime = false, // Ensure token expiration is checked
+            ClockSkew = TimeSpan.Zero, // Optional: Prevents automatic expiration buffer
+            RoleClaimType = "http://schemas.microsoft.com/ws/2008/06/identity/claims/role",
+            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Secret"]!))
+        };
+    });
+    builder.Services.AddAuthorization(options =>
+    {
+        options.AddPolicy("AdminPolicy", policy => policy.RequireRole("Admin"));
+        options.AddPolicy("UserPolicy", policy => policy.RequireRole("User"));
+    });
+
+    // Add services to the container.
+    builder.Services.AddControllers()
+            .AddJsonOptions(options =>
+            {
+                options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
+            });
+
+    // Register generic services
+    builder.Services.AddScoped(typeof(IItemService<>), typeof(ItemService<>));
+    builder.Services.AddScoped(typeof(IRepositoryFactory<>), typeof(RepositoryFactory<>));
+    builder.Services.AddScoped(typeof(IItemInfra<>), typeof(MySQLItemInfra<>));
+    builder.Services.AddScoped(typeof(IItemInfra<>), typeof(MongoItemInfra<>));
+
+    // Register other services
+    builder.Services.AddScoped<IUserInfra, MongoUserInfra>();
+    builder.Services.AddScoped<IUserInfra, MySQLUserInfra>();
+
+    builder.Services.AddScoped<IUserService, UserService>();
+    //Configure settings
+}
+
+void ConfigureDatabase()
+{
+    //Register for mySQL
+    string? mySQLConnectionString = builder.Configuration.GetConnectionString("MySQL");
+    if (!string.IsNullOrEmpty(mySQLConnectionString))
+    {
+        builder.Services.AddDbContext<MyDbContext>(options =>
+            options.UseMySql(mySQLConnectionString, Microsoft.EntityFrameworkCore.ServerVersion.AutoDetect(mySQLConnectionString))
+        );
+    };
+
+    //Register for Mongo
+    string? mongoConnectionString = builder.Configuration.GetConnectionString("MongoDb");
+    string? databaseName = builder.Configuration["Database:Name"];
+    if (!string.IsNullOrEmpty(mongoConnectionString) && !string.IsNullOrEmpty(databaseName))
+    {
+        builder.Services.AddSingleton<IMongoClient>(new MongoClient(mongoConnectionString));
+        builder.Services.AddScoped(sp =>
+        {
+            var client = sp.GetRequiredService<IMongoClient>();
+            return client.GetDatabase(databaseName);
+        });
+    }
+}
+
+void ApplyMigrations(WebApplication app)
+{
+    using (var scope = app.Services.CreateScope())
+    {
+        var dbContext = scope.ServiceProvider.GetRequiredService<MyDbContext>();
+        string? databaseType = builder.Configuration["Database:Type"];
+        if (!string.IsNullOrEmpty(databaseType) 
+            && databaseType.Equals("MySQL", StringComparison.OrdinalIgnoreCase))
+        {
+            // Apply migrations if the database type is MySQL
+            dbContext.Database.Migrate();
+        }
+    }
+}
+
+void ConfigureThirdPartyServices()
+{
+    builder.Services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
+    builder.Services.AddAutoMapper(typeof(DtoMappingProfile).Assembly);
+    builder.Services.AddApiVersioning(opt =>
+    {
+        opt.DefaultApiVersion = new ApiVersion(1, 0);
+        opt.AssumeDefaultVersionWhenUnspecified = true;
+        opt.ReportApiVersions = true;
+        opt.ApiVersionReader = ApiVersionReader.Combine(new UrlSegmentApiVersionReader());
+    });
+    builder.Services.AddAWSService<IAmazonS3>();
+
+    //Rabbit MQ
+    builder.Services.AddSingleton<IRabbitMqService, RabbitMqService>();
+    builder.Services.AddSingleton<RabbitMqConsumerService>();
+    builder.Services.AddHostedService(provider => provider.GetRequiredService<RabbitMqConsumerService>());
+}

package/BlueprintTemplate/Blueprint.API/Properties/launchSettings.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:21467",
+      "sslPort": 44391
+    }
+  },
+  "profiles": {
+    "http": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "applicationUrl": "http://localhost:5262",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "https": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "applicationUrl": "https://localhost:7280;http://localhost:5262",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}