SystemX.Web/Projects/HubX/HubX.Server/Services/UniqueKeyService.cs

using DB.HubXDB;
using HubX.Library.Enums;
using HubX.Library.Http.Packet;
using Microsoft.EntityFrameworkCore;
using Microsoft.Identity.Client.Extensions.Msal;
using System.Data;
using SystemX.Core.DB;

namespace HubX.Server.Services
{
    public class UniqueKeyService
    {
        private readonly EFCoreService _efCoreService;

        public UniqueKeyService(EFCoreService efCoreService)
        {
            _efCoreService = efCoreService;
        }

        public async Task<Response_InsertUniqueKy> Request_InsertUniqueKey(Request_InsertUniqueKey request)
        {
            Response_InsertUniqueKy response = new Response_InsertUniqueKy();

            if (request != null)
            {
                response.Identity = request.Identity;

                bool transactionResult = true;
                var context = _efCoreService.GetDBContext<HubXContext>();
                if (context != null)
                {
                    var data = context.TStorages.Where(x=>x.CIdentity == request.Identity);
                    if (data?.Count() > 0)
                    {
                        Log4net.WriteLine($"Exist Unique Key", LogType.Error);
                        response.Result = "Exist Unique Key";
                    }
                    else
                    {
                        var storage = new TStorage
                        {
                            CIdentity = request.Identity,
                            CData1 = request.Data1,
                            CData2 = request.Data2,
                            CData3 = request.Data3,
                            CData4 = request.Data4,
                            CData5 = request.Data5,

                            CDateTime = DateTime.Now
                        };

                        using (var transaction = await context.CreateTransactionAsync())
                        {
                            await context.AddAsync(storage);
                            transactionResult = await context.CloseTransactionAsync(transaction);
                        }

                        //db error
                        if (transactionResult == false)
                        {
                            response.Result = EnumResult.Failed.ToString();
                            Log4net.WriteLine($"Transaction Error", LogType.Error);
                        }
                        else
                        {
                            Log4net.WriteLine($"Transaction Success", LogType.DB);
                        }
                    }                             
                }
            }

            return response;
        }

        public async Task<Response_SelectUniqueKy> Request_SelectUniqueKey(Request_SelectUniqueKey request)
        {
            Response_SelectUniqueKy response = new Response_SelectUniqueKy();

            if (request != null)
            {
                response.Identity = request.Identity;

                var context = _efCoreService.GetDBContext<HubXContext>();
                if (context != null)
                {                
                    try
                    {
                        using (var transaction = await context.CreateTransactionAsync(IsolationLevel.ReadUncommitted))
                        {
                            var data = context.TStorages.AsNoTracking().First(x=>x.CIdentity == request.Identity);
                            await context.CloseTransactionAsync(transaction);
                            if(data != null)
                            {
                                response.Data1 = data.CData1;
                                response.Data2 = data.CData2;
                                response.Data3 = data.CData3;
                                response.Data4 = data.CData4;
                                response.Data5 = data.CData5;
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        Log4net.WriteLine($"Select Unique Key Transaction Error", LogType.Error);
                        Log4net.WriteLine(e);
                    }                   
                }
            }

            return response;
        }

        public async Task<Response_UpdateUniqueKy> Request_UpdateUniqueKey(Request_UpdateUniqueKey request)
        {
            Response_UpdateUniqueKy response = new Response_UpdateUniqueKy();

            if (request != null)
            {
                response.Identity = request.Identity;
                
                bool transactionResult = true;
                var context = _efCoreService.GetDBContext<HubXContext>();
                if (context != null)
                {
                    var selected = context.TStorages.First(x => x.CIdentity == request.Identity);
                    if (selected != null)
                    {
                        selected.CData1 = request.Data1;
                        selected.CData2 = request.Data2;
                        selected.CData3 = request.Data3;
                        selected.CData4 = request.Data4;
                        selected.CData5 = request.Data5;

                        using (var transaction = await context.CreateTransactionAsync())
                        {
                            context.Update(selected);
                            transactionResult = await context.CloseTransactionAsync(transaction);
                        }
                    }    
                }

                //db error
                if (transactionResult == false)
                {
                    response.Result = EnumResult.Failed.ToString();
                    Log4net.WriteLine($"Transaction Error", LogType.Error);
                }
                else
                {
                    Log4net.WriteLine($"Transaction Success", LogType.DB);
                }
            }

            return response;
        }
    }
}