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

51
BrokerApiServer/Controllers/AccountController.cs Normal file
View File

@@ -0,0 +1,51 @@
// using Microsoft.AspNetCore.Mvc;
//
// using Swashbuckle.AspNetCore.Annotations;
//
// using BrokerCore.ApiModels;
// using BrokerCore.Common;
//
// namespace BrokerApiServer.Controllers;
//
// using BrokerCore.Services;
//
// using Common;
//
// [Route("api/v1/account")]
// [ApiController, SwaggerTag("**PlanetUser 항목으로 이전 후 삭제 예정** (3월 말 예정)")]
// // 플래닛에서 b2b 유저 로그인하는 컨트롤러
// public class AccountController : PlanetAuthControllerBase
// {
// private readonly UserAuthService m_user_auth_service;
//
// public AccountController(UserAuthService userAuthService)
// {
// m_user_auth_service = userAuthService;
// }
//
// [SwaggerIgnore]
// [HttpPost, Route("login"), RequirePlanetAuth]
// [Produces("application/json")]
// [ProducesResponseType(typeof(LoginResponse), StatusCodes.Status200OK)]
// [ProducesResponseType(typeof(ApiErrorResponse), StatusCodes.Status400BadRequest)]
// [SwaggerOperation(Summary = "웹 포털 런처 토큰으로 칼리버스 유저 인증 처리 (삭제 예정 - 3월말 런칭에 불포함)",
// Description = "플래닛의 클라이언트 구동 시 항상 유저 인증 후 실행해야 함")]
// public async Task<IActionResult> login([FromBody] LoginRequest request)
// {
// Guard.Against.isNull(request, ServerErrorCode.InvalidRequest, "Request is empty");
// Guard.Against.isNullOrEmptyOrWhiteSpace(request.WebPortalToken, ServerErrorCode.InvalidRequest,
// "WebPortalToken does not exist");
//
// var result = await m_user_auth_service.authByWebPortalToken(request.WebPortalToken, this.PlanetId);
// Guard.Against.resultFail(result);
// return Ok(new LoginResponse { UserGuid = m_user_auth_service.UserGuid, Nickname = m_user_auth_service.Nickname, });
// }
//
// [SwaggerIgnore]
// [HttpPost, Route("dummy")]
// public async Task<IActionResult> dummy([FromBody] DummyRequest request)
// {
// await Task.CompletedTask;
// return Ok(new DummyResponse { Dummy = request.Dummy });
// }
// }

125
BrokerApiServer/Controllers/AdminController.cs Normal file
View File

