public async Task <IActionResult> SetFirstOnetime([FromBody] SetFirstOnetime.Request req)
{
var db = PDBSM.PersonalDBContext(SelfHost.playerInfo.playerId);
var pbi = await db.PlayerBasicInformations.FindAsync(SelfHost.playerInfo.playerId);
if (pbi == null)
{
return(BuildErrorResponse(Error.LowCode.ServerInternalError));
}
if (0 != (pbi.initialLevel & PlayerInformation.InitialLevelFlg.Name))
{
return(BuildErrorResponse(Error.LowCode.BadRequest));
}
if (MasterData.CheckNgWords(req.playerName))
{
return(BuildErrorResponse(Error.LowCode.NgWord));
}
try
{
await Common2DB.PlayerNames.AddAsync(new PlayerName
{
playerName = req.playerName,
playerId = pbi.playerId,
});
await Common2DB.SaveChangesAsync();
}
catch //(Exception ex)
{
return(BuildErrorResponse(Error.LowCode.OverlapName));
}
pbi.playerName = req.playerName;
pbi.initialLevel |= PlayerInformation.InitialLevelFlg.Name;
await db.SaveChangesAsync();
await new Player(SelfHost.playerInfo.playerId).Invalidate();
var session = new Session(SelfHost.sessionId);
session.Model.initialLevel = pbi.initialLevel;
await session.SaveAsync();
return(Ok(new SetFirstOnetime.Response
{
initialLevel = pbi.initialLevel,
}));
}
public async Task <PutUnitTemporaryAvailabilityResponse> PutUnitTemporaryAvailability(string mobileSuitId, PutUnitTemporaryAvailabilityRequest request)
{
var response = new PutUnitTemporaryAvailabilityResponse();
await MasterDataLoader.LoadAsync();
var masterData = MasterDataLoader.LatestMasterData;
if (masterData == null)
{
// todo: error message
throw new Exception("master data not exist");
}
var mobileSuit = masterData.GetMobileSuit(mobileSuitId);
if (mobileSuit == null)
{
// todo: error message
throw new BadRequestException("unit not exist");
}
var temporarilyDisabledItem = await Common2DB.DisabledMobileSuits.Where(r => r.itemId == mobileSuit.itemId).FirstOrDefaultAsync();
if (request.isEnabledOnGmTool)
{
if (temporarilyDisabledItem != null)
{
Common2DB.DisabledMobileSuits.Remove(temporarilyDisabledItem);
await Common2DB.SaveChangesAsync();
}
}
else
{
if (temporarilyDisabledItem == null)
{
await Common2DB.DisabledMobileSuits.AddAsync(
new evolib.Databases.common2.DisabledMobileSuit
{
itemId = mobileSuit.itemId,
});
await Common2DB.SaveChangesAsync();
}
}
return(response);
}
public async Task <IActionResult> DisabledMobileSuit(string itemId, bool disabled)
{
await MasterDataLoader.LoadAsync();
var masterData = MasterDataLoader.LatestMasterData;
var item = masterData.GetItemFromItemId(itemId);
if (item == null ||
item.itemType != evolib.Item.Type.MobileSuit)
{
return(BadRequest());
}
var record = await Common2DB.DisabledMobileSuits
.Where(r => r.itemId == itemId)
.FirstOrDefaultAsync();
if (disabled)
{
if (record == null)
{
await Common2DB.DisabledMobileSuits.AddAsync(
new evolib.Databases.common2.DisabledMobileSuit
{
itemId = itemId,
}
);
await Common2DB.SaveChangesAsync();
}
}
else
{
if (record != null)
{
Common2DB.DisabledMobileSuits.Remove(record);
await Common2DB.SaveChangesAsync();
}
}
return(Ok(new { itemId, disabled }));
}
public async Task <IActionResult> SetPath([FromBody] SetPath.Request req)
{
var rec = await Common2DB.GenericDatas.FindAsync(GenericData.Type.TranslationTablePath);
if (rec == null)
{
rec = new GenericData();
rec.TranslationTableRecord(req.path);
await Common2DB.GenericDatas.AddAsync(rec);
}
else
{
rec.TranslationTableRecord(req.path);
}
await Common2DB.SaveChangesAsync();
await TranslationTable.LoadAsync(Common2DB);
return(Ok(req.path));
}
public async Task <IActionResult> SetMinMatchmakeEntriedPlayersNumber([FromBody] SetMinMatchmakeEntriedPlayersNumber.Request req)
{
var rec = await Common2DB.GenericDatas.FindAsync(GenericData.Type.MinMatchmakeEntriedPlayersNumber);
if (rec == null)
{
rec = new GenericData();
MinMatchmakeEntriedPlayersNumber.Push(rec, req.number.Value);
await Common2DB.GenericDatas.AddAsync(rec);
}
else
{
MinMatchmakeEntriedPlayersNumber.Push(rec, req.number.Value);
}
await Common2DB.SaveChangesAsync();
return(Ok(new SetMinMatchmakeEntriedPlayersNumber.Response
{
number = MinMatchmakeEntriedPlayersNumber.Pop(rec),
}));
}
public async Task <IActionResult> ResponseFriendRequest([FromBody] ResponseFriendRequest.Request req)
{
var res = new ResponseFriendRequest.Response();
res.resultCode = ProtocolModels.Friend.ResponseFriendRequest.Response.ResultCode.Unknown;
await DependJobManager.Enqueue(req.playerIdDst.Value, req.playerIdSrc.Value, async() =>
{
var personalDB = PDBSM.PersonalDBContext(req.playerIdDst.Value);
var friendRequest = await personalDB.FriendRequests.FindAsync(req.playerIdDst, req.playerIdSrc);
if (friendRequest == null)
{
res.resultCode = ProtocolModels.Friend.ResponseFriendRequest.Response.ResultCode.RequestNotFound;
return;
}
if (false == req.approved)
{
personalDB.FriendRequests.Remove(friendRequest);
await personalDB.SaveChangesAsync();
res.resultCode = ProtocolModels.Friend.ResponseFriendRequest.Response.ResultCode.Ok;
return;
}
var myFriendCnt = await Common2DB.Friends.CountAsync(r => r.playerIdL == req.playerIdDst || r.playerIdR == req.playerIdDst);
if (evolib.Social.MaxFriendCnt <= myFriendCnt)
{
res.resultCode = ProtocolModels.Friend.ResponseFriendRequest.Response.ResultCode.MyFriendsCntLimit;
return;
}
var hisFriendCnt = await Common2DB.Friends.CountAsync(r => r.playerIdL == req.playerIdSrc || r.playerIdR == req.playerIdSrc);
if (evolib.Social.MaxFriendCnt <= hisFriendCnt)
{
res.resultCode = ProtocolModels.Friend.ResponseFriendRequest.Response.ResultCode.HisFriendsCntLimit;
return;
}
personalDB.FriendRequests.Remove(friendRequest);
await personalDB.SaveChangesAsync();
var friend = Friend.Create(req.playerIdDst.Value, req.playerIdSrc.Value);
await Common2DB.Friends.AddAsync(friend);
await Common2DB.SaveChangesAsync();
res.resultCode = ProtocolModels.Friend.ResponseFriendRequest.Response.ResultCode.Ok;
//PUSH
var player = new Player(req.playerIdSrc.Value);
await player.FetchAsync();
if (await new Session(player.Model.sessionId).ExistsAsync())
{
await new ConnectionQueue(player.Model.sessionId).EnqueueAsync(new UpdateFriends());
}
});
return(Ok(res));
}
public async Task <IActionResult> RuptureFriend([FromBody] RuptureFriend.Request req)
{
var res = new RuptureFriend.Response();
res.resultCode = ProtocolModels.Friend.RuptureFriend.Response.ResultCode.Unknown;
await DependJobManager.Enqueue(req.playerIdSrc.Value, req.playerIdDst.Value, async() =>
{
var friend = Friend.Create(req.playerIdSrc.Value, req.playerIdDst.Value);
friend = await Common2DB.Friends.FindAsync(friend.playerIdL, friend.playerIdR);
if (null == friend)
{
res.resultCode = ProtocolModels.Friend.RuptureFriend.Response.ResultCode.NotFriend;
return;
}
Common2DB.Friends.Remove(friend);
await Common2DB.SaveChangesAsync();
res.resultCode = ProtocolModels.Friend.RuptureFriend.Response.ResultCode.Ok;
//{
// var r = new FavoriteFriend
// {
// playerId = req.playerIdSrc.Value,
// favoritePlayerId = req.playerIdDst.Value,
// };
// var db = pdbsm.PersonalDBContext(req.playerIdSrc.Value);
// db.FavoriteFriends.Attach(r);
// db.FavoriteFriends.Remove(r);
// await db.SaveChangesAsync();
//}
//{
// var r = new FavoriteFriend
// {
// playerId = req.playerIdDst.Value,
// favoritePlayerId = req.playerIdSrc.Value,
// };
// var db = pdbsm.PersonalDBContext(req.playerIdDst.Value);
// db.FavoriteFriends.Attach(r);
// db.FavoriteFriends.Remove(r);
// await db.SaveChangesAsync();
//}
//PUSH
var player = new Player(req.playerIdDst.Value);
await player.FetchAsync();
if (await new Session(player.Model.sessionId).ExistsAsync())
{
await new ConnectionQueue(player.Model.sessionId).EnqueueAsync(new UpdateFriends());
}
});
return(Ok(res));
}
public async Task <IActionResult> SetPath([FromBody] SetPath.Request req)
{
try
{
var requester = new DummyRequester();
var plainPath = req.path;
var resPlain = await requester.GetAsync(plainPath);
if (resPlain.StatusCode != System.Net.HttpStatusCode.OK)
{
return(BadRequest("Not Found: plain masterdata."));
}
var encryptPath = req.path.Substring(0, req.path.Length - Path.GetExtension(req.path).Length);
var resEncrypt = await requester.GetBinaryAsync(encryptPath);
if (resEncrypt.StatusCode != System.Net.HttpStatusCode.OK)
{
return(BadRequest("Not Found: encryption masterdata."));
}
var s3PutClient = new AmazonS3Client(
Amazon.RegionEndpoint.GetBySystemName(DeliveryDataInfo.S3BucketRegion)
);
var plainKey = evolib.Util.KeyGen.GetUrlSafe(64);
{
var putReq = new PutObjectRequest()
{
BucketName = DeliveryDataInfo.S3BucketName,
Key = plainKey,
InputStream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(resPlain.Payload)),
};
var putRes = await s3PutClient.PutObjectAsync(putReq);
}
var encryptkey = evolib.Util.KeyGen.GetUrlSafe(32);
{
var putReq = new PutObjectRequest()
{
BucketName = DeliveryDataInfo.S3BucketName,
Key = encryptkey,
InputStream = new MemoryStream(resEncrypt.Payload),
};
var putRes = await s3PutClient.PutObjectAsync(putReq);
}
var masterData = await MasterDataLoader.ParseAsync(resPlain.Payload, "", "");
var masterDataPath = new MasterDataPath();
masterDataPath.Model.pathSrc = req.path;
masterDataPath.Model.s3KeyPlain = plainKey;
masterDataPath.Model.pathPlain = $"https://{DeliveryDataInfo.CfDomainName }/{plainKey}";
masterDataPath.Model.pathEncrypt = $"https://{DeliveryDataInfo.CfDomainName }/{encryptkey}";
masterDataPath.Model.updateDate = System.DateTime.UtcNow;
masterDataPath.Model.version = masterData.VersionStr;
await masterDataPath.SaveAsync();
System.Action <GenericData> pushRecord = (record) =>
{
record.MasterDataPathRecord(
req.path,
plainKey,
$"https://{DeliveryDataInfo.CfDomainName }/{plainKey}",
$"https://{DeliveryDataInfo.CfDomainName }/{encryptkey}",
masterData.VersionStr
);
};
var rec = await Common2DB.GenericDatas.FindAsync(GenericData.Type.MasterDataPath);
if (rec == null)
{
rec = new GenericData();
pushRecord(rec);
await Common2DB.GenericDatas.AddAsync(rec);
}
else
{
pushRecord(rec);
}
await Common2DB.SaveChangesAsync();
var res = new SetPath.Response();
return(Ok(res));
}
catch (System.Exception e)
{
return(BadRequest("Failed to update."));
}
}
public async Task <IActionResult> SetPath(string path, string pathEncrypt)
{
try
{
if (string.IsNullOrEmpty(pathEncrypt))
{
pathEncrypt = path.Substring(0, path.Length - Path.GetExtension(path).Length);
}
var requester = new DummyRequester();
var response = await requester.GetAsync(pathEncrypt);
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
return(BadRequest("param: pathEncrypt is invalid."));
}
response = await requester.GetAsync(path);
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
return(BadRequest("param: path is invalid."));
}
var masterData = await MasterDataLoader.ParseAsync(response.Payload, "", "");
var masterDataPath = new MasterDataPath();
masterDataPath.Model.pathSrc = path;
masterDataPath.Model.s3KeyPlain = "";
masterDataPath.Model.pathPlain = path;
masterDataPath.Model.pathEncrypt = pathEncrypt;
masterDataPath.Model.updateDate = System.DateTime.UtcNow;
masterDataPath.Model.version = masterData.VersionStr;
await masterDataPath.SaveAsync();
System.Action <GenericData> pushRecord = (record) =>
{
record.MasterDataPathRecord(
path,
"",
path,
pathEncrypt,
masterData.VersionStr
);
};
var rec = await Common2DB.GenericDatas.FindAsync(GenericData.Type.MasterDataPath);
if (rec == null)
{
rec = new GenericData();
pushRecord(rec);
await Common2DB.GenericDatas.AddAsync(rec);
}
else
{
pushRecord(rec);
}
await Common2DB.SaveChangesAsync();
}
catch (System.Exception ex)
{
return(BadRequest(ex.Message));
}
var res = new SetPath.Response();
return(Ok(res));
}
public async Task <PutResetAccountResponse> PutResetAccount(long playerId)
{
var response = new PutResetAccountResponse();
var registeredAccount = await Common1DB.PlayerIds
.Where(r => r.playerId == playerId)
.Join(Common1DB.Accounts,
p => new { AccountType = p.accountType, p.account },
a => new { AccountType = a.type, a.account },
(p, a) => a)
.FirstOrDefaultAsync();
if (registeredAccount == null)
{
// todo: error message
throw new NotFoundException("account not exist");
}
{ //Personal
var personalDB = PDBSM.PersonalDBContext(registeredAccount.playerId);
//{
// var list = await personalDB.XXXX.Where(r => r.playerId == registeredAccount.playerId).ToListAsync();
// personalDB.XXXX.RemoveRange(list);
//}
{
var list = await personalDB.PlayerBasicInformations.Where(r => r.playerId == registeredAccount.playerId).ToListAsync();
personalDB.PlayerBasicInformations.RemoveRange(list);
}
{
var list = await personalDB.PlayerBattleInformations.Where(r => r.playerId == registeredAccount.playerId).ToListAsync();
personalDB.PlayerBattleInformations.RemoveRange(list);
}
{
var list = await personalDB.OwnMobileSuitSettings.Where(r => r.playerId == registeredAccount.playerId).ToListAsync();
personalDB.OwnMobileSuitSettings.RemoveRange(list);
}
{
var list = await personalDB.OwnVoicePackSettings.Where(r => r.playerId == registeredAccount.playerId).ToListAsync();
personalDB.OwnVoicePackSettings.RemoveRange(list);
}
{
var list = await personalDB.ItemInventories.Where(r => r.playerId == registeredAccount.playerId).ToListAsync();
personalDB.ItemInventories.RemoveRange(list);
}
{
var list = await personalDB.AssetsInventories.Where(r => r.playerId == registeredAccount.playerId).ToListAsync();
personalDB.AssetsInventories.RemoveRange(list);
}
{
var list = await personalDB.FavoriteFriends.Where(r => r.playerId == registeredAccount.playerId).ToListAsync();
personalDB.FavoriteFriends.RemoveRange(list);
}
{
var list = await personalDB.FriendRequests.Where(r => r.playerIdSrc == registeredAccount.playerId).ToListAsync();
personalDB.FriendRequests.RemoveRange(list);
}
{
var list = await personalDB.MutePlayers.Where(r => r.playerIdSrc == registeredAccount.playerId).ToListAsync();
personalDB.MutePlayers.RemoveRange(list);
}
{
var list = await personalDB.AppOptions.Where(r => r.playerId == registeredAccount.playerId).ToListAsync();
personalDB.AppOptions.RemoveRange(list);
}
{
var list = await personalDB.MobileSuitOptions.Where(r => r.playerId == registeredAccount.playerId).ToListAsync();
personalDB.MobileSuitOptions.RemoveRange(list);
}
{
var list = await personalDB.DateLogs.Where(r => r.playerId == registeredAccount.playerId).ToListAsync();
personalDB.DateLogs.RemoveRange(list);
}
{
var list = await personalDB.ReplayUserHistory.Where(r => r.playerId == registeredAccount.playerId).ToListAsync();
personalDB.ReplayUserHistory.RemoveRange(list);
}
{
var list = await personalDB.BattlePasses.Where(r => r.playerId == registeredAccount.playerId).ToListAsync();
personalDB.BattlePasses.RemoveRange(list);
}
{
var list = await personalDB.CareerRecords.Where(r => r.playerId == registeredAccount.playerId).ToListAsync();
personalDB.CareerRecords.RemoveRange(list);
}
await personalDB.SaveChangesAsync();
}
{ //Common3
//await Common3DB.SaveChangesAsync();
}
{ //Common2
{
var list = await Common2DB.Friends.Where(r => r.playerIdL == registeredAccount.playerId ||
r.playerIdR == registeredAccount.playerId).ToListAsync();
Common2DB.Friends.RemoveRange(list);
}
await Common2DB.SaveChangesAsync();
}
{ //Common1
{
var rec = new evolib.Databases.common1.PlayerId
{
playerId = registeredAccount.playerId
};
Common1DB.PlayerIds.Attach(rec);
Common1DB.PlayerIds.Remove(rec);
}
{
Common1DB.Accounts.Remove(registeredAccount);
}
await Common1DB.SaveChangesAsync();
}
return(response);
}
