bcjang/caliverse_server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

초기커밋

Browse Source
This commit is contained in:
bcjang
2025-05-01 07:20:41 +09:00
commit 98bb2e3c5c
2747 changed files with 646947 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
BrokerApiCore/Repository/PlanetInfoRepo.cs Normal file
View File

@@ -0,0 +1,50 @@
namespace BrokerCore.Repository;
using Context;
using DbEntity;
using Microsoft.EntityFrameworkCore;
using ServerBase;
using ServerCommon;
public class PlanetInfoRepo
{
private readonly MetaverseBrokerDbContext m_db;
public PlanetInfoRepo(MetaverseBrokerDbContext db)
{
m_db = db;
}
public async Task<(Result, PlanetInfo?)> findOne(string? id)
{
var result = new Result();
try
{
var value = await m_db.PlanetInfos.FirstAsync(x => x.PlanetId == id);
return (result, value);
}
catch (Exception ex)
{
result.setFail(ServerErrorCode.RdbError, ex.Message);
}
return (result, null);
}
public async Task<(Result, IEnumerable<PlanetInfo>?)> findAll()
{
var result = new Result();
try
{
var value = await m_db.PlanetInfos.ToListAsync();
return (result, value);
}
catch (Exception ex)
{
result.setFail(ServerErrorCode.RdbError, ex.Message);
}
return (result, null);
}
}

210
BrokerApiCore/Repository/PlanetItemExchangeOrderAmountTotalLimitRepo.cs Normal file
View File

@@ -0,0 +1,210 @@
using Microsoft.EntityFrameworkCore;
using ServerBase;
using ServerCommon;
namespace BrokerCore.Repository;
using DbEntity;
using Context;
public class PlanetItemExchangeOrderAmountTotalLimitRepo
{
private readonly MetaverseBrokerDbContext m_db_context;
public PlanetItemExchangeOrderAmountTotalLimitRepo(MetaverseBrokerDbContext dbContext)
{
m_db_context = dbContext;
}
// 총 교환 제한 추가
public async Task<Result> add(PlanetItemExchangeOrderAmountTotalLimit limit,
CancellationToken cancellationToken = default)
{
var result = new Result();
try
{
m_db_context.PlanetItemExchangeOrderAmountTotalLimits.Add(limit);
await m_db_context.SaveChangesAsync(cancellationToken);
}
catch (Exception e)
{
result.setFail(ServerErrorCode.RdbError, e.Message);
}
return result;
}
// 총 교환 제한 업데이트
public async Task<Result> update(PlanetItemExchangeOrderAmountTotalLimit limit,
CancellationToken cancellationToken = default)
{
var result = new Result();
try
{
m_db_context.PlanetItemExchangeOrderAmountTotalLimits.Update(limit);
await m_db_context.SaveChangesAsync(cancellationToken);
}
catch (Exception e)
{
result.setFail(ServerErrorCode.RdbError, e.Message);
}
return result;
}
public async Task<Result> increaseDailyAmount(
PlanetItemExchangeOrderAmountTotalLimit limit,
int increaseAmount,
CancellationToken cancellationToken = default)
{
var result = new Result();
try
{
limit.DailyAmount += increaseAmount;
// DailyAmount만 업데이트하기 위해 특정 열만 업데이트
var entity = m_db_context.Entry(limit);
entity.Property(x => x.DailyAmount).IsModified = true;
await m_db_context.SaveChangesAsync(cancellationToken);
}
catch (Exception e)
{
result.setFail(ServerErrorCode.RdbError, e.Message);
}
return result;
}
// 총 교환 제한 삭제
public async Task<Result> delete(PlanetItemExchangeOrderAmountTotalLimit limit,
CancellationToken cancellationToken = default)
{
var result = new Result();
try
{
m_db_context.PlanetItemExchangeOrderAmountTotalLimits.Remove(limit);
await m_db_context.SaveChangesAsync(cancellationToken);
}
catch (Exception e)
{
result.setFail(ServerErrorCode.RdbError, e.Message);
}
return result;
}
// 특정 교환 메타 아이디와 날짜에 대한 교환 제한 조회
public async Task<(Result, PlanetItemExchangeOrderAmountTotalLimit?)> findByExchangeMetaAndDateOrCreate(
string exchangeMetaId,
DateOnly exchangeDate,
string seasonId,
CancellationToken cancellationToken = default)
{
var result = new Result();
try
{
var limit = await m_db_context.PlanetItemExchangeOrderAmountTotalLimits
.Where(x =>
x.ExchangeMetaId == exchangeMetaId &&
x.ExchangeDate == exchangeDate &&
x.SeasonId == seasonId)
.FirstOrDefaultAsync(cancellationToken);
if (limit == null)
{
limit = new PlanetItemExchangeOrderAmountTotalLimit
{
ExchangeMetaId = exchangeMetaId,
ExchangeDate = exchangeDate,
SeasonId = seasonId,
DailyAmount = 0
};
await add(limit, cancellationToken);
}
return (result, limit);
}
catch (Exception e)
{
result.setFail(ServerErrorCode.RdbError, e.Message);
return (result, null);
}
}
public async Task<(Result, PlanetItemExchangeOrderAmountTotalLimit?)> findByExchangeMetaAndDate(
string exchangeMetaId,
DateOnly exchangeDate,
string seasonId,
CancellationToken cancellationToken = default)
{
var result = new Result();
try
{
var limit = await m_db_context.PlanetItemExchangeOrderAmountTotalLimits
.Where(x =>
x.ExchangeMetaId == exchangeMetaId &&
x.ExchangeDate == exchangeDate &&
x.SeasonId == seasonId)
.FirstOrDefaultAsync(cancellationToken);
return (result, limit);
}
catch (Exception e)
{
result.setFail(ServerErrorCode.RdbError, e.Message);
return (result, null);
}
}
// // 특정 교환 메타 아이디에 대한 모든 교환 제한 조회
// public async Task<(Result, IEnumerable<PlanetItemExchangeOrderAmountTotalLimit>?)> findByExchangeMeta(
// string exchangeMetaId,
// int pageIndex = 1,
// int pageSize = 20,
// CancellationToken cancellationToken = default)
// {
// var result = new Result();
// try
// {
// var limits = await m_db_context.PlanetItemExchangeOrderAmountTotalLimits
// .Where(x => x.ExchangeMetaId == exchangeMetaId)
// .OrderBy(x => x.ExchangeDate)
// .Skip((pageIndex - 1) * pageSize)
// .Take(pageSize)
// .ToArrayAsync(cancellationToken);
//
// return (result, limits);
// }
// catch (Exception e)
// {
// result.setFail(ServerErrorCode.RdbError, e.Message);
// return (result, null);
// }
// }
//
// // 특정 날짜에 대한 모든 교환 제한 조회
// public async Task<(Result, IEnumerable<PlanetItemExchangeOrderAmountTotalLimit>?)> findByDate(
// DateOnly exchangeDate,
// int pageIndex = 1,
// int pageSize = 20,
// CancellationToken cancellationToken = default)
// {
// var result = new Result();
// try
// {
// var limits = await m_db_context.PlanetItemExchangeOrderAmountTotalLimits
// .Where(x => x.ExchangeDate == exchangeDate)
// .OrderBy(x => x.ExchangeMetaId)
// .Skip((pageIndex - 1) * pageSize)
// .Take(pageSize)
// .ToArrayAsync(cancellationToken);
//
// return (result, limits);
// }
// catch (Exception e)
// {
// result.setFail(ServerErrorCode.RdbError, e.Message);
// return (result, null);
// }
// }
}