@@ -0,0 +1,125 @@
using Microsoft.AspNetCore.Mvc;
using ServerCommon;
using BrokerCore.ApiModels;
using BrokerCore.Services;
namespace BrokerApiServer.Controllers;
using BrokerCore.Common;
using BrokerCore.DbEntity;
using Common;
using ServerBase;
using Swashbuckle.AspNetCore.Annotations;
[Route("api/v1/admin")]
[ApiController]
// 운영자만 접근 가능한 컨트롤러
public class AdminController : ControllerBase
{
private readonly PlanetItemExchangeService m_exchange_service;
private readonly UserAuthService m_user_auth_service;
public AdminController(PlanetItemExchangeService exchangeService, UserAuthService userAuthService)
{
m_exchange_service = exchangeService;
m_user_auth_service = userAuthService;
}
[SwaggerIgnore]
[HttpPost("sapphire_change"), RequireAdminAuth]
public async Task<IActionResult> userSapphireChange(AdminSapphireChangeRequest request)
{
Guard.Against.isTrue(
string.IsNullOrEmpty(request.UserGuid) && string.IsNullOrEmpty(request.Email) &&
string.IsNullOrEmpty(request.AccountId),
ServerErrorCode.InvalidRequest, ()=>"email 과 userguid의 값이 모두 비어 있음");
var user_guid = request.UserGuid;
if (string.IsNullOrEmpty(user_guid))
{
if (!string.IsNullOrEmpty(request.Email))
{
await m_user_auth_service.authFromEmail(request.Email);
user_guid = m_user_auth_service.UserGuid;
}
else if (!string.IsNullOrEmpty(request.AccountId))
{
await m_user_auth_service.authByAccount(request.AccountId);
user_guid = m_user_auth_service.UserGuid;
}
else
{
Guard.Against.throwException(ServerErrorCode.InvalidRequest, ()=>"요청에 오류가 있음");
}
}
var dynamo_db_client = m_user_auth_service.ServerLogic.getDynamoDbClient();
CurrencyControlHelper.setDbConnector(dynamo_db_client);
var (result, sapphire_current_amount_double) =
await CurrencyControlHelper.earnMoneyByUserGuid(user_guid, CurrencyType.Sapphire, request.SapphireDelta);
Guard.Against.resultFail(result);
return Ok(new AdminSapphireChangeResponse
{
AccountId = request.AccountId,
Email = request.Email,
UserGuid = request.UserGuid,
SapphireDelta = request.SapphireDelta,
SapphireCurrentAmount = Convert.ToInt64(sapphire_current_amount_double)
});
}
[HttpPost("exchange/order/list"), RequireAdminAuth]
[Produces("application/json")]
[ProducesResponseType(StatusCodes.Status200OK, Type = typeof(PlanetItemExchangeOrderListResponse))]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
[SwaggerOperation(Summary = "교환 주문 목록 조회 [Bearer 인증 필요]")]
public async Task<IActionResult> getOrders(
[SwaggerRequestBody] AdminItemExchangeOrderListRequest request,
CancellationToken cancellationToken)
{
// var user_guid = request.UserGuid;
// var account_id = request.SsoAccountId;
// await m_exchange_service.validateAndGetUser(account_id, user_guid, planet_id);
// user_guid = m_exchange_service.PlanetUser.UserGuid;
// account_id = m_exchange_service.PlanetUser.AccountId;
ExchangeOrderStatus? order_status = request switch
{
{ Option: FindOption.Completed } => ExchangeOrderStatus.Completed,
{ Option: FindOption.Pending } => ExchangeOrderStatus.Pending,
_ => null // 전체 조회
};
var account_id = request.SsoAccountId ?? string.Empty;
var user_guid = request.UserGuid ?? string.Empty;
var planet_id = request.PlanetId ?? string.Empty;
var season_id = request.SeasonId ?? string.Empty;
var exchange_meta_id = request.ExchangeMetaId ?? string.Empty;
var page_index = request.PageIndex <= 0 ? 1 : request.PageIndex;
var page_size = request.PageSize <= 0 ? 20 : request.PageSize;
var (orders, total_count) =
await m_exchange_service.findOrderList(planet_id, exchange_meta_id, season_id, user_guid, order_status, page_index,
page_size, "desc", cancellationToken);
var order_dtos = orders.Select(x => new PlanetItemExchangeOrderDto
{
OrderId = x.OrderId,
OrderStatus = x.OrderStatus,
SeasonId = x.SeasonId,
ExchangeMetaId = x.ExchangeMetaId,
ExchangeMetaAmount = x.ExchangeMetaAmount,
AccountId = x.AccountId,
UserGuid = x.UserGuid,
PlanetId = x.PlanetId,
CaliverseItemType = x.CaliverseItemType,
CaliverseItemId = x.CaliverseItemId,
CaliverseItemDeltaAmount = x.CaliverseItemDeltaAmount,
PlanetItemType = x.PlanetItemType,
PlanetItemId = x.PlanetItemId,
PlanetItemDeltaAmount = x.PlanetItemDeltaAmount,
CreatedAt = x.CreatedAt,
CompletedAt = x.CompletedAt,
});
return Ok(new PlanetItemExchangeOrderListResponse { Orders = order_dtos, TotalCount = total_count });
}
}

166
BrokerApiServer/Controllers/CurrencyController.cs Normal file
View File

