netcore-blueprint 1.0.5 → 1.0.7

package/Blueprint.API/Blueprint.API.csproj

@@ -7,7 +7,22 @@
   </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/Blueprint.API/Blueprint.API.csproj.user

@@ -2,5 +2,7 @@
 <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/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/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/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/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/Blueprint.API/Program.cs

@@ -1,25 +1,176 @@
-var builder = WebApplication.CreateBuilder(args);
+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;
 
-// Add services to the container.
+var builder = WebApplication.CreateBuilder(args);
 
-builder.Services.AddControllers();
-// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
-builder.Services.AddEndpointsApiExplorer();
-builder.Services.AddSwaggerGen();
+ConfigureThirdPartyServices();
+ConfigureServices();
+ConfigureSwagger();
+ConfigureDatabase();
 
 var app = builder.Build();
 
-// Configure the HTTP request pipeline.
-if (app.Environment.IsDevelopment())
+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()
 {
-    app.UseSwagger();
-    app.UseSwaggerUI();
+    // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
+    builder.Services.AddEndpointsApiExplorer();
+    builder.Services.AddSwaggerGen();
 }
 
-app.UseHttpsRedirection();
+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());
+            });
 
-app.UseAuthorization();
+    // 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<>));
 
-app.MapControllers();
+    // Register other services
+    builder.Services.AddScoped<IUserInfra, MongoUserInfra>();
+    builder.Services.AddScoped<IUserInfra, MySQLUserInfra>();
 
-app.Run();
+    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/Blueprint.API/Services/RabbitMqConsumerService.cs

@@ -0,0 +1,154 @@
+using RabbitMQ.Client;
+using RabbitMQ.Client.Events;
+using System.Text;
+using System.Text.Json;
+using Template.Core.Dtos.Requests;
+
+namespace Blueprint.API.Services
+{
+    public class RabbitMqConsumerService : BackgroundService
+    {
+        private IConnection? _connection;
+        private IChannel? _channel;
+        private readonly Dictionary<string, Func<string, Task>> _queueHandlers;
+
+        public RabbitMqConsumerService()
+        {
+            // Initialize queue handlers
+            _queueHandlers = new Dictionary<string, Func<string, Task>>
+            {
+                { "user-creation-queue", HandleUserCreationAsync },
+                { "user-update-queue", HandleUserUpdateAsync },
+            };
+        }
+
+        private async Task InitializeRabbitMq(CancellationToken stoppingToken)
+        {
+            while (!stoppingToken.IsCancellationRequested)
+            { 
+                try
+                {
+                    var factory = new ConnectionFactory
+                    {
+                        HostName = "localhost",
+                        UserName = "truongdx8",
+                        Password = "12345678"
+                    };
+
+                    // Create a connection
+                    _connection = await factory.CreateConnectionAsync();
+
+                    // Create a channel (more modern than IModel)
+                    _channel = await _connection.CreateChannelAsync();
+
+                    // Declare all queues
+                    foreach (var queueName in _queueHandlers.Keys)
+                    {
+                        await _channel.QueueDeclareAsync(queue: queueName,
+                                  durable: true,
+                                  exclusive: false,
+                                  autoDelete: false,
+                                  arguments: null);
+                    }
+                    Console.WriteLine("RabbitMQ connected successfully.");
+                    return; // Exit the loop once connection is established
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine($"Error connecting to RabbitMQ: {ex.Message}");
+                    await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken);
+                }
+            }
+        }
+
+        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+        {
+            await InitializeRabbitMq(stoppingToken);
+
+            stoppingToken.Register(() => Console.WriteLine("RabbitMQ consumer is stopping."));
+
+            if (_connection != null && _connection.IsOpen)
+            {
+                // Start consumers for all queues
+                foreach (var queueName in _queueHandlers.Keys)
+                {
+                    Task.Run(() => StartConsumer(queueName, stoppingToken), stoppingToken);
+                }
+            }
+
+            // Keep the background service running
+            await Task.CompletedTask;
+        }
+
+        private async Task StartConsumer(string queueName, CancellationToken stoppingToken)
+        {
+            var consumer = new AsyncEventingBasicConsumer(_channel!);
+
+            consumer.ReceivedAsync += async (model, ea) =>
+            {
+                var body = ea.Body.ToArray();
+                var message = Encoding.UTF8.GetString(body);
+
+                try
+                {
+                    // Route the message to the appropriate handler
+                    if (_queueHandlers.TryGetValue(queueName, out var handler))
+                    {
+                        await handler(message);
+                    }
+                    else
+                    {
+                        Console.WriteLine($"No handler found for queue: {queueName}");
+                    }
+
+                    // Acknowledge the message
+                    await _channel!.BasicAckAsync(ea.DeliveryTag, false);
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine($"Error processing message: {ex.Message}");
+                    await _channel!.BasicNackAsync(ea.DeliveryTag, false, true); // Requeue the message
+                }
+            };
+
+            await _channel!.BasicConsumeAsync(queue: queueName, autoAck: false, consumer: consumer);
+
+            // Keep the task alive
+            while (!stoppingToken.IsCancellationRequested)
+            {
+                await Task.Delay(1000, stoppingToken);
+            }
+        }
+
+        private Task HandleUserCreationAsync(string message)
+        {
+            Console.WriteLine($"[User Creation] Processing message: {message}");
+            // Deserialize message and handle creation logic
+            var user = JsonSerializer.Deserialize<UserRequestDto>(message);
+            Console.WriteLine($"Creating user: {user?.Name}");
+            return Task.CompletedTask;
+        }
+
+        private Task HandleUserUpdateAsync(string message)
+        {
+            Console.WriteLine($"[User Update] Processing message: {message}");
+            // Deserialize message and handle update logic
+            var user = JsonSerializer.Deserialize<UserRequestDto>(message);
+            Console.WriteLine($"Updating user with ID {user?.Id}");
+            return Task.CompletedTask;
+        }
+
+        public override void Dispose()
+        {
+            if (_channel != null && _channel.IsOpen)
+            {
+                _channel.CloseAsync().GetAwaiter().GetResult();
+            }
+            if (_connection != null && _connection.IsOpen)
+            {
+                _connection.CloseAsync().GetAwaiter().GetResult();
+            }
+            base.Dispose();
+        }
+    }
+}