SW/SystemX.Web
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[성현모] UniqueKeyApi REST 완료

Browse Source
This commit is contained in:
SHM
2025-08-05 08:46:05 +09:00
parent d138088df9
commit afa4940880
15 changed files with 647 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

216
Projects/WebApi/WebApi.Project.UniqueKeyApi/Services/UniqueKeyService.cs Normal file
View File

@ -0,0 +1,216 @@
using Microsoft.AspNetCore.SignalR;
using Microsoft.EntityFrameworkCore;
using Microsoft.Identity.Client.Extensions.Msal;
using System.Data;
using SystemX.Core.DB;
using SystemX.Core.Services;
using WebApi.Library.Config;
using WebApi.Library.Enums;
using WebApi.Project.UniqueKeyApi.Models;
namespace WebApi.Project.UniqueKeyApi.Services
{
public class UniqueKeyService
{
private readonly IServiceScopeFactory _scopeFactory;
private readonly ConfigService<UniqueKeyApiConfig>? _configService;
public UniqueKeyService(IServiceProvider serviceProvider, IServiceScopeFactory scopeFactory, ConfigService<UniqueKeyApiConfig> configSerice)
{
_scopeFactory = scopeFactory;
_configService = configSerice;
}
public async Task<Response_InsertUniqueKy> Request_InsertUniqueKey(Request_InsertUniqueKey request, string guid = "")
{
Response_InsertUniqueKy response = new Response_InsertUniqueKy();
if (request != null)
{
response.Identity = request.Identity;
bool transactionResult = true;
using (var scope = _scopeFactory.CreateScope())
{
var provider = scope.ServiceProvider.GetRequiredService<DbContextProvider>();
using (var context = GetUniqueKeyDBContext(provider, 1))
{
if(context is not null)
{
var data = await context.tUniqueKeyStorages.AsNoTracking().Where(x => x.cIdentity== request.Identity).ToListAsync();
if (data?.Count() > 0)
{
LogXnet.WriteLine($"Exist Unique Key::{guid}", LogXLabel.Error);
response.Result = "Exist Unique Key";
}
else
{
var storage = new tUniqueKeyStorage
{
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 = WebApiResult.Failed.ToString();
LogXnet.WriteLine($"Transaction Error::{guid}", LogXLabel.Error);
}
else
{
LogXnet.WriteLine($"Transaction Success", LogXLabel.DB);
}
}
}
}
}
}
return response;
}
public async Task<Response_SelectUniqueKy> Request_SelectUniqueKey(Request_SelectUniqueKey request, string guid = "")
{
Response_SelectUniqueKy response = new Response_SelectUniqueKy();
if (request != null)
{
response.Identity = request.Identity;
using (var scope = _scopeFactory.CreateScope())
{
var provider = scope.ServiceProvider.GetRequiredService<DbContextProvider>();
using(var context = GetUniqueKeyDBContext(provider, 1))
{
if (context is not null)
{
try
{
using (var transaction = await context.CreateTransactionAsync(IsolationLevel.ReadUncommitted))
{
var data = await context.tUniqueKeyStorages.AsNoTracking().FirstOrDefaultAsync(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)
{
LogXnet.WriteLine($"Select Unique Key Transaction Error::{guid}", LogXLabel.Error);
LogXnet.WriteLine(e);
}
}
}
}
}
return response;
}
public async Task<List<tUniqueKeyStorage>> Request_SelectUniqueKeyAll(string guid = "")
{
List<tUniqueKeyStorage> result = new List<tUniqueKeyStorage>();
using (var scope = _scopeFactory.CreateScope())
{
var provider = scope.ServiceProvider.GetRequiredService<DbContextProvider>();
using(var context = GetUniqueKeyDBContext(provider, 1))
{
if (context is not null)
{
try
{
using (var transaction = await context.CreateTransactionAsync(IsolationLevel.ReadUncommitted))
{
result = await context.tUniqueKeyStorages.AsNoTracking().ToListAsync();
await context.CloseTransactionAsync(transaction);
}
}
catch (Exception e)
{
LogXnet.WriteLine($"Select Unique Key Transaction Error::{guid}", LogXLabel.Error);
LogXnet.WriteLine(e);
}
}
}
}
return result;
}
public async Task<Response_UpdateUniqueKy> Request_UpdateUniqueKey(Request_UpdateUniqueKey request, string guid = "")
{
Response_UpdateUniqueKy response = new Response_UpdateUniqueKy();
if (request != null)
{
response.Identity = request.Identity;
bool transactionResult = true;
using (var scope = _scopeFactory.CreateScope())
{
var provider = scope.ServiceProvider.GetRequiredService<DbContextProvider>();
using(var context = GetUniqueKeyDBContext(provider, 1))
{
if (context != null)
{
var selected = await context.tUniqueKeyStorages.FirstOrDefaultAsync(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 = WebApiResult.Failed.ToString();
LogXnet.WriteLine($"Transaction Error::{guid}", LogXLabel.Error);
}
else
{
LogXnet.WriteLine($"Transaction Success", LogXLabel.DB);
}
}
}
}
return response;
}
private UniqueKeyDBContext? GetUniqueKeyDBContext(DbContextProvider provider, int dbID)
{
var connectionString = _configService?.GetConfig()?.DataBase?.Find(x => x.DBID == dbID);
return provider?.GetDBContext<UniqueKeyDBContext>($"{connectionString?.DBName}");
}
}
}