@@ -0,0 +1,166 @@
// using Asp.Versioning;
//
// using BrokerCore.ApiModels;
// using BrokerCore.Common;
// using BrokerCore.Services;
// using BrokerCore.DbEntity;
//
// using Microsoft.AspNetCore.Mvc;
//
// using Swashbuckle.AspNetCore.Annotations;
//
// namespace BrokerApiServer.Controllers;
//
// using Common;
//
// [ApiVersion("1.0")]
// [Route("api/v1")]
// [ApiController, SwaggerTag("**PlanetUser 항목으로 이전 후 삭제 예정** (3월 말 예정)")]
// // 플래닛에서 b2b로 통신하는 컨트롤러
// public sealed class CurrencyController : PlanetAuthControllerBase
// {
// private readonly SapphireExchangeService m_exchange_service;
//
// public CurrencyController(
// SapphireExchangeService exchangeService)
// {
// m_exchange_service = exchangeService;
// }
//
// [SwaggerIgnore]
// [HttpPost("balance/sapphire"), RequirePlanetAuth]
// [Produces("application/json")]
// [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(SapphireResponse))]
// [ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
// [SwaggerOperation(Summary = "사파이어 현재 수량 조회")]
// public async Task<IActionResult> getSapphireBalance(SapphireRequest request)
// {
// await m_exchange_service.authUser(request.UserGuid, this.PlanetId);
//
// var current_sapphire_amount = await m_exchange_service.getCurrentSapphire();
// return Ok(new SapphireResponse { Amount = current_sapphire_amount });
// }
//
// [SwaggerIgnore]
// [HttpPost("exchange/order/list"), RequirePlanetAuth]
// [Produces("application/json")]
// [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(ExchangeOrderListResponse))]
// [ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
// [SwaggerOperation(Summary = "사파이어 교환 주문 목록 조회")]
// public async Task<IActionResult> getOrders(
// [SwaggerRequestBody] ExchangeOrderListRequest request,
// CancellationToken cancellationToken)
// {
// var planet_id = this.PlanetId;
// var user_guid = request.UserGuid;
// await m_exchange_service.authUser(user_guid, this.PlanetId);
//
// ExchangeOrderStatus? order_status = request switch
// {
// { Option: FindOption.Completed } => ExchangeOrderStatus.Completed,
// { Option: FindOption.Pending } => ExchangeOrderStatus.Pending,
// _ => null // 전체 조회
// };
// var orders =
// await m_exchange_service.findOrderList(planet_id, user_guid, order_status, request.PageIndex,
// request.PageSize, "desc", cancellationToken);
// var mapped_orders = orders.Select(x => new ExchangeOrder
// {
// OrderId = x.OrderId,
// SapphireAmount = x.SapphireReducedDelta,
// SapphireReduceAmount = x.SapphireReducedDelta,
// EmeraldAmount = x.PlanetMoneyIncDelta,
// CreatedAt = x.CreatedAt,
// CompletedAt = x.CompletedAt,
// Status = x.OrderStatus
// });
// return Ok(new ExchangeOrderListResponse { Orders = mapped_orders });
// }
//
// // [HttpPost("exchange/order/list_for_user"), RequireUserJwtAuth]
// // [Produces("application/json")]
// // [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(ExchangeOrderListResponse))]
// // [ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
// // [SwaggerOperation(Summary = "사파이어 교환 주문 목록 조회")]
// // public async Task<IActionResult> getOrdersForUser(
// // [SwaggerRequestBody] ExchangeOrderListRequest request,
// // CancellationToken cancellationToken)
// // {
// // var planet_id = this.PlanetId;
// // var user_guid = request.UserGuid;
// // await m_exchange_service.authUser(user_guid, planet_id);
// //
// // ExchangeOrderStatus? order_status = request switch
// // {
// // { Option: FindOption.Completed } => ExchangeOrderStatus.Completed,
// // { Option: FindOption.Pending } => ExchangeOrderStatus.Pending,
// // _ => null // 전체 조회
// // };
// // var orders =
// // await m_exchange_service.findOrderList(planet_id, user_guid, order_status, request.PageIndex,
// // request.PageSize, request.SortOrder, cancellationToken);
// // var mapped_orders = orders.Select(x => new ExchangeOrder
// // {
// // OrderId = x.OrderId,
// // SapphireAmount = x.SapphireReducedDelta,
// // SapphireReduceAmount = x.SapphireReducedDelta,
// // EmeraldAmount = x.PlanetMoneyIncDelta,
// // CreatedAt = x.CreatedAt,
// // CompletedAt = x.CompletedAt,
// // Status = x.OrderStatus
// // });
// // return Ok(new ExchangeOrderListResponse { Orders = mapped_orders });
// // }
//
// [SwaggerIgnore]
// [HttpPost("exchange/order/create"), RequirePlanetAuth]
// [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(ExchangeOrderResponse))]
// [ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
// [SwaggerOperation(Summary = "사파이어 교환 주문 체결 (사파이어 차감)")]
// public async Task<IActionResult> createOrder(
// ExchangeOrderRequest request,
// CancellationToken cancellationToken)
// {
// var user_guid = request.UserGuid;
// await m_exchange_service.authUser(user_guid, this.PlanetId);
// // 메타버스 클라이언트에서 정상적으로
// Guard.Against.isTrue(m_exchange_service.isUserLoggedIn(),
// ServerErrorCode.MetaverseClientOnConnected,
// "메타버스에 접속 중인 상태. 메타버스에서 정상적으로 로그아웃 한 후에 다시 시도 바람.");
//
// var (order, current_sapphire_balance) =
// await m_exchange_service.createOrder(this.PlanetId, this.PlanetServerType, request.Sapphire,
// request.Emerald);
//
// var response = new ExchangeOrderResponse
// {
// OrderId = order.OrderId,
// SapphireAmount = order.SapphireReducedDelta,
// EmeraldAmount = order.PlanetMoneyIncDelta,
// CurrentSapphireBalance = current_sapphire_balance,
// };
// return Ok(response);
// }
//
// [SwaggerIgnore]
// [HttpPost("exchange/order/complete"), RequirePlanetAuth]
// [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(ExchangeOrderCompleteResponse))]
// [ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
// [SwaggerOperation(Summary = "사파이어 교환 완료 (완료된 이후에 에메랄드 지급")]
// public async Task<IActionResult> completeOrder(
// ExchangeOrderCompleteRequest request,
// CancellationToken cancellationToken)
// {
// await m_exchange_service.authUser(request.UserGuid, this.PlanetId);
//
// var order = await m_exchange_service.completeOrder(request.OrderId, cancellationToken);
// var response = new ExchangeOrderCompleteResponse
// {
// OrderId = order.OrderId,
// SapphireAmount = order.SapphireReducedDelta,
// EmeraldAmount = order.PlanetMoneyIncDelta,
// Status = order.OrderStatus,
// };
// return Ok(response);
// }
// }