227
BrokerApiCore/Repository/PlanetItemExchangeOrderAmountUserLimitRepo.cs Normal file
View File

@@ -0,0 +1,227 @@
using Microsoft.EntityFrameworkCore;
using ServerBase;
using ServerCommon;
namespace BrokerCore.Repository;
using DbEntity;
using Context;
public class PlanetItemExchangeOrderAmountUserLimitRepo
{
private readonly MetaverseBrokerDbContext m_db_context;
public PlanetItemExchangeOrderAmountUserLimitRepo(MetaverseBrokerDbContext dbContext)
{
m_db_context = dbContext;
}
// 사용자별 교환 제한 추가
public async Task<Result> add(PlanetItemExchangeOrderAmountUserLimit limit,
CancellationToken cancellationToken = default)
{
var result = new Result();
try
{
m_db_context.PlanetItemExchangeOrderAmountUserLimits.Add(limit);
await m_db_context.SaveChangesAsync(cancellationToken);
}
catch (Exception e)
{
result.setFail(ServerErrorCode.InternalServerError, e.Message);
}
return result;
}
// 사용자별 교환 제한 업데이트
public async Task<Result> update(PlanetItemExchangeOrderAmountUserLimit limit,
CancellationToken cancellationToken = default)
{
var result = new Result();
try
{
m_db_context.PlanetItemExchangeOrderAmountUserLimits.Update(limit);
await m_db_context.SaveChangesAsync(cancellationToken);
}
catch (Exception e)
{
result.setFail(ServerErrorCode.InternalServerError, e.Message);
}
return result;
}
// 사용자별 교환 제한 삭제
public async Task<Result> delete(PlanetItemExchangeOrderAmountUserLimit limit,
CancellationToken cancellationToken = default)
{
var result = new Result();
try
{
m_db_context.PlanetItemExchangeOrderAmountUserLimits.Remove(limit);
await m_db_context.SaveChangesAsync(cancellationToken);
}
catch (Exception e)
{
result.setFail(ServerErrorCode.InternalServerError, e.Message);
}
return result;
}
// 특정 사용자와 날짜에 대한 교환 제한 조회
public async Task<(Result, PlanetItemExchangeOrderAmountUserLimit?)> findByUserAndDate(
string exchangeMetaId,
string userGuid,
DateOnly exchangeDate,
string seasonId,
CancellationToken cancellationToken = default)
{
var result = new Result();
try
{
var limit = await m_db_context.PlanetItemExchangeOrderAmountUserLimits
.Where(x =>
x.ExchangeMetaId == exchangeMetaId &&
x.ExchangeDate == exchangeDate &&
x.SeasonId == seasonId &&
x.UserGuid == userGuid)
.FirstOrDefaultAsync(cancellationToken);
return (result, limit);
}
catch (Exception e)
{
result.setFail(ServerErrorCode.RdbError, e.Message);
return (result, null);
}
}
// // 특정 교환 메타 아이디에 대한 모든 교환 제한 조회
// public async Task<(Result, IEnumerable<PlanetItemExchangeOrderAmountUserLimit>?)> findByExchangeMeta(
// string exchangeMetaId,
// int pageIndex = 1,
// int pageSize = 20,
// CancellationToken cancellationToken = default)
// {
// var result = new Result();
// try
// {
// var limits = await m_db_context.PlanetItemExchangeOrderAmountUserLimits
// .Where(x => x.ExchangeMetaId == exchangeMetaId)
// .OrderBy(x => x.ExchangeDate)
// .Skip((pageIndex - 1) * pageSize)
// .Take(pageSize)
// .ToArrayAsync(cancellationToken);
//
// return (result, limits);
// }
// catch (Exception e)
// {
// result.setFail(ServerErrorCode.RdbError, e.Message);
// return (result, null);
// }
// }
//
// // 특정 날짜에 대한 모든 교환 제한 조회
// public async Task<(Result, IEnumerable<PlanetItemExchangeOrderAmountUserLimit>?)> findByDate(
// DateOnly exchangeDate,
// int pageIndex = 1,
// int pageSize = 20,
// CancellationToken cancellationToken = default)
// {
// var result = new Result();
// try
// {
// var limits = await m_db_context.PlanetItemExchangeOrderAmountUserLimits
// .Where(x => x.ExchangeDate == exchangeDate)
// .OrderBy(x => x.ExchangeMetaId)
// .Skip((pageIndex - 1) * pageSize)
// .Take(pageSize)
// .ToArrayAsync(cancellationToken);
//
// return (result, limits);
// }
// catch (Exception e)
// {
// result.setFail(ServerErrorCode.RdbError, e.Message);
// return (result, null);
// }
// }
//
// // 특정 사용자의 모든 교환 제한 조회
// public async Task<(Result, IEnumerable<PlanetItemExchangeOrderAmountUserLimit>?)> findByUser(
// string userGuid,
// int pageIndex = 1,
// int pageSize = 20,
// CancellationToken cancellationToken = default)
// {
// var result = new Result();
// try
// {
// var limits = await m_db_context.PlanetItemExchangeOrderAmountUserLimits
// .Where(x => x.UserGuid == userGuid)
// .OrderBy(x => x.ExchangeDate)
// .ThenBy(x => x.ExchangeMetaId)
// .Skip((pageIndex - 1) * pageSize)
// .Take(pageSize)
// .ToArrayAsync(cancellationToken);
//
// return (result, limits);
// }
// catch (Exception e)
// {
// result.setFail(ServerErrorCode.RdbError, e.Message);
// return (result, null);
// }
// }
public async Task increaseDailyAmount(PlanetItemExchangeOrderAmountUserLimit userLimit, int increaseAmount,
CancellationToken cancellationToken)
{
userLimit.DailyAmount += increaseAmount;
var entry = m_db_context.Entry(userLimit);
entry.Property(x => x.DailyAmount).IsModified = true;
await update(userLimit, cancellationToken);
}
public async Task<(Result, PlanetItemExchangeOrderAmountUserLimit?)> findByExchangeMetaAndDateOrCreate(
string orderExchangeMetaId, string orderUserGuid, DateOnly exchangeDate, string orderSeasonId,
CancellationToken cancellationToken)
{
var result = new Result();
try
{
var limit = await m_db_context.PlanetItemExchangeOrderAmountUserLimits
.Where(x =>
x.ExchangeMetaId == orderExchangeMetaId &&
x.ExchangeDate == exchangeDate &&
x.SeasonId == orderSeasonId &&
x.UserGuid == orderUserGuid)
.FirstOrDefaultAsync(cancellationToken);
if (limit is null)
{
limit = new PlanetItemExchangeOrderAmountUserLimit
{
ExchangeMetaId = orderExchangeMetaId,
UserGuid = orderUserGuid,
ExchangeDate = exchangeDate,
SeasonId = orderSeasonId,
DailyAmount = 0,
};
await add(limit, cancellationToken);
}
return (result, limit);
}
catch (Exception e)
{
result.setFail(ServerErrorCode.RdbError, e.Message);
return (result, null);
}
}
}

296
BrokerApiCore/Repository/PlanetItemExchangeOrderRepo.cs Normal file
View File

@@ -0,0 +1,296 @@
using Microsoft.EntityFrameworkCore;
using ServerBase;
using ServerCommon;
namespace BrokerCore.Repository;
using Common;
using DbEntity;
using Context;
public class PlanetItemExchangeOrderRepo
{
private readonly MetaverseBrokerDbContext m_db_context;
public PlanetItemExchangeOrderRepo(MetaverseBrokerDbContext dbContext)
{
m_db_context = dbContext;
}
//================================================================================
// 교환 주문을 추가한다.
// 트랜잭션을 사용한다.
//================================================================================
public async Task<Result> add(PlanetItemExchangeOrder order, CancellationToken cancellationToken = default)
{
try
{
m_db_context.PlanetItemExchangeOrders.Add(order);
await m_db_context.SaveChangesAsync(cancellationToken);
}
catch (Exception e)
{
return new Result { ErrorCode = ServerErrorCode.RdbError, ResultString = e.Message };
}
return new Result();
}
// public async Task<Result> add(PlanetItemExchangeOrder order,
// CancellationToken cancellationToken = default)
// {
// var result = new Result();
//
// // 실행 전략 생성
// var strategy = m_db_context.Database.CreateExecutionStrategy();
//
// // 실행 전략을 사용하여 트랜잭션 작업을 실행
// await strategy.ExecuteAsync(async () =>
// {
// // 트랜잭션 시작
// await using var transaction = await m_db_context.Database.BeginTransactionAsync(cancellationToken);
// try
// {
// var order_date_utc = order.CreatedAt.ToUniversalTime().Date; // UTC 기준 주문일의 자정(00:00:00)
//
// // 단일 쿼리로 total_exchange_count와 user_exchange_count를 함께 조회
// var exchange_counts = await m_db_context.PlanetItemExchangeOrders
// .Where(x => x.PlanetId == order.PlanetId &&
// x.ExchangeMetaId == order.ExchangeMetaId &&
// x.CreatedAt >= order_date_utc && x.CreatedAt < order_date_utc.AddDays(1))
// .GroupBy(x => 1)
// .Select(g => new
// {
// TotalCount = g.Sum(x => x.ExchangeMetaAmount),
// UserCount = g.Where(x => x.UserGuid == order.UserGuid).Sum(x => x.ExchangeMetaAmount)
// })
// .FirstOrDefaultAsync(cancellationToken);
//
// var total_exchange_count = exchange_counts?.TotalCount ?? 0;
// var user_exchange_count = exchange_counts?.UserCount ?? 0;
//
// if (total_exchange_count + order.ExchangeMetaAmount > dailyLimit)
// {
// result.setFail(ServerErrorCode.ExchangeTotalOrderDailyLimitExceeded,
// $"일일 총 구매 제한 초과 => {order.ExchangeMetaId} Total exchange count {total_exchange_count} + order amount {order.ExchangeMetaAmount} > daily total limit {dailyLimit}");
// return;
// }
//
// if (user_exchange_count + order.ExchangeMetaAmount > dailyUserLimit)
// {
// result.setFail(ServerErrorCode.ExchangeUserOrderDailyLimitExceeded,
// $"일일 개인 구매 제한 초과 => {order.ExchangeMetaId} User exchange count {user_exchange_count} + order amount {order.ExchangeMetaAmount} > daily user limit {dailyUserLimit}");
// return;
// }
//
// m_db_context.PlanetItemExchangeOrders.Add(order);
// m_
//
// await m_db_context.SaveChangesAsync(cancellationToken);
// await transaction.CommitAsync(cancellationToken);
// }
// catch (Exception e)
// {
// result.setFail(ServerErrorCode.InternalServerError, e.Message);
// }
// });
//
// return result;
// }
public async Task<Result> delete(PlanetItemExchangeOrder order, CancellationToken cancellationToken = default)
{
var result = new Result();
try
{
m_db_context.PlanetItemExchangeOrders.Remove(order);
await m_db_context.SaveChangesAsync(cancellationToken);
}
catch (Exception e)
{
result.setFail(ServerErrorCode.InternalServerError, e.Message);
}
return result;
}
//================================================================================
// 교환 주문을 비동기로 업데이트한다.
// OrderId를 키로 사용한다.
// OrderType과 OrderCompletedAt만 업데이트한다.
//================================================================================
public async Task<(Result, PlanetItemExchangeOrder?)> findAndUpdateStatus(string orderId,
ExchangeOrderStatus orderStatus,
CancellationToken cancellationToken = default)
{
var result = new Result();
try
{
var order = await m_db_context.PlanetItemExchangeOrders.Where(x => x.OrderId == orderId)
.FirstOrDefaultAsync(cancellationToken);
if (order == null)
{
result.setFail(ServerErrorCode.ExchangeOrderIdNotFound, $"Order not found: {orderId}");
return (result, null);
}
order.OrderStatus = orderStatus;
order.CompletedAt = DateTime.UtcNow;
m_db_context.PlanetItemExchangeOrders.Attach(order);
m_db_context.Entry(order).Property(x => x.OrderStatus).IsModified = true;
m_db_context.Entry(order).Property(x => x.CompletedAt).IsModified = true;
await m_db_context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
return (new Result(), order);
}
catch (Exception e)
{
// await transaction.RollbackAsync(cancellationToken).ConfigureAwait(false);
return (new Result { ResultString = e.Message }, null);
}
}
public async Task<(Result, PlanetItemExchangeOrder?)> findOne(string orderId,
ExchangeOrderStatus orderStatus,
CancellationToken cancellationToken = default)
{
try
{
var order = await m_db_context.PlanetItemExchangeOrders
.Where(x => x.OrderId == orderId && x.OrderStatus == orderStatus)
.FirstOrDefaultAsync(cancellationToken);
return (new Result(), order);
}
catch (Exception e)
{
return (new Result { ErrorCode = ServerErrorCode.RdbError, ResultString = e.Message }, null);
}
}
// public async Task<Result> updateForPending(SapphireExchangeOrder order,
// CancellationToken cancellationToken = default)
// {
// // await using var transaction = await m_db_context.Database.BeginTransactionAsync(cancellationToken);
// try
// {
// m_db_context.SapphireExchangeOrders.Attach(order);
// m_db_context.Entry(order).Property(x => x.OrderStatus).IsModified = true;
// await m_db_context.SaveChangesAsync(cancellationToken);
// // await transaction.CommitAsync(cancellationToken);
// return new Result();
// }
// catch (Exception e)
// {
// // await transaction.RollbackAsync(cancellationToken);
// return new Result { ResultString = e.Message };
// }
// }
//==========================================================================
//SELECT *
// FROM `sapphire_exchange_order`
// WHERE `PlanetId` = @planetId
// AND `UserGuid` = @userGuid
// AND (@orderStatus IS NULL OR `OrderStatus` = @orderStatus)
// ORDER BY `CreatedAt` ASC
// LIMIT @pageSize OFFSET @offset;
//==========================================================================
public async Task<(Result, IEnumerable<PlanetItemExchangeOrder>?, int)> findList(
string planetId,
string metaId,
string seasonId,
string userGuid,
ExchangeOrderStatus? orderStatus = null,
int pageIndex = 1,
int pageSize = 20,
string sortOrder = "asc",
CancellationToken cancellationToken = default)
{
var result = new Result();
try
{
var query = m_db_context.PlanetItemExchangeOrders.AsQueryable();
if (!string.IsNullOrEmpty(planetId))
{
query = query.Where(x => x.PlanetId == planetId);
}
if (!string.IsNullOrEmpty(metaId))
{
query = query.Where(x => x.ExchangeMetaId == metaId);
}
if (!string.IsNullOrEmpty(seasonId))
{
query = query.Where(x => x.SeasonId == seasonId);
}
if (!string.IsNullOrEmpty(userGuid))
{
query = query.Where(x => x.UserGuid == userGuid);
}
if (orderStatus.HasValue)
{
query = query.Where(x => x.OrderStatus == orderStatus);
}
query = sortOrder.ToLower() == "desc"
? query.OrderByDescending(o => o.CreatedAt)
: query.OrderBy(o => o.CreatedAt);
var orders = await query
.Skip((pageIndex - 1) * pageSize)
.Take(pageSize)
.ToArrayAsync(cancellationToken);
var total_count = await query.CountAsync(cancellationToken);
return (result, orders, total_count);
}
catch (Exception e)
{
result.setFail(ServerErrorCode.RdbError, e.Message);
return (result, null, 0);
}
}
//================================================================================
// 사파이어 교환 주문 목록을 비동기로 조회한다.
// OrderType과 PlanetId로 검색한다.
// Result, IEnumerable<>를 반환한다.
// 조건에 맞는 값이 없다면 빈 배열을 반환한다.
//================================================================================
public async Task<PaginatedList<PlanetItemExchangeOrder>> findPlanetItemExchangeOrders(int pageIndex, int pageSize)
{
var query = m_db_context.Set<PlanetItemExchangeOrder>().AsNoTracking();
var count = await query.CountAsync();
var items = await query
.OrderBy(o => o.CreatedAt)
.Skip((pageIndex - 1) * pageSize)
.Take(pageSize)
.ToListAsync();
return new PaginatedList<PlanetItemExchangeOrder>(items, count, pageIndex, pageSize);
}
public class PaginatedList<T> : List<T>
{
public int PageIndex { get; private set; }
public int TotalPages { get; private set; }
public int TotalCount { get; private set; }
public PaginatedList(List<T> items, int count, int pageIndex, int pageSize)
{
PageIndex = pageIndex;
TotalCount = count;
this.AddRange(items);
}
public bool HasPreviousPage => PageIndex > 1;
public bool HasNextPage => PageIndex < TotalPages;
}
}

