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

335
UGQApiServer/Controllers/Admin/AdminAccountController.cs Normal file
View File

@@ -0,0 +1,335 @@
using System.Globalization;
using System.Security.Claims;
using Amazon.DynamoDBv2.Model;
using Asp.Versioning;
using MetaAssets;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using ServerCommon;
using ServerCommon.UGQ.Models;
using Swashbuckle.AspNetCore.Annotations;
using UGQApiServer.Controllers.Common;
using UGQApiServer.Converter;
using UGQApiServer.Models;
using UGQApiServer.Auth;
using UGQDataAccess.Repository.Models;
using UGQDataAccess.Service;
using UGQDatabase.Models;
using ServerCommon.BusinessLogDomain;
using UGQDataAccess.Repository;
using MySqlConnector;
using ServerBase;
namespace UGQApiServer.Controllers.Admin;
[ApiController]
[ApiVersion("1.0")]
[ApiExplorerSettings(GroupName = "admin")]
[Route("api/v{version:apiVersion}/Admin/Account")]
[ControllerName("Account")]
[UGQAdminApi]
[Authorize(Roles = "Admin,Service")]
public class AdminAccountController : ControllerBase
{
const int MAX_PAGE_SIZE = 100;
AccountService _accountService;
QuestEditorService _questEditorService;
MetaDataApi _metaDataApi;
QuestEditorApi _questEditorApi;
DynamoDbClient _dynamoDbClient;
AuthSql _authSql;
public AdminAccountController(
AccountService accountService,
QuestEditorService questEditorService, MetaDataApi metaDataApi, QuestEditorApi questEditorApi,
DynamoDbClient dynamoDbClient, AuthSql authSql)
{
_accountService = accountService;
_questEditorService = questEditorService;
_metaDataApi = metaDataApi;
_questEditorApi = questEditorApi;
_dynamoDbClient = dynamoDbClient;
_authSql = authSql;
}
string? adminUsernameFromToken()
{
return User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Name)?.Value;
}
/// <summary>
/// 모든 계정 리스트 얻기
/// </summary>
[HttpGet]
[Route("all-accounts")]
[Produces("application/json")]
public async Task<IResult> getAllAccounts([FromQuery] int pageNumber, [FromQuery] int pageSize, [FromQuery] string? searchText, [FromQuery] AccountSortType sortType)
{
pageSize = Math.Clamp(pageSize, 1, MAX_PAGE_SIZE);
var result = await _accountService.getAccounts(pageNumber, pageSize, searchText, sortType);
long totalCount = await _accountService.getAllAccountCount();
return Results.Ok(new UGQAllAccountItemResponse
{
TotalCount = totalCount,
PageNumber = result.PageNumber,
PageSize = result.PageSize,
TotalPages = result.TotalPages,
Accounts = result.Items.Select(x => x.ToDTO()).ToList()
});
}
/// <summary>
/// 계정 정보 얻기
/// </summary>
[HttpGet]
[Route("account")]
[Produces("application/json")]
public async Task<IResult> getAccount([FromQuery] string userGuid)
{
var accountEntity = await _accountService.getAccount(userGuid);
if (accountEntity == null)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));
(Result result, MoneyAttrib? moneyAttrib) =
await EntitySearchHelper.findUserMoneyByUserGuid(_dynamoDbClient, accountEntity.UserGuid);
if (result.isFail())
return Results.BadRequest(ApiResponseFactory.error(result.ErrorCode));
if(moneyAttrib == null)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UserMoneyDocEmpty));
return Results.Ok(new UGQAccountMoney
{
Sapphire = moneyAttrib.Sapphire,
UserGuid = accountEntity.UserGuid,
Nickname = accountEntity.Nickname,
AccountId = accountEntity.AccountId ?? "",
SlotCount = (MetaHelper.GameConfigMeta.UGQDefaultSlot + accountEntity.AdditionalSlotCount),
GradeType = accountEntity.GradeType,
CreatorPoint = accountEntity.CreatorPoint,
});
}
/// <summary>
/// 계정의 UGQ 슬롯 수 변경
/// </summary>
[HttpPost]
[Route("modify-account-slot")]
[Produces("application/json")]
public async Task<IResult> modifyAccountSlot([FromBody] UGQModifyAccountSlot model)
{
string? adminUsername = adminUsernameFromToken();
if (adminUsername == null)
return Results.Unauthorized();
(ServerErrorCode errorCode, var accountEntity) = await _accountService.modifySlotCount(model.UserGuid, model.Count, adminUsername);
if (errorCode != ServerErrorCode.Success)
return Results.BadRequest(ApiResponseFactory.error(errorCode));
if (accountEntity == null)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));
return Results.Ok(accountEntity.ToDTO());
}
/// <summary>
/// 계정의 UGQ 등급 변경 예약
/// </summary>
[HttpPost]
[Route("reserve-account-grade")]
[Produces("application/json")]
public async Task<IResult> reserveAccountGrade([FromBody] UGQReserveAccountGrade model)
{
if (DateTime.UtcNow > model.ReserveTime)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqInvalidReserveTime));
var accountEntity = await _accountService.getAccount(model.UserGuid);
if (accountEntity == null)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));
if(accountEntity.GradeType == model.GradeType)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqSameGradeReserve));
var reserveAccountGradeEntity = await _accountService.getReserveAccountGrade(model.UserGuid);
if(reserveAccountGradeEntity != null)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqAlreadyExistsReserveGrade));
reserveAccountGradeEntity = await _accountService.reserveAccountGrade(model.UserGuid, accountEntity.GradeType, model.GradeType, model.ReserveTime);
if (reserveAccountGradeEntity == null)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));
return Results.Ok(reserveAccountGradeEntity.ToDTO());
}
/// <summary>
/// 계정의 UGQ 등급 변경 예약 수정
/// </summary>
[HttpPost]
[Route("modify-reserve-account-grade")]
[Produces("application/json")]
public async Task<IResult> modifyReserveAccountGrade([FromBody] UGQModifyAccountGrade model)
{
if (DateTime.UtcNow > model.ReserveTime)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqInvalidReserveTime));
var reserveAccountGradeEntity = await _accountService.modifyReserveAccountGrade(model.ReserveId, model.GradeType, model.ReserveTime);
if (reserveAccountGradeEntity == null)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));
return Results.Ok(reserveAccountGradeEntity.ToDTO());
}
/// <summary>
/// 계정의 UGQ 등급 변경 예약 취소
/// </summary>
[HttpPost]
[Route("delete-reserve-account-grade")]
[Produces("application/json")]
public async Task<IResult> deleteReserveAccountGrade([FromQuery] string reserveId)
{
var errorCode = await _accountService.deleteReserveAccountGrade(reserveId);
if (errorCode != ServerErrorCode.Success)
return Results.BadRequest(ApiResponseFactory.error(errorCode));
return Results.Ok();
}
/// <summary>
/// 계정의 UGQ 등급 변경 예약 조회
/// </summary>
[HttpPost]
[Route("all-reserve-account-grade")]
[Produces("application/json")]
public async Task<IResult> getAllReserveAccountGrade([FromQuery] int pageNumber, [FromQuery] int pageSize, [FromQuery] AccountGradeSortType sortType, [FromQuery] AccountGradeProcessType processType, [FromQuery] string? accountId)
{
string userGuid = string.Empty;
if(accountId != null)
{
var accountEntity = await _accountService.getAccountByAccountId(accountId);
if (accountEntity == null || accountEntity.AccountId == null)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));
userGuid = accountEntity.UserGuid;
}
var result = await _accountService.getReserveAccountGrades(pageNumber, pageSize, sortType, processType, userGuid);
if (result == null)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));
long totalCount = await _accountService.getAllReserveAccountGradeCount();
if (accountId != null)
totalCount = result.Items.Count;
return Results.Ok(new UGQAllReserveAccountGradeItemResponse
{
TotalCount = totalCount,
PageNumber = result.PageNumber,
PageSize = result.PageSize,
TotalPages = result.TotalPages,
Accounts = result.Items.Select(x => x.ToDTO()).ToList()
});
}
/// <summary>
/// 계정의 UGQ 등급 변경 예약 조회
/// </summary>
[HttpPost]
[Route("get-reserve-account-grade")]
[Produces("application/json")]
public async Task<IResult> getReserveAccountGrade([FromQuery] string accountId, [FromQuery] AccountGradeProcessType processType)
{
var accountEntity = await _accountService.getAccountByAccountId(accountId);
if(accountEntity == null || accountEntity.AccountId == null)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));
var reserveAccountGradeEntityList = await _accountService.getReserveAccountGrade(accountEntity.UserGuid, processType);
if (reserveAccountGradeEntityList == null || reserveAccountGradeEntityList.Count == 0)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));
return Results.Ok(new UGQReserveAccountGradeItemResponse
{
Accounts = reserveAccountGradeEntityList.Select(x => x.ToDTO()).ToList()
});
}
/// <summary>
/// 계정의 Creator Point 변경
/// </summary>
[HttpPost]
[Route("modify-creator-point")]
[Produces("application/json")]
public async Task<IResult> modifyCreatorPoint([FromBody] UGQModifyCreatorPoint model)
{
string? adminUsername = adminUsernameFromToken();
if (adminUsername == null)
return Results.Unauthorized();
(var errorCode, var accountEntity) = await _accountService.modifyCreatorPoint(model.UserGuid, model.Amount, model.Reason, adminUsername);
if (errorCode != ServerErrorCode.Success)
return Results.BadRequest(ApiResponseFactory.error(errorCode));
if (accountEntity == null)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));
return Results.Ok(accountEntity.ToDTO());
}
/// <summary>
/// 메타버스 계정 정보 얻기
/// </summary>
/// <remarks>
/// email을 입력하면 email로 accountId를 검색, email을 입력 안 하면 accountId 입력 값을 사용
/// </remarks>
[HttpGet]
[Route("metaverse-account")]
[Produces("application/json")]
public async Task<IResult> getMetaverseAccount([FromQuery] string? email, [FromQuery] ulong? accountId)
{
if (email != null)
{
accountId = await _authSql.getAccountIdFromMysql(email);
if (accountId == 0)
{
return Results.Ok(new UGQMetaverseAccount
{
});
}
}
string loginAccountId = accountId.ToString() ?? "";
(Result result, UserByAccountIdResult? gameAccount) =
await EntitySearchHelper.findUserByAccountId(_dynamoDbClient, loginAccountId, "");
if (result.isFail() && result.ErrorCode != ServerErrorCode.DynamoDbQueryNoMatchAttribute)
return Results.BadRequest(ApiResponseFactory.error(result.ErrorCode));
if (gameAccount == null)
{
return Results.Ok(new UGQMetaverseAccount
{
LoginAccountId = loginAccountId,
});
}
else
{
return Results.Ok(new UGQMetaverseAccount
{
LoginAccountId = loginAccountId,
UserGuid = gameAccount.UserGuid,
Nickname = gameAccount.Nickname,
});
}
}
}