43
BrokerApiServer/Controllers/PlanetController.cs Normal file
View File

@@ -0,0 +1,43 @@
using BrokerCore.ApiModels;
using BrokerCore.Services;
using Microsoft.AspNetCore.Mvc;
using Swashbuckle.AspNetCore.Annotations;
namespace BrokerApiServer.Controllers;
using BrokerCore.Common;
[Route("api/v1/planet")]
[ApiController, SwaggerTag("플래닛의 인증 처리")]
// 플래닛 인증 컨트롤러
public class PlanetController : ControllerBase
{
private readonly PlanetService m_planet_service;
public PlanetController(PlanetService planetService)
{
m_planet_service = planetService;
}
[HttpPost("auth")]
[Produces("application/json")]
[ProducesResponseType(StatusCodes.Status200OK, Type = typeof(PlanetAuthResponse))]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
[SwaggerOperation(Summary = "플래닛 서비스 인증")]
public async Task<IActionResult> auth(
[FromBody, SwaggerRequestBody(nameof(PlanetAuthRequest))]
PlanetAuthRequest request)
{
Guard.Against.isNull(request, ServerErrorCode.InvalidRequest, ()=>"invalid request");
Guard.Against.isNullOrEmptyOrWhiteSpace(request.PlanetId, ServerErrorCode.InvalidRequest,
()=>"planet id is required");
Guard.Against.isNullOrEmptyOrWhiteSpace(request.PlanetSecretKey, ServerErrorCode.InvalidRequest,
()=>"planet access key is required");
var access_token = await m_planet_service.auth(request.PlanetId, request.PlanetSecretKey);
Guard.Against.isNull(access_token, ServerErrorCode.InternalServerError, ()=>"access_token create failed");
return Ok(new PlanetAuthResponse { AccessToken = access_token });
}
}

179
BrokerApiServer/Controllers/PlanetUserController.cs Normal file
View File

@@ -0,0 +1,179 @@
using Microsoft.AspNetCore.Mvc;
using Swashbuckle.AspNetCore.Annotations;
namespace BrokerApiServer.Controllers;
using System.ComponentModel;
using BrokerCore.ApiModels;
using BrokerCore.Common;
using BrokerCore.DbEntity;
using BrokerCore.Services;
using Common;
[Route("api/v1/planet/user")]
[ApiController, SwaggerTag("**플래닛 유저의 로그인 및 교환 처리**<br> - /api/v1/planet/auth를 통해 accessToken을 발급받은 후 사용 <br> - Bearer 형식 Hearder로 인증")]
public class PlanetUserController : PlanetAuthControllerBase
{
private readonly PlanetItemExchangeService m_exchange_service;
private readonly UserAuthService m_user_auth_service;
public PlanetUserController(
PlanetItemExchangeService exchangeService, UserAuthService userAuthService)
{
m_exchange_service = exchangeService;
m_user_auth_service = userAuthService;
}
[HttpPost, Route("login"), RequirePlanetAuth]
[Produces("application/json")]
[ProducesResponseType(typeof(LoginResponse), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(ApiErrorResponse), StatusCodes.Status400BadRequest)]
[SwaggerOperation(Summary = "웹 포털 런처 토큰으로 칼리버스 유저 인증 처리 [Bearer 인증 필요]",
Description = "플래닛의 클라이언트 구동 시 항상 유저 인증 후 실행해야 함")]
public async Task<IActionResult> login([FromBody] LoginRequest request)
{
Guard.Against.isNull(request, ServerErrorCode.InvalidRequest, ()=>"Request is empty");
Guard.Against.isNullOrEmptyOrWhiteSpace(request.WebPortalToken, ServerErrorCode.InvalidRequest,
()=>"WebPortalToken does not exist");
var result = await m_user_auth_service.authByWebPortalToken(request.WebPortalToken, this.PlanetId);
Guard.Against.resultFail(result);
return Ok(new LoginResponse
{
UserGuid = m_user_auth_service.UserGuid, Nickname = m_user_auth_service.Nickname,
});
}
[HttpPost("currency"), RequirePlanetAuth]
[Produces("application/json")]
[ProducesResponseType(StatusCodes.Status200OK, Type = typeof(CurrencyBalanceResponse))]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
[SwaggerOperation(Summary = "칼리버스 측 재화 현재 수량 조회 [Bearer 인증 필요]")]
public async Task<IActionResult> getCurrencyBalance(CurrencyBalanceRequest request)
{
var sso_account_id = request.SsoAccountId ?? string.Empty;
var user_guid = request.UserGuid ?? string.Empty;
await m_exchange_service.validateAndGetUser(sso_account_id, user_guid, this.PlanetId);
var current_sapphire_amount = await m_exchange_service.getCurrencyAmount(request.CaliverseCurrencyType);
return Ok(new CurrencyBalanceResponse { CaliverseCurrencyType = request.CaliverseCurrencyType, Amount = current_sapphire_amount });
}
// [SwaggerIgnore]
// [HttpPost("sapphire"), RequirePlanetAuth]
// [Produces("application/json")]
// [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(CurrencyBalanceResponse))]
// [ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
// [SwaggerOperation(Summary = "!! 삭제 예정 => 칼리버스 측 재화 현재 수량 조회로 대체 [Bearer 인증 필요]")]
// public async Task<IActionResult> getSapphireBalance(CurrencyBalanceRequest request)
// {
// var sso_account_id = string.Empty;
// await m_exchange_service.validateAndGetUser(sso_account_id, request.UserGuid, this.PlanetId);
//
// var current_sapphire_amount = await m_exchange_service.getCurrentSapphire();
// return Ok(new CurrencyBalanceResponse { Amount = current_sapphire_amount });
// }
[HttpPost("exchange/order/list"), RequirePlanetAuth]
[Produces("application/json")]
[ProducesResponseType(StatusCodes.Status200OK, Type = typeof(PlanetItemExchangeOrderListResponse))]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
[SwaggerOperation(Summary = "교환 주문 목록 조회 [Bearer 인증 필요]")]
public async Task<IActionResult> getOrders(
[SwaggerRequestBody] PlanetItemExchangeOrderListRequest request,
CancellationToken cancellationToken)
{
var planet_id = string.IsNullOrEmpty(request.PlanetId) ? this.PlanetId : request.PlanetId;
var user_guid = request.UserGuid;
var account_id = request.SsoAccountId;
await m_exchange_service.validateAndGetUser(account_id, user_guid, this.PlanetId);
user_guid = m_exchange_service.PlanetUser.UserGuid;
account_id = m_exchange_service.PlanetUser.AccountId;
ExchangeOrderStatus? order_status = request switch
{
{ Option: FindOption.Completed } => ExchangeOrderStatus.Completed,
{ Option: FindOption.Pending } => ExchangeOrderStatus.Pending,
_ => null // 전체 조회
};
var season_id = request.SeasonId;
var request_exchange_meta_id = request.ExchangeMetaId;
var page_index = request.PageIndex <= 0 ? 1 : request.PageIndex;
var page_size = request.PageSize <= 0 ? 20 : request.PageSize;
var (orders, total_count) =
await m_exchange_service.findOrderList(planet_id, request_exchange_meta_id, season_id, user_guid, order_status, page_index,
page_size, "desc", cancellationToken);
var order_dtos = orders.Select(x => new PlanetItemExchangeOrderDto
{
OrderId = x.OrderId,
OrderStatus = x.OrderStatus,
SeasonId = x.SeasonId,
ExchangeMetaId = x.ExchangeMetaId,
ExchangeMetaAmount = x.ExchangeMetaAmount,
AccountId = x.AccountId,
UserGuid = x.UserGuid,
PlanetId = x.PlanetId,
CaliverseItemType = x.CaliverseItemType,
CaliverseItemId = x.CaliverseItemId,
CaliverseItemDeltaAmount = x.CaliverseItemDeltaAmount,
PlanetItemType = x.PlanetItemType,
PlanetItemId = x.PlanetItemId,
PlanetItemDeltaAmount = x.PlanetItemDeltaAmount,
CreatedAt = x.CreatedAt,
CompletedAt = x.CompletedAt,
});
return Ok(new PlanetItemExchangeOrderListResponse { Orders = order_dtos, TotalCount = total_count });
}
[HttpPost("exchange/order/create"), RequirePlanetAuth]
[ProducesResponseType(StatusCodes.Status200OK, Type = typeof(PlanetItemExchangeResponse))]
[ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse)), Description("에러 발생 시 처리")]
[Produces("application/json")]
[SwaggerOperation(Summary = "교환 주문 체결 요청 [Bearer 인증 필요]")]
public async Task<IActionResult> createOrder(
PlanetItemExchangeRequest request,
CancellationToken cancellationToken)
{
var sso_account_id = string.Empty;
var user_guid = request.UserGuid;
var season_id = request.SeasonId;
await m_exchange_service.validateAndGetUser(sso_account_id, user_guid, this.PlanetId);
// 메타버스 클라이언트에서 정상적으로
Guard.Against.isTrue(m_exchange_service.isUserLoggedIn(),
ServerErrorCode.MetaverseClientOnConnected,
()=>"메타버스에 접속 중인 상태. 메타버스에서 정상적으로 로그아웃 한 후에 다시 시도 바람.");
var (result, order) =
await m_exchange_service.createOrder(this.PlanetId, season_id, this.PlanetServerType, request.ExchangeMetaId,
request.ExchangeMetaAmount, cancellationToken);
Guard.Against.resultFail(result, ServerErrorCode.InternalServerError, ()=>result.ResultString);
var response = new PlanetItemExchangeResponse { ExchangeOrder = order.toDto(), };
return Ok(response);
}
[HttpPost("exchange/order/complete"), RequirePlanetAuth]
[Produces("application/json")]
[ProducesResponseType(StatusCodes.Status200OK, Type = typeof(PlanetItemExchangeResponse))]
[SwaggerResponse(StatusCodes.Status400BadRequest, "교환 주문 완료 실패<br>실패 사유를 확인하세요.",
typeof(ApiErrorResponse))]
[SwaggerOperation(Summary = "교환 주문 완료 요청 [Bearer 인증 필요]")]
public async Task<IActionResult> completeOrder(
PlanetItemExchangeCompleteRequest request,
CancellationToken cancellationToken)
{
var sso_account_id = string.Empty;
await m_exchange_service.validateAndGetUser(sso_account_id, request.UserGuid, this.PlanetId);
// 메타버스 클라이언트에서 정상적으로
Guard.Against.isTrue(m_exchange_service.isUserLoggedIn(),
ServerErrorCode.MetaverseClientOnConnected,
()=>"메타버스에 접속 중인 상태. 메타버스에서 정상적으로 로그아웃 한 후에 다시 시도 바람.");
var order = await m_exchange_service.completeOrder(request.ExchangeOrderId, cancellationToken);
var response = new PlanetItemExchangeResponse { ExchangeOrder = order.toDto() };
return Ok(response);
}
}

93
BrokerApiServer/Controllers/UserController.cs Normal file
View File

@@ -0,0 +1,93 @@
//
// using Asp.Versioning;
//
// using BrokerCore.ApiModels;
// using BrokerCore.Common;
// using BrokerCore.DbEntity;
// using BrokerCore.Services;
//
// using Microsoft.AspNetCore.Mvc;
//
// using ServerCommon;
//
// using Swashbuckle.AspNetCore.Annotations;
//
// namespace BrokerApiServer.Controllers;
//
// [ApiVersion("1.0")]
// [Route("api/v1/user")]
// [ApiController, SwaggerTag("**PlanetUser 항목으로 이전 후 삭제 예정** (3월 말 예정)")]
// // 특별한 인증 없이 런처 토큰만으로도 사용 가능한 컨트롤러
// public class UserController : ControllerBase
// {
// private readonly SapphireExchangeService m_exchange_service;
// private readonly IServerLogic m_server_logic;
//
// public UserController(
// IServerLogic serverLogic,
// SapphireExchangeService exchangeService)
// {
// m_server_logic = serverLogic;
// m_exchange_service = exchangeService;
// }
//
// [SwaggerIgnore]
// [HttpPost("balance/sapphire"), RequireUserJwtAuth]
// [Produces("application/json")]
// [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(UserSapphireResponse))]
// [ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
// [SwaggerOperation(Summary = "유저 사파이어 현재 수량 조회 (유저 sso jwt bearer header 필요)",
// Description = "웹 런처에서 발급한 토큰을 header의 authorization에 bearer 형식으로 넣어주세요.")]
// public async Task<IActionResult> getSapphireBalance(UserSapphireRequest _)
// {
// var dynamo_db_client = m_server_logic.getDynamoDbClient();
// var user_guid = this.HttpContext.Items["user_guid"] as string ?? string.Empty;
// CurrencyControlHelper.setDbConnector(dynamo_db_client);
// var (result, current_sapphire_amount_double) =
// await CurrencyControlHelper.getMoneyByUserGuid(user_guid, CurrencyType.Sapphire);
// Guard.Against.resultFail(result);
//
// var current_sapphire_amount = Convert.ToInt64(current_sapphire_amount_double);
// return Ok(new UserSapphireResponse { SapphireAmount = current_sapphire_amount });
// }
//
// [SwaggerIgnore]
// [HttpPost("exchange/order/list"), RequireUserJwtAuth]
// [Produces("application/json")]
// [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(UserExchangeOrderListResponse))]
// [ProducesResponseType(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
// [SwaggerOperation(Summary = "유저 사파이어 교환 주문 목록 조회 (유저 sso jwt bearer header 필요)",
// Description = "웹 런처에서 발급한 토큰을 header의 authorization에 bearer 형식으로 넣어주세요.\n 이기몹의 PlanetId는 igm26_iggymob 입니다.")]
// public async Task<IActionResult> getOrdersForUser(
// [SwaggerRequestBody] UserExchangeOrderListRequest request,
// CancellationToken cancellationToken)
// {
// var planet_id = request.PlanetId;
// var user_guid = this.HttpContext.Items["user_guid"]?.ToString() ?? string.Empty;
// Guard.Against.isNullOrEmptyOrWhiteSpace(user_guid,
// ServerErrorCode.AccountNotFound, "해당 유저를 찾을 수 없음");
// await m_exchange_service.authUser(user_guid, string.Empty);
//
// ExchangeOrderStatus? order_status = request switch
// {
// { Option: FindOption.Completed } => ExchangeOrderStatus.Completed,
// { Option: FindOption.Pending } => ExchangeOrderStatus.Pending,
// _ => null // 전체 조회
// };
// var orders =
// await m_exchange_service.findOrderList(planet_id, user_guid, order_status,
// request.PageIndex, request.PageSize, request.SortOrder,
// cancellationToken);
// var mapped_orders = orders.Select(x => new ExchangeOrder
// {
// OrderId = x.OrderId,
// SapphireAmount = x.SapphireReducedDelta,
// SapphireReduceAmount = x.SapphireReducedDelta,
// EmeraldAmount = x.PlanetMoneyIncDelta,
// CreatedAt = x.CreatedAt,
// CompletedAt = x.CompletedAt,
// Status = x.OrderStatus
// });
// return Ok(new UserExchangeOrderListResponse { Orders = mapped_orders });
// }
// }