240
BrokerApiCore/Repository/SapphireExchangeOrderRepo.cs Normal file
View File

@@ -0,0 +1,240 @@
// using Microsoft.EntityFrameworkCore;
//
// using ServerCommon;
//
// namespace BrokerCore.Repository;
//
// using Common;
//
// using DbEntity;
// using Context;
//
// public class SapphireExchangeOrderRepo
// {
// private readonly MetaverseBrokerDbContext m_db_context;
//
// public SapphireExchangeOrderRepo(MetaverseBrokerDbContext dbContext)
// {
// m_db_context = dbContext;
// }
//
// //================================================================================
// // 사파이어 교환 주문을 추가한다.
// // 트랜잭션을 사용한다.
// //================================================================================
// public async Task<Result> add(SapphireExchangeOrder order, CancellationToken cancellationToken = default)
// {
// var result = new Result();
// try
// {
// m_db_context.SapphireExchangeOrders.Add(order);
// await m_db_context.SaveChangesAsync(cancellationToken);
// return result;
// }
// catch (Exception e)
// {
// result.setFail(ServerErrorCode.InternalServerError, e.Message);
// }
//
// return result;
// }
//
// public async Task<Result> delete(SapphireExchangeOrder order, CancellationToken cancellationToken = default)
// {
// var result = new Result();
// try
// {
// m_db_context.SapphireExchangeOrders.Remove(order);
// await m_db_context.SaveChangesAsync(cancellationToken);
// }
// catch (Exception e)
// {
// result.setFail(ServerErrorCode.InternalServerError, e.Message);
// }
//
// return result;
// }
//
// //================================================================================
// // 사파이어 교환 주문을 비동기로 업데이트한다.
// // 트랜잭션을 사용한다.
// // OrderId를 키로 사용한다.
// // OrderType과 OrderCompletedAt만 업데이트한다.
// //================================================================================
// public async Task<(Result, SapphireExchangeOrder?)> findAndComplete(string orderId,
// CancellationToken cancellationToken = default)
// {
// var result = new Result();
// // var transaction = await m_db_context.Database.BeginTransactionAsync(cancellationToken).ConfigureAwait(false);
// // await using var transaction1 = transaction.ConfigureAwait(false);
// try
// {
// var order = await m_db_context.SapphireExchangeOrders.Where(x => x.OrderId == orderId).FirstOrDefaultAsync(cancellationToken);
// Guard.Against.isNull(order, ServerErrorCode.ExchangeOrderIdNotFound, "Invalid orderId");
// if (order.OrderStatus != ExchangeOrderStatus.Pending)
// {
// result.setFail(ServerErrorCode.Success, $"Fail To Complete OrderStatus Not Pending: orderId {orderId}, order_status {order.OrderStatus}");
// return (result, order);
// }
//
// order.OrderStatus = ExchangeOrderStatus.Completed;
// order.CompletedAt = DateTime.Now;
// m_db_context.SapphireExchangeOrders.Attach(order);
// m_db_context.Entry(order).Property(x => x.OrderStatus).IsModified = true;
// m_db_context.Entry(order).Property(x => x.CompletedAt).IsModified = true;
// await m_db_context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
// // await transaction.CommitAsync(cancellationToken).ConfigureAwait(false);
// return (new Result(), order);
// }
// catch (Exception e)
// {
// // await transaction.RollbackAsync(cancellationToken).ConfigureAwait(false);
// return (new Result { ResultString = e.Message }, null);
// }
// }
//
// // public async Task<Result> updateForPending(SapphireExchangeOrder order,
// // CancellationToken cancellationToken = default)
// // {
// // // await using var transaction = await m_db_context.Database.BeginTransactionAsync(cancellationToken);
// // try
// // {
// // m_db_context.SapphireExchangeOrders.Attach(order);
// // m_db_context.Entry(order).Property(x => x.OrderStatus).IsModified = true;
// // await m_db_context.SaveChangesAsync(cancellationToken);
// // // await transaction.CommitAsync(cancellationToken);
// // return new Result();
// // }
// // catch (Exception e)
// // {
// // // await transaction.RollbackAsync(cancellationToken);
// // return new Result { ResultString = e.Message };
// // }
// // }
// //==========================================================================
// //SELECT *
// // FROM `sapphire_exchange_order`
// // WHERE `PlanetId` = @planetId
// // AND `UserGuid` = @userGuid
// // AND (@orderStatus IS NULL OR `OrderStatus` = @orderStatus)
// // ORDER BY `CreatedAt` ASC
// // LIMIT @pageSize OFFSET @offset;
// //==========================================================================
// public async Task<(Result, IEnumerable<SapphireExchangeOrder>?)> findList(
// string planetId,
// string userGuid,
// ExchangeOrderStatus? orderStatus = null,
// int pageIndex = 1,
// int pageSize = 20,
// string sortOrder = "asc",
// CancellationToken cancellationToken = default)
// {
// var result = new Result();
// try
// {
// var query = m_db_context.SapphireExchangeOrders.AsQueryable();
//
// if (!string.IsNullOrEmpty(planetId))
// {
// query = query.Where(x => x.PlanetId == planetId);
// }
//
// if (!string.IsNullOrEmpty(userGuid))
// {
// query = query.Where(x => x.UserGuid == userGuid);
// }
//
// //orderStatus.HasValue는 orderStatus가 null일 때도 에러가 발생하지 않음. orderStatus가 null이면 HasValue는 false를 반환.
// if (orderStatus.HasValue)
// {
// query = query.Where(x => x.OrderStatus == orderStatus);
// }
//
// query = sortOrder.ToLower() == "desc"
// ? query.OrderByDescending(o => o.CreatedAt)
// : query.OrderBy(o => o.CreatedAt);
//
// var orders = await query
// .Skip((pageIndex - 1) * pageSize)
// .Take(pageSize)
// .ToArrayAsync(cancellationToken);
//
// return (result, orders);
// }
// catch (Exception e)
// {
// result.setFail(ServerErrorCode.DynamoDbException, e.Message);
// return (result, null);
// }
// }
//
// //================================================================================
// // 사파이어 교환 주문 목록을 비동기로 조회한다.
// // OrderType과 PlanetId로 검색한다.
// // Result, IEnumerable<>를 반환한다.
// // 조건에 맞는 값이 없다면 빈 배열을 반환한다.
// //================================================================================
// public async Task<(Result, IEnumerable<SapphireExchangeOrder>?)> findList_old(string planetId, string userGuid,
// ExchangeOrderStatus? orderStatus = null, int pageIndex = 1, int pageSize = 20, CancellationToken cancellationToken = default)
// {
// var result = new Result();
// try
// {
// if (orderStatus == null)
// {
// var orders = await m_db_context.SapphireExchangeOrders
// .OrderBy(o => o.CreatedAt)
// .Skip((pageIndex - 1) * pageSize)
// .Take(pageSize)
// .Where(x => x.PlanetId == planetId && x.UserGuid == userGuid).ToArrayAsync(cancellationToken);
// return (result, orders);
// }
// else
// {
// var orders = await m_db_context.SapphireExchangeOrders
// .Where(x => x.PlanetId == planetId && x.UserGuid == userGuid && x.OrderStatus == orderStatus)
// .Skip((pageIndex - 1) * pageSize)
// .Take(pageSize)
// .ToArrayAsync(cancellationToken);
// return (result, orders);
// }
// }
// catch (Exception e)
// {
// result.setFail(ServerErrorCode.RdbError, e.Message);
// return (result, null);
// }
// }
//
// public async Task<PaginatedList<SapphireExchangeOrder>> getSapphireExchangeOrders(int pageIndex, int pageSize)
// {
// var query = m_db_context.Set<SapphireExchangeOrder>().AsNoTracking();
//
// var count = await query.CountAsync();
// var items = await query
// .OrderBy(o => o.CreatedAt)
// .Skip((pageIndex - 1) * pageSize)
// .Take(pageSize)
// .ToListAsync();
//
// return new PaginatedList<SapphireExchangeOrder>(items, count, pageIndex, pageSize);
// }
//
// public class PaginatedList<T> : List<T>
// {
// public int PageIndex { get; private set; }
// public int TotalPages { get; private set; }
// public int TotalCount { get; private set; }
//
// public PaginatedList(List<T> items, int count, int pageIndex, int pageSize)
// {
// PageIndex = pageIndex;
// TotalCount = count;
//
// this.AddRange(items);
// }
//
// public bool HasPreviousPage => PageIndex > 1;
// public bool HasNextPage => PageIndex < TotalPages;
// }
// }

163
BrokerApiCore/Repository/SqlConfig/PlanetExchangeOrderConfig.cs Normal file
View File

@@ -0,0 +1,163 @@
namespace BrokerCore.DbEntity;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;
public class PlanetExchangeOrderConfig : IEntityTypeConfiguration<PlanetItemExchangeOrder>
{
public void Configure(EntityTypeBuilder<PlanetItemExchangeOrder> builder)
{
builder.ToTable("planet_item_exchange_order");
builder.HasIndex(o => o.CreatedAt);
builder.HasIndex(o => o.OrderStatus);
builder.HasIndex(o => o.PlanetId);
builder.HasIndex(o => o.SeasonId);
builder.HasIndex(o => o.AccountId);
builder.HasIndex(o => o.UserGuid);
// 기본 키 (Primary Key)
builder.HasKey(o => o.OrderId);
builder.Property(o => o.OrderId)
.HasColumnOrder(1)
.HasColumnName("order_id")
.HasMaxLength(50)
.IsRequired()
.HasComment("교환 주문 아이디 (GUID)");
// 주문 상태 (Enum)
builder.Property(o => o.OrderStatus)
.HasColumnOrder(2)
.HasColumnName("order_status")
.IsRequired()
.HasConversion<string>()
.HasMaxLength(50)
.HasComment("교환 주문 상태");
// 플래닛 ID (string)
builder.Property(o => o.PlanetId)
.HasColumnOrder(3)
.HasColumnName("planet_id")
.HasMaxLength(50)
.IsRequired()
.HasComment("플래닛 아이디");
// PlanetInfo와의 외래 키 관계 설정
builder.HasOne<PlanetInfo>()
.WithMany()
.HasForeignKey(o => o.PlanetId)
.OnDelete(DeleteBehavior.Restrict) // 삭제 동작 정책을 Restrict로 설정
.HasConstraintName("FK_PlanetExchangeOrder_PlanetInfo");
builder.Property(o => o.SeasonId)
.HasColumnOrder(4)
.HasColumnName("season_id")
.HasMaxLength(50)
.IsRequired()
.HasComment("시즌 아이디");
builder.Property(o => o.ExchangeMetaId)
.HasColumnOrder(5)
.HasColumnName("exchange_meta_id")
.HasMaxLength(50)
.IsRequired()
.HasComment("교환 메타 아이디");
builder.Property(o => o.ExchangeMetaAmount)
.HasColumnOrder(6)
.HasColumnName("exchange_meta_amount")
.HasColumnType("INT")
.IsRequired()
.HasComment("교환 메타 수량");
// 계정 ID (ulong)
builder.Property(o => o.AccountId)
.HasColumnOrder(7)
.HasColumnName("account_id")
.HasMaxLength(50)
.IsRequired()
.HasComment("SSO 아이디");
// 사용자 GUID (string)
builder.Property(o => o.UserGuid)
.HasColumnOrder(8)
.HasColumnName("user_guid")
.HasMaxLength(50)
.IsRequired()
.HasComment("유저 아이디 (GUID)");
// 사용자 닉네임 (string)
builder.Property(o => o.Nickname)
.HasColumnOrder(9)
.HasColumnName("nickname")
.HasMaxLength(50)
.IsRequired()
.HasComment("유저 닉네임");
// 칼리버스 아이템 타입 (Enum)
builder.Property(o => o.CaliverseItemType)
.HasColumnOrder(10)
.HasColumnName("caliverse_item_type")
.IsRequired()
.HasConversion<string>()
.HasMaxLength(50)
.HasComment("칼리버스 아이템 타입");
// 칼리버스 아이템 ID (string)
builder.Property(o => o.CaliverseItemId)
.HasColumnOrder(11)
.HasColumnName("caliverse_item_id")
.HasMaxLength(50)
.IsRequired()
.HasComment("칼리버스 아이템 아이디");
// 칼리버스 아이템 수량 (long)
builder.Property(o => o.CaliverseItemDeltaAmount)
.HasColumnOrder(12)
.HasColumnName("caliverse_item_quantity")
.HasColumnType("INT")
.IsRequired()
.HasComment("칼리버스 아이템 갯수");
// 플래닛 아이템 타입 (Enum)
builder.Property(o => o.PlanetItemType)
.HasColumnOrder(13)
.HasColumnName("planet_item_type")
.IsRequired()
.HasConversion<string>()
.HasMaxLength(50)
.HasComment("플래닛 아이템 타입");
// 플래닛 아이템 ID (string)
builder.Property(o => o.PlanetItemId)
.HasColumnOrder(14)
.HasColumnName("planet_item_id")
.HasMaxLength(50)
.IsRequired()
.HasComment("플래닛 아이템 아이디");
// 플래닛 아이템 수량 (long)
builder.Property(o => o.PlanetItemDeltaAmount)
.HasColumnOrder(15)
.HasColumnName("planet_item_quantity")
.HasColumnType("INT")
.IsRequired()
.HasComment("플래닛 아이템 갯수");
// 생성 시간 (TIMESTAMP)
builder.Property(o => o.CreatedAt)
.HasColumnOrder(16)
.HasColumnName("created_at")
.HasColumnType("TIMESTAMP")
.IsRequired()
.HasDefaultValueSql("CURRENT_TIMESTAMP")
.HasComment("교환 주문 시작 시간");
// 완료 시간 (TIMESTAMP?) - Nullable
builder.Property(o => o.CompletedAt)
.HasColumnOrder(17)
.HasColumnName("completed_at")
.HasColumnType("TIMESTAMP")
.IsRequired(false)
.HasComment("교환 주문 완료 시간");
}
}

56
BrokerApiCore/Repository/SqlConfig/PlanetInfoConfig.cs Normal file
View File

@@ -0,0 +1,56 @@
namespace BrokerCore.Repository.SqlConfig;
using DbEntity;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;
public class PlanetInfoConfig : IEntityTypeConfiguration<PlanetInfo>
{
public void Configure(EntityTypeBuilder<PlanetInfo> builder)
{
builder.ToTable("planet_info");
builder.HasKey(x => x.PlanetId);
builder.HasIndex(x => x.PlanetName);
builder.HasIndex(x => x.CompanyName);
builder.HasIndex(x => x.SecretKey);
builder.Property(x => x.PlanetId)
.IsRequired()
.HasColumnName("planet_id")
.HasColumnType("varchar(50)");
builder.Property(x => x.PlanetName)
.IsRequired()
.HasColumnName("planet_name")
.HasColumnType("varchar(32)");
builder.Property(x => x.CompanyName)
.IsRequired()
.HasColumnName("company_name")
.HasColumnType("varchar(32)");
builder.Property(x => x.SecretKey)
.IsRequired()
.HasColumnName("secret_key")
.HasColumnType("varchar(50)");
builder.Property(x => x.ServerType)
.IsRequired()
.HasColumnName("server_type")
.HasColumnType("varchar(50)");
builder.Property(x => x.Description)
.IsRequired()
.HasColumnName("description")
.HasColumnType("varchar(255)");
builder.Property(x => x.CreatedAt)
.HasColumnName("created_at")
.HasComment("생성 시간")
.HasColumnType("timestamp")
.IsRequired()
.HasDefaultValueSql("CURRENT_TIMESTAMP"); // MySQL 기본값
builder.Property(x => x.UpdatedAt)
.HasColumnName("updated_at")
.HasComment("수정 시간")
.HasColumnType("timestamp")
.IsRequired()
.HasDefaultValueSql("CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"); // MySQL 기본값
}
}

63
BrokerApiCore/Repository/SqlConfig/PlanetItemExchangeOrderAmountTotalLimitConfig.cs Normal file
View File

@@ -0,0 +1,63 @@
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;
namespace BrokerApiCore.Repository.SqlConfig;
using BrokerCore.DbEntity;
public class PlanetItemExchangeOrderAmountTotalLimitConfig : IEntityTypeConfiguration<PlanetItemExchangeOrderAmountTotalLimit>
{
public void Configure(EntityTypeBuilder<PlanetItemExchangeOrderAmountTotalLimit> builder)
{
// 테이블 이름
builder.ToTable("planet_exchange_order_amount_total_limits");
// 인덱스
builder.HasIndex(o => o.ExchangeDate);
builder.HasIndex(o => o.ExchangeMetaId);
builder.HasIndex(o => o.SeasonId);
// 복합 기본 키 (Primary Key) - ExchangeMetaId에 PlanetId 속성이 있으므로 생략함
builder.HasKey(o => new { o.ExchangeMetaId, o.ExchangeDate, o.SeasonId});
// 교환 메타 아이디
builder.Property(o => o.ExchangeMetaId)
.HasColumnName("exchange_meta_id")
.HasMaxLength(50)
.IsRequired()
.HasComment("교환 메타 아이디");
// 교환 일자
builder.Property(o => o.ExchangeDate)
.HasColumnName("exchange_date")
.IsRequired()
.HasComment("교환 일자");
// 교환 메타 수량
builder.Property(o => o.DailyAmount)
.HasColumnName("daily_amount")
.HasColumnType("INT")
.IsRequired()
.HasComment("일일 교환 메타 수량 합계");
builder.Property(o => o.SeasonId)
.HasColumnName("season_id")
.HasMaxLength(50)
.IsRequired()
.HasComment("시즌 아이디");
builder.Property(o => o.CreatedAt)
.HasColumnName("created_at")
.HasColumnType("TIMESTAMP")
.IsRequired()
.HasComment("생성 일자");
builder.Property(o => o.UpdatedAt)
.HasColumnName("updated_at")
.HasColumnType("TIMESTAMP")
.IsRequired()
.HasComment("업데이트 일자");
}
}

72
BrokerApiCore/Repository/SqlConfig/PlanetItemExchangeOrderAmountUserLimitConfig.cs Normal file
View File

@@ -0,0 +1,72 @@

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;
namespace BrokerApiCore.Repository.SqlConfig;
using BrokerCore.DbEntity;
public class PlanetItemExchangeOrderAmountUserLimitConfig : IEntityTypeConfiguration<PlanetItemExchangeOrderAmountUserLimit>
{
public void Configure(EntityTypeBuilder<PlanetItemExchangeOrderAmountUserLimit> builder)
{
// 테이블 이름
builder.ToTable("planet_exchange_order_amount_user_limits");
// 인덱스
builder.HasIndex(o => o.ExchangeMetaId);
builder.HasIndex(o => o.ExchangeDate);
builder.HasIndex(o => o.SeasonId);
builder.HasIndex(o => o.UserGuid);
// 복합 기본 키 (Primary Key) - ExchangeMetaId에 PlanetId 속성이 있으므로 생략함
builder.HasKey(o => new { o.ExchangeMetaId, o.ExchangeDate, o.SeasonId, o.UserGuid });
// 교환 메타 아이디
builder.Property(o => o.ExchangeMetaId)
.HasColumnName("exchange_meta_id")
.HasMaxLength(50)
.IsRequired()
.HasComment("교환 메타 아이디");
// 교환 일자
builder.Property(o => o.ExchangeDate)
.HasColumnName("exchange_date")
.IsRequired()
.HasComment("교환 일자");
// 유저 아이디
builder.Property(o => o.UserGuid)
.HasColumnName("user_guid")
.HasMaxLength(50)
.IsRequired()
.HasComment("유저 아이디 (GUID)");
// 교환 메타 수량
builder.Property(o => o.DailyAmount)
.HasColumnName("daily_amount")
.HasColumnType("INT")
.IsRequired()
.HasComment("사용자별 일일 교환 메타 수량");
builder.Property(o => o.SeasonId)
.HasColumnName("season_id")
.HasMaxLength(50)
.IsRequired()
.HasComment("시즌 아이디");
builder.Property(o => o.CreatedAt)
.HasColumnName("created_at")
.HasColumnType("TIMESTAMP")
.IsRequired()
.HasComment("생성 일자");
builder.Property(o => o.UpdatedAt)
.HasColumnName("updated_at")
.HasColumnType("TIMESTAMP")
.IsRequired()
.HasComment("업데이트 일자");
}
}

67
BrokerApiCore/Repository/SqlConfig/SapphireExchangeOrderConfig.cs Normal file
View File

@@ -0,0 +1,67 @@
namespace BrokerCore.Repository.SqlConfig;
using DbEntity;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;
public class SapphireExchangeOrderConfig : IEntityTypeConfiguration<SapphireExchangeOrder>
{
public void Configure(EntityTypeBuilder<SapphireExchangeOrder> builder)
{
builder.ToTable("sapphire_exchange_order");
builder.HasKey(x => x.OrderId);
builder.HasIndex(x => x.CreatedAt);
builder.HasIndex(x => x.OrderStatus);
builder.HasIndex(x => x.AccountId);
builder.HasIndex(x => x.UserGuid);
builder.HasIndex(x => x.PlanetId);
builder.Property(x => x.OrderId)
.HasColumnName("order_id")
.HasColumnType("varchar(60)")
.HasComment("사파이어 교환 주문 아이디 guid")
.IsRequired();
builder.Property(x => x.OrderStatus)
.HasColumnName("order_status")
.HasComment("사파이어 교환 주문 상태")
.HasColumnType("tinyint")
.IsRequired();
builder.Property(x => x.AccountId)
.HasColumnName("account_id")
.HasComment("sso 계정 아이디")
.HasColumnType("bigint unsigned")
.IsRequired();
builder.Property(x => x.UserGuid)
.HasColumnName("user_guid")
.HasComment("유저 아이디")
.HasColumnType("varchar(50)")
.IsRequired();
builder.Property(x => x.PlanetId)
.HasColumnName("planet_id")
.HasComment("플래닛 아이디")
.HasColumnType("varchar(50)")
.IsRequired();
builder.Property(x => x.SapphireReducedDelta)
.HasColumnName("sapphire_reduced_amount")
.HasComment("사파이어 차감 수량")
.HasColumnType("decimal(20, 0)")
.IsRequired();
builder.Property(x => x.PlanetMoneyIncDelta)
.HasColumnName("planet_money_amount")
.HasComment("플래닛에서 발급한 재화 수량")
.HasColumnType("decimal(20, 0)")
.IsRequired();
builder.Property(x => x.CreatedAt)
.HasColumnName("created_at")
.HasComment("사파이어 교환 주문 시작 시간")
.HasColumnType("timestamp")
.IsRequired();
builder.Property(x => x.CompletedAt)
.HasColumnName("completed_at")
.HasComment("사파이어 교환 주문 완료 시간")
.HasColumnType("timestamp")
.IsRequired(false);
}
}

71
BrokerApiCore/Repository/SqlContext/MetaverseBrokerDbContext.cs Normal file
View File

@@ -0,0 +1,71 @@
using ServerCore;
using ServerBase;
using ServerCommon;
using Microsoft.EntityFrameworkCore;
namespace BrokerCore.Repository.Context;
using BrokerApiCore.Repository.SqlConfig;
using DbEntity;
using Microsoft.EntityFrameworkCore.Design;
using SqlConfig;
public class MetaverseBrokerDbContext: DbContext
{
public DbSet<SapphireExchangeOrder> SapphireExchangeOrders { get; set; }
public DbSet<PlanetInfo> PlanetInfos { get; set; }
public DbSet<PlanetItemExchangeOrder> PlanetItemExchangeOrders { get; set; }
//PlanetItemExchangeOrderAmountUserLimit
public DbSet<PlanetItemExchangeOrderAmountUserLimit> PlanetItemExchangeOrderAmountUserLimits { get; set; }
//PlanetItemExchangeOrderAmountTotalLimit
public DbSet<PlanetItemExchangeOrderAmountTotalLimit> PlanetItemExchangeOrderAmountTotalLimits { get; set; }
public MetaverseBrokerDbContext(DbContextOptions<MetaverseBrokerDbContext> options) : base(options)
{
// base.Database.EnsureCreated();
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.ApplyConfiguration(new PlanetInfoConfig());
// todo PlanetExchangeOrderConfig으로 교체 예정
modelBuilder.ApplyConfiguration(new SapphireExchangeOrderConfig());
modelBuilder.ApplyConfiguration(new PlanetExchangeOrderConfig());
modelBuilder.ApplyConfiguration(new PlanetItemExchangeOrderAmountUserLimitConfig());
modelBuilder.ApplyConfiguration(new PlanetItemExchangeOrderAmountTotalLimitConfig());
base.OnModelCreating(modelBuilder);
}
}
// ef core 마이그레이션 도구에서 디자인타임에 사용함
public class MetaverseBrokerDbContextFactory : IDesignTimeDbContextFactory<MetaverseBrokerDbContext>
{
public MetaverseBrokerDbContext CreateDbContext(string[] args)
{
// nlog 설정
var nlog_config_path = "../../bin/Debug/Config/nlog.config";
var full_path = Path.GetFullPath(nlog_config_path);
Console.WriteLine("[MetaverseBrokerDbContextFactory] Full path: {0}", full_path);
Log.NLogFileName = full_path;
Log.initLog("BrokerApiServer", "Developer");
var server_config = new ServerConfigMetaverseBroker();
server_config.setConfigFilePath("../../bin/Debug/Config/ServerConfig.json");
server_config.tryLoadConfig().GetAwaiter().GetResult();
var connection_string = server_config.MetaverseBroker?.MetaverseBrokerDbLocal;
Console.WriteLine("[MetaverseBrokerDbContextFactory] Connection string: {0}", connection_string);
if (string.IsNullOrEmpty(connection_string)) { throw new ApplicationException("Connection string is empty."); }
var mysql_version = ServerVersion.AutoDetect(connection_string);
Console.WriteLine("[MetaverseBrokerDbContextFactory] Mysql vsersion: {0}", mysql_version.ToString());
// var mysql_version = ServerVersion.Create(new Version(11, 6, 2), ServerType.MariaDb);
var options_builder = new DbContextOptionsBuilder<MetaverseBrokerDbContext>();
options_builder.UseMySql(connection_string, mysql_version, builder => builder.EnableRetryOnFailure(3)).EnableDetailedErrors();
return new MetaverseBrokerDbContext(options_builder.Options);
}
}