200
UGQApiServer/Controllers/Admin/AdminController.cs Normal file
View File

@@ -0,0 +1,200 @@
using System.Globalization;
using System.Security.Claims;
using Amazon.Auth.AccessControlPolicy;
using Asp.Versioning;
using JwtRoleAuthentication.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using ServerCommon.UGQ.Models;
using Swashbuckle.AspNetCore.Annotations;
using UGQApiServer.Controllers.Common;
using UGQApiServer.Converter;
using UGQApiServer.Models;
using UGQDataAccess.Repository.Models;
using UGQDataAccess.Service;
using UGQDatabase.Models;
using UGQDataAccess.Logs;
using ServerBase;
namespace UGQApiServer.Controllers.Admin;
[ApiController]
[ApiVersion("1.0")]
[ApiExplorerSettings(GroupName = "admin")]
[Route("api/v{version:apiVersion}/[controller]")]
[UGQAdminApi]
public class AdminController : ControllerBase
{
AdminService _adminService;
TokenService _tokenService;
public AdminController(AdminService adminService, TokenService tokenService)
{
_adminService = adminService;
_tokenService = tokenService;
}
/// <summary>
/// 어드민 계정 추가
/// </summary>
// [Authorize(Roles = "Admin")]
[HttpPost]
[Route("signup")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(AdminSignupResponse))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> signup([FromBody] AdminSignupRequest request)
{
var entity = await _adminService.signup(request.Username, request.Password, UGQAccountRole.Service);
if (entity == null)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));
return Results.Ok(new AdminSignupResponse
{
Username = entity.Username,
Role = entity.Role,
});
}
/// <summary>
/// 어드민 로그인
/// </summary>
[HttpPost]
[Route("login")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(AdminLoginResponse))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> login([FromBody] AdminLoginRequest request)
{
var entity = await _adminService.login(request.Username, request.Password);
if(entity == null)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));
var accessToken = _tokenService.CreateAdminToken(entity.Username, entity.Role);
var refreshToken = _tokenService.GenerateRefreshToken();
DateTime refreshTokenExpryTime = DateTime.Now.AddDays(7);
if (await _adminService.saveRefreshToken(entity.Id, refreshToken, refreshTokenExpryTime) == null)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));
List<ILogInvoker> business_logs = [
new UgqApiAdminLoginBusinessLog(entity.Username),
];
var log_action = new LogActionEx(LogActionType.UgqApiAdminLogin);
UgqApiBusinessLogger.collectLogs(log_action, entity, business_logs);
return Results.Ok(new AdminLoginResponse
{
Username = entity.Username,
Role = entity.Role,
AccessToken = accessToken,
RefreshToken = refreshToken
});
}
/// <summary>
/// 어드민 패스워드 변경
/// </summary>
[Authorize]
[HttpPost]
[Route("change-password")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(AdminChangePaswordResponse))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> changePassowrd([FromBody] AdminChangePaswordRequest request)
{
var username = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Name)?.Value;
if (username == null)
return Results.Unauthorized();
var entity = await _adminService.changePassword(username, request.NewPassword);
if (entity == null)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));
return Results.Ok(new AdminChangePaswordResponse
{
});
}
/// <summary>
/// 어드민 패스워드 변경
/// </summary>
[HttpPost]
[Route("update-password")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(AdminUpdatePaswordResponse))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> updatePassowrd([FromBody] AdminUpdatePaswordRequest request)
{
var entity = await _adminService.changePassword(request.Username, request.NewPassword);
if (entity == null)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));
return Results.Ok(new AdminUpdatePaswordResponse
{
});
}
/// <summary>
/// 토큰 리프레쉬
/// </summary>
[HttpPost]
[Route("refresh")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(RefreshTokenResponse))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> Refresh([FromBody] RefreshTokenRequest request)
{
var principal = _tokenService.GetPrincipalFromExpiredToken(request.AccessToken);
var username = principal.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Name)?.Value;
if (username == null)
return Results.Unauthorized();
var entity = await _adminService.get(username);
if (entity is null)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));
if (entity.RefreshToken != request.RefreshToken || entity.RefreshTokenExpiryTime <= DateTime.Now)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqInvalidToken));
var accessToken = _tokenService.CreateAdminToken(entity.Username, entity.Role);
var refreshToken = _tokenService.GenerateRefreshToken();
if (await _adminService.saveRefreshToken(entity.Id, refreshToken, null) == null)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));
return Results.Ok(new RefreshTokenResponse
{
AccessToken = accessToken,
RefreshToken = refreshToken,
});
}
[Authorize]
[HttpPost]
[Route("logout")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK)]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> Logout()
{
var username = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Name)?.Value;
if (username == null)
return Results.Unauthorized();
if (await _adminService.deleteRefreshToken(username) == null)
return Results.BadRequest(ApiResponseFactory.error(ServerErrorCode.UgqNullEntity));
return Results.Ok();
}
}