31
BrokerApiCore/Repository/SqlContext/SsoAccountDbContext.cs Normal file
View File

@@ -0,0 +1,31 @@
using Microsoft.EntityFrameworkCore;
namespace BrokerCore.Repository.Context;
using DbEntity;
public class SsoAccountDbContext: DbContext
{
private readonly DbContextOptions<SsoAccountDbContext> m_options;
public DbSet<SsoAccountInfo> SsoAccounts { get; set; }
// public DbSet<WalletUser> WalletUsers { get; set; }
public SsoAccountDbContext(DbContextOptions<SsoAccountDbContext> options) : base(options)
{
m_options = options;
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity<SsoAccountInfo>(entity =>
{
entity.ToTable("wallet_user");
entity.HasNoKey();
entity.Property(x => x.Id).HasColumnName("id").HasColumnType("bigint unsigned");
entity.Property(x => x.AccessToken).HasColumnName("access_token").HasColumnType("bigint unsigned");
entity.Property(x => x.AccessTokenIgm).HasColumnName("access_igm_token").HasColumnType("bigint unsigned");
entity.Property(x => x.Email).HasColumnName("email").HasColumnType("varchar(500)");
});
// base.OnModelCreating(modelBuilder);
}
}

52
BrokerApiCore/Repository/SsoAccountRepo.cs Normal file
View File

@@ -0,0 +1,52 @@
using Microsoft.EntityFrameworkCore;
namespace BrokerCore.Repository;
using Context;
using DbEntity;
public class SsoAccountRepo
{
private readonly SsoAccountDbContext m_db_context;
public SsoAccountRepo(SsoAccountDbContext dbContext)
{
m_db_context = dbContext;
}
public async Task<(Result, SsoAccountInfo?)> findOne(ulong id)
{
try
{
var sso_account = await m_db_context.SsoAccounts.Where(x => x.Id == id).FirstOrDefaultAsync();
if (sso_account == null)
{
return (new Result { ErrorCode = ServerErrorCode.AccountIdNotFoundInSsoAccountDb, ResultString = "Not found SsoAccount" },
null);
}
return (new Result(), sso_account);
}
catch (Exception e)
{
return (new Result { ErrorCode = ServerErrorCode.RdbError, ResultString = e.Message },
null);
}
}
public async Task<(Result, SsoAccountInfo?)> findOneByEmail(string email)
{
try
{
var sso_account = await m_db_context.SsoAccounts.Where(x => x.Email == email).FirstOrDefaultAsync();
if (sso_account == null)
{
return (new Result { ErrorCode = ServerErrorCode.AccountIdNotFoundInSsoAccountDb, ResultString = "Not found SsoAccount" },
null);
}
return (new Result(), sso_account);
}
catch (Exception e)
{
return (new Result { ErrorCode = ServerErrorCode.RdbError, ResultString = e.Message },
null);
}
}
}

67
BrokerApiCore/Repository/UserBaseDocRepo.cs Normal file
View File

@@ -0,0 +1,67 @@
using ServerCommon;
namespace BrokerCore.Repository;
using ServerCore; using ServerBase;
public class UserBaseDocRepo
{
private readonly DynamoDbClient m_dynamo_db_client;
public UserBaseDocRepo(DynamoDbClient dynamoDbClient)
{
this.m_dynamo_db_client = dynamoDbClient;
}
public async Task<(Result, UserBaseDoc?)> findUserBaseDoc(string userGuid)
{
var (result, primary_key_object) = await DynamoDBDocBaseHelper.makePrimaryKey<UserBaseDoc>(userGuid);
if (result.isFail() || primary_key_object == null)
{
return (result, null);
}
var config = m_dynamo_db_client.makeQueryConfigForReadByPKOnly(primary_key_object.PK);
// var (result, user_doc) = await m_dynamoDbClient.simpleQueryDocTypeWithQueryOperationConfig<UserBaseDoc>(config);
return await m_dynamo_db_client.simpleQueryDocTypeWithQueryOperationConfig<UserBaseDoc>(config);
}
public async Task<(Result, UserBaseAttrib?)> findUserBaseAttrib(string userGuid)
{
var (result, doc) = await findUserBaseDoc(userGuid);
return (result, doc?.getAttrib<UserBaseAttrib>());
}
public async Task<(Result, string)> findNickname(string userGuid)
{
var (result, found_nickname_attrib) = await NicknameDoc.findNicknameFromGuid(m_dynamo_db_client, userGuid);
if(result.isFail())
{
return (result, string.Empty);
}
NullReferenceCheckHelper.throwIfNull(found_nickname_attrib, () => $"found_nickname_attrib is null !!!, userGuid:{userGuid}");
return (result, found_nickname_attrib.Nickname);
}
//===================================================================================================
// 로그아웃 여부만 체크
// TODO: 레디스 캐시를 이용하여 로그인 여부를 체크하는 것이 더 효율적일 수 있음
//===================================================================================================
public bool isUserLoggedIn(UserBaseAttrib userAttrib)
{
return userAttrib.GameLoginDateTime > userAttrib.GameLogoutDateTime;
}
// public async Task<Result> insertUserBaseDoc(UserBaseAttrib userAttrib)
// {
// var user_doc = new UserBaseDoc(userAttrib.UserGuid);
// var user_attrib = user_doc.getAttrib<UserBaseAttrib>();
// NullReferenceCheckHelper.throwIfNull(user_attrib, () => $"insertUserBaseDoc : user_attrib is null !!! - {userAttrib.UserGuid}");
// user_attrib.UserGuid = userAttrib.UserGuid;
// user_attrib.AccountId = userAttrib.AccountId;
// user_attrib.EOA = userAttrib.EOA;
// user_attrib.SelectedCharacterGuid = userAttrib.SelectedCharacterGuid;
// user_attrib.IsIntroCompleted = userAttrib.IsIntroCompleted;
// return await m_dynamoDbClient.simpleInsertDocumentWithDocType(user_doc);
// }
}