164
UGQApiServer/Controllers/Admin/AdminMetaDataController.cs Normal file
View File

@@ -0,0 +1,164 @@
using System.Globalization;
using Asp.Versioning;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using ServerCommon;
using ServerCommon.UGQ.Models;
using Swashbuckle.AspNetCore.Annotations;
using UGQApiServer.Controllers.Common;
using UGQApiServer.Converter;
using UGQApiServer.Models;
using UGQDataAccess.Repository.Models;
using UGQDataAccess.Service;
using UGQApiServer.UGQData;
using ServerBase;
namespace UGQApiServer.Controllers.Admin;
[Authorize]
[ApiController]
[ApiVersion("1.0")]
[ApiExplorerSettings(GroupName = "admin")]
[Route("api/v{version:apiVersion}/Admin/MetaData")]
[ControllerName("MetaData")]
[UGQAdminApi]
[Authorize(Roles = "Admin,Service")]
public class AdminMetaDataController : ControllerBase
{
AccountService _accountService;
QuestEditorService _questEditorService;
MetaDataApi _metaDataApi;
QuestEditorApi _questEditorApi;
DynamoDbClient _dynamoDbClient;
public AdminMetaDataController(
AccountService accountService,
QuestEditorService questEditorService, MetaDataApi metaDataApi, QuestEditorApi questEditorApi, DynamoDbClient dynamoDbClient)
{
_accountService = accountService;
_questEditorService = questEditorService;
_metaDataApi = metaDataApi;
_questEditorApi = questEditorApi;
_dynamoDbClient = dynamoDbClient;
}
/////////////////////////////////////////////////////////////////////////////
// 메타데이터 어드민
/////////////////////////////////////////////////////////////////////////////
/// <summary>
/// 사용가능한 시작 npc 가져오기
/// </summary>
/// <param name="userGuid">유저 Guid</param>
/// <param name="pageNumber">페이지</param>
/// <param name="pageSize">pageSize (최대 100)</param>
[HttpGet]
[Route("assignable-npcs")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(UGQNpcMetaDataList))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> getAssignableNpcs([FromQuery] string userGuid, [FromQuery] int pageNumber, [FromQuery] int pageSize)
{
return await _metaDataApi.getAssignableNpcs(userGuid, pageNumber, pageSize);
}
/// <summary>
/// 사용가능한 task action 가져오기
/// </summary>
/// <param name="userGuid">유저 Guid</param>
/// <param name="pageNumber">페이지</param>
/// <param name="pageSize">pageSize (최대 100)</param>
[HttpGet]
[Route("available-task-actions")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(TaskActionList))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> getAvailableTaskActions([FromQuery] string userGuid, [FromQuery] int pageNumber, [FromQuery] int pageSize)
{
return await _metaDataApi.getAvailableTaskActions(pageNumber, pageSize);
}
/// <summary>
/// 액션의 입력가능한 값 리스트 얻어오기
/// </summary>
/// <remarks>
/// Task Action이 의상장착인 경우에 사용
/// </remarks>
/// <param name="userGuid">유저 Guid</param>
/// <param name="taskActionId">TaskAction의 아이디</param>
/// <param name="pageNumber">페이지</param>
/// <param name="pageSize">pageSize (최대 100)</param>
[HttpGet]
[Route("task-action-values")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(TaskActionValueList))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> getActionValues([FromQuery] string userGuid, [FromQuery] int taskActionId, [FromQuery] int pageNumber, [FromQuery] int pageSize)
{
return await _metaDataApi.getActionValues(userGuid, taskActionId, pageNumber, pageSize);
}
/// <summary>
/// 사용가능한 dialog 유형 가져오기
/// </summary>
/// <param name="userGuid">유저 Guid</param>
/// <param name="pageNumber">페이지</param>
/// <param name="pageSize">pageSize (최대 100)</param>
[HttpGet]
[Route("dialog-types")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(DialogTypeList))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> getDialogTypes([FromQuery] string userGuid, [FromQuery] int pageNumber, [FromQuery] int pageSize)
{
return await _metaDataApi.getDialogTypes(pageNumber, pageSize);
}
/// <summary>
/// dialog 유형에 따라 사용가능한 dialog 액션 가져오기
/// </summary>
/// <param name="userGuid">유저 Guid</param>
/// <param name="dialogType">dialog 유형</param>
/// <param name="pageNumber">페이지</param>
/// <param name="pageSize">pageSize (최대 100)</param>
[HttpGet]
[Route("dialog-actions")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(DialogActionList))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> getDialogActions([FromQuery] string userGuid, [FromQuery] int dialogType, [FromQuery] int pageNumber, [FromQuery] int pageSize)
{
return await _metaDataApi.getDialogActions(dialogType, pageNumber, pageSize);
}
/// <summary>
/// dialog 액션에 따라 입력 가능한 값 가져오기
/// </summary>
/// <param name="userGuid">유저 Guid</param>
/// <param name="dialogType">다이얼로그 타입</param>
/// <param name="dialogActionId">조건 종류</param>
/// <param name="pageNumber">페이지</param>
/// <param name="pageSize">pageSize (최대 100)</param>
[HttpGet]
[Route("dialog-action-values")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(DialogActionValueList))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> getDialogConditionValues([FromQuery] string userGuid, [FromQuery] int dialogType, [FromQuery] int dialogActionId, [FromQuery] int pageNumber, [FromQuery] int pageSize)
{
return await _metaDataApi.getDialogConditionValues(dialogType, dialogActionId, pageNumber, pageSize);
}
[HttpGet]
[Route("preset-images")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(DialogActionValueList))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> getPresetImages([FromQuery] string userGuid, [FromQuery] PresetKind kind, [FromQuery] PresetCategory category)
{
return await _metaDataApi.getPresetImages(kind, category);
}
}

341
UGQApiServer/Controllers/Admin/AdminQuestEditorController.cs Normal file
View File

@@ -0,0 +1,341 @@
using System.Globalization;
using System.Security.Claims;
using Asp.Versioning;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using ServerCommon;
using ServerCommon.UGQ.Models;
using Swashbuckle.AspNetCore.Annotations;
using UGQApiServer.Controllers.Common;
using UGQApiServer.Converter;
using UGQApiServer.Models;
using UGQDataAccess.Repository.Models;
using UGQDataAccess.Service;
using UGQDatabase.Models;
using ServerBase;
namespace UGQApiServer.Controllers.Admin;
[Authorize]
[ApiController]
[ApiVersion("1.0")]
[ApiExplorerSettings(GroupName = "admin")]
[Route("api/v{version:apiVersion}/Admin/QuestEditor")]
[ControllerName("QuestEditor")]
[UGQAdminApi]
[Authorize(Roles = "Admin,Service")]
public class AdminQuestEditorController : ControllerBase
{
const int MAX_PAGE_SIZE = 100;
AccountService _accountService;
QuestEditorService _questEditorService;
MetaDataApi _metaDataApi;
QuestEditorApi _questEditorApi;
DynamoDbClient _dynamoDbClient;
public AdminQuestEditorController(
AccountService accountService,
QuestEditorService questEditorService, MetaDataApi metaDataApi, QuestEditorApi questEditorApi, DynamoDbClient dynamoDbClient)
{
_accountService = accountService;
_questEditorService = questEditorService;
_metaDataApi = metaDataApi;
_questEditorApi = questEditorApi;
_dynamoDbClient = dynamoDbClient;
}
string? adminUsernameFromToken()
{
return User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Name)?.Value;
}
/// <summary>
/// 퀘스트 생성
/// </summary>
/// <remarks>
/// 빈 슬롯에 퀘스트 추가하는 경우에 호출
/// </remarks>
[HttpPost]
[Route("quest")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(UGQContent))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> addQuest([FromQuery] string userGuid, [FromBody] UGQSaveQuestModel saveQuestModel)
{
string? adminUsername = adminUsernameFromToken();
if(adminUsername == null)
return Results.Unauthorized();
return await _questEditorApi.addQuest(userGuid, saveQuestModel, adminUsername);
}
/// <summary>
/// 퀘스트 내용 가져오기
/// </summary>
/// <param name="questContentId">UGQSummary의 QuestContentId 값으로 api 호출</param>
/// <param name="userGuid">유저 Guid</param>
[HttpGet]
[Route("quest/{questContentId}")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(UGQContent))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> getQuest(string questContentId, [FromQuery] string userGuid)
{
return await _questEditorApi.getQuest(userGuid, questContentId);
}
/// <summary>
/// 편집 가능한 경우 퀘스트 내용 가져오기
/// </summary>
/// <remarks>
/// GET api와는 다르게 편집 불가능한 state인 경우에는 실패 리턴
/// </remarks>
/// <param name="questContentId">UGQSummary의 QuestContentId 값으로 api 호출</param>
/// <param name="userGuid">유저 Guid</param>
[HttpPost]
[Route("quest/{questContentId}/edit")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(UGQContent))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> editQuest(string questContentId, [FromQuery] string userGuid)
{
return await _questEditorApi.editQuest(userGuid, questContentId);
}
/// <summary>
/// 퀘스트 내용 업데이트
/// </summary>
/// <remarks>
/// Task의 DialogId는 업데이트하지 않음.
/// 편집 불가능 state인 경우 에러 리턴
/// </remarks>
/// <param name="questContentId">GET 또는 edit 에서 얻은 questContentId 사용</param>
/// <param name="userGuid">유저 Guid</param>
/// <param name="saveQuestModel">웹에서 입력한 값</param>
[HttpPut]
[Route("quest/{questContentId}")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(UGQContent))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> saveQuest(string questContentId, [FromQuery] string userGuid, [FromBody] UGQSaveQuestModel saveQuestModel)
{
return await _questEditorApi.saveQuest(userGuid, questContentId, saveQuestModel);
}
/// <summary>
/// 퀘스트 삭제
/// </summary>
/// <param name="questContentId">GET또는 edit 에서 얻은 questContentId 사용</param>
/// <param name="userGuid">유저 Guid</param>
[HttpDelete]
[Route("quest/{questContentId}")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK)]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> deleteQuest(string questContentId, [FromQuery] string userGuid)
{
return await _questEditorApi.deleteQuest(userGuid, questContentId);
}
/// <summary>
/// 퀘스트 이미지 업로드
/// </summary>
/// <remarks>
/// 세부사항은 정리 예정
/// </remarks>
/// <param name="questContentId">GET 또는 edit 에서 얻은 questContentId 사용</param>
/// <param name="userGuid">유저 Guid</param>
/// <param name="titleImageId">기본 이미지 인덱스</param>
/// <param name="bannerImageId">기본 이미지 인덱스</param>
/// <param name="title">업로드 파일</param>
/// <param name="banner">업로드 파일</param>
[HttpPost]
[Route("quest-image/{questContentId}")]
[Produces("application/json")]
public async Task<IResult> uploadQuestImage(string questContentId, [FromQuery] string userGuid, [FromQuery] int? titleImageId, [FromQuery] int? bannerImageId, IFormFile? title, IFormFile? banner)
{
return await _questEditorApi.uploadQuestImage(userGuid, questContentId, titleImageId ?? 0, bannerImageId ?? 0, title, banner);
}
/// <summary>
/// 퀘스트 타이틀 이미지 업로드
/// </summary>
/// <remarks>
/// 세부사항은 정리 예정
/// </remarks>
/// <param name="userGuid">유저 Guid</param>
/// <param name="questContentId">GET 또는 edit 에서 얻은 questContentId 사용</param>
/// <param name="titleImageId">기본 이미지 인덱스</param>
/// <param name="title">업로드 파일</param>
[HttpPost]
[Route("quest-title-image/{questContentId}")]
[Produces("application/json")]
public async Task<IResult> uploadQuestTitleImage(string questContentId, [FromQuery] string userGuid, [FromQuery] int? titleImageId, IFormFile? title)
{
return await _questEditorApi.uploadQuestImage(userGuid, questContentId, titleImageId ?? 0, 0, title, null);
}
/// <summary>
/// 퀘스트 배너 이미지 업로드
/// </summary>
/// <remarks>
/// 세부사항은 정리 예정
/// </remarks>
/// <param name="userGuid">유저 Guid</param>
/// <param name="questContentId">GET 또는 edit 에서 얻은 questContentId 사용</param>
/// <param name="bannerImageId">기본 이미지 인덱스</param>
/// <param name="banner">업로드 파일</param>
[HttpPost]
[Route("quest-banner-image/{questContentId}")]
[Produces("application/json")]
public async Task<IResult> uploadQuestBannerImage(string questContentId, [FromQuery] string userGuid, [FromQuery] int? bannerImageId, IFormFile? banner)
{
return await _questEditorApi.uploadQuestImage(userGuid, questContentId, 0, bannerImageId ?? 0, null, banner);
}
/// <summary>
/// 퀘스트 다이얼로그 가져오기
/// </summary>
/// <param name="questContentId">GET 또는 edit 에서 얻은 questContentId 사용</param>
/// <param name="dialogId">UGQContent.Tasks에 있는 DialogId 사용</param>
/// <param name="userGuid">유저 Guid</param>
[HttpGet]
[Route("quest-dialog/{questContentId}/{dialogId}")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(UGQDialog))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> getQuestDialog(string questContentId, string dialogId, [FromQuery] string userGuid)
{
return await _questEditorApi.getQuestDialog(userGuid, questContentId, dialogId);
}
/// <summary>
/// 퀘스트 다이얼로그 새로 생성
/// </summary>
/// <remarks>
/// Dialog 를 추가하고, UGQContent.Tasks의 DialogId를 저장
/// </remarks>
/// <param name="questContentId">GET 또는 edit 에서 얻은 questContentId 사용</param>
/// <param name="userGuid">유저 Guid</param>
/// <param name="taskIndex">몇번째 Task에 추가되는 다이얼로그인지. 0부터 시작</param>
/// <param name="questDialog">questDialog</param>
[HttpPost]
[Route("quest-dialog/{questContentId}")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(UGQAddQuestDialogResponse))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> addQuestDialog(string questContentId, [FromQuery] string userGuid, [FromQuery] int taskIndex, [FromBody] UGQSaveDialogModel questDialog)
{
return await _questEditorApi.addQuestDialog(userGuid, questContentId, taskIndex, questDialog);
}
/// <summary>
/// 퀘스트 다이얼로그 업데이트
/// </summary>
/// <param name="questContentId">GET 또는 edit 에서 얻은 questContentId 사용</param>
/// <param name="dialogId">UGQContent.Tasks에 있는 DialogId 사용</param>
/// <param name="userGuid">유저 Guid</param>
/// /// <param name="questDialog">questDialog</param>
[HttpPut]
[Route("quest-dialog/{questContentId}/{dialogId}")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(UGQDialog))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> saveQuestDialog(string questContentId, string dialogId, [FromQuery] string userGuid, [FromBody] UGQSaveDialogModel questDialog)
{
return await _questEditorApi.saveQuestDialog(userGuid, questContentId, dialogId, questDialog);
}
/// <summary>
/// 퀘스트 state 변경
/// </summary>
/// <remarks>
/// Test 로 변경 실패 시 ValidationErrorResponse로 응답
/// </remarks>
/// <param name="questContentId">GET또는 edit 에서 얻은 questContentId 사용</param>
/// <param name="userGuid">유저 Guid</param>
/// <param name="state">UGQState</param>
[HttpPatch]
[Route("quest-state/{questContentId}")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(UGQContent))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ValidationErrorResponse))]
public async Task<IResult> changeQuestState(string questContentId, [FromQuery] string userGuid, [FromQuery] QuestContentState state)
{
string? adminUsername = adminUsernameFromToken();
if (adminUsername == null)
return Results.Unauthorized();
return await _questEditorApi.changeQuestState(userGuid, questContentId, state, adminUsername);
}
[HttpGet]
[Route("creator-point-history")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(UGQCreatorPointHistoryResult))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> getCreatorPointHistory([FromQuery] string userGuid, [FromQuery] int pageNumber, [FromQuery] int pageSize, [FromQuery] CreatorPointHistoryKind kind, DateTimeOffset startDate, DateTimeOffset endDate)
{
return await _questEditorApi.getCreatorPointHistory(userGuid, pageNumber, pageSize, kind, startDate, endDate);
}
/// <summary>
/// 모든 퀘스트 보기
/// </summary>
[HttpGet]
[Route("all-quests")]
[Produces("application/json")]
public async Task<IResult> getAllQuests([FromQuery] QuestContentState state, [FromQuery] int pageNumber, [FromQuery] int pageSize, [FromQuery] string? searchText)
{
pageSize = Math.Clamp(pageSize, 1, MAX_PAGE_SIZE);
var result = await _questEditorService.getAllQuests(pageNumber, pageSize, state, searchText);
long allCount = await _questEditorService.getAllCount();
LangEnum langEnum = Culture.ToLangEnum(CultureInfo.CurrentCulture.Name);
return Results.Ok(new UQGAllQuestResponse
{
TotalCount = allCount,
PageNumber = result.PageNumber,
PageSize = result.PageSize,
TotalPages = result.TotalPages,
Summaries = result.Items.Select(x => x.ToDTO(langEnum)).ToList()
});
}
/// <summary>
/// 계정의 모든 퀘스트 보기
/// </summary>
[HttpGet]
[Route("account-quest")]
[Produces("application/json")]
[SwaggerResponse(StatusCodes.Status200OK, Type = typeof(List<UGQSummary>))]
[SwaggerResponse(StatusCodes.Status400BadRequest, Type = typeof(ApiErrorResponse))]
public async Task<IResult> getQuests([FromQuery] int pageNumber, [FromQuery] int pageSize, [FromQuery] string userGuid, [FromQuery] QuestContentState state, [FromQuery] string? searchText)
{
pageSize = Math.Clamp(pageSize, 1, MAX_PAGE_SIZE);
List<QuestContentEntity> all = await _questEditorService.getAll(userGuid);
var result = await _questEditorService.getSummaries(pageNumber, pageSize, userGuid, state, searchText);
LangEnum langEnum = Culture.ToLangEnum(CultureInfo.CurrentCulture.Name);
return Results.Ok(new UGQSummaryResponse
{
TotalCount = all.Count,
PageNumber = result.PageNumber,
PageSize = result.PageSize,
TotalPages = result.TotalPages,
Summaries = result.Items.Select(x => x.ToDTO(langEnum)).ToList(),
});
}
}