public static async Task <ValidatedView> RejectJoinRequest(int accountId, int targetId) { try { ClanMemberModel clanMemberModel = await Model <ClanMemberModel> .AsQueryable() .FirstOrDefault(x => x.AccountID == accountId); if (clanMemberModel == null || clanMemberModel.Role < ClanRole.VICE_LEADER) { return(ValidatedView.Invalid(ErrorCode.CLAN_ACCEPT_MEMBER_INSUFFICIENT_RIGHTS)); } ClanMemberPendingModel clanMemberPendingModel = await Model <ClanMemberPendingModel> .AsQueryable() .FirstOrDefault(x => x.AccountID == targetId && x.ClanID == clanMemberModel.ClanID); if (clanMemberPendingModel == null) { return(ValidatedView.Invalid(ErrorCode.CLAN_PENDING_DID_NOT_REQUEST)); } await Model <ClanMemberPendingModel> .AsCollection() .DeleteOneAsync(x => x.AccountID == targetId && x.ClanID == clanMemberModel.ClanID); return(ValidatedView.Valid()); } catch (Exception e) { GameContext.Logger.LogError(e); } return(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED)); }
public static async Task <ValidatedView> Delete(int clanId) { try { await Model <ClanMemberModel> .AsCollection() .DeleteManyAsync(x => x.ClanID == clanId); await Model <ClanMemberPendingModel> .AsCollection() .DeleteManyAsync(x => x.ClanID == clanId); await Model <ClanRelationModel> .AsCollection() .DeleteManyAsync(x => x.InitiatorID == clanId || x.TargetID == clanId); await Model <ClanRelationPendingModel> .AsCollection() .DeleteManyAsync(x => x.InitiatorID == clanId || x.TargetID == clanId); await Model <ClanLogModel> .AsCollection() .DeleteManyAsync(x => x.ClanID == clanId); await Model <ClanModel> .AsCollection() .DeleteOneAsync(x => x.ID == clanId); // Update emulator to remove from cache return(ValidatedView.Valid()); } catch (Exception e) { GameContext.Logger.LogError(e); } return(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED)); }
public static async Task <ValidatedView> CreateJoinRequest(int accountId, ClanJoinView clanJoinView) { if (!clanJoinView.IsValid(out string message)) { return(ValidatedView.Invalid(message)); } try { if (await Model <ClanMemberPendingModel> .AsQueryable() .Any(x => x.AccountID == accountId && x.ClanID == clanJoinView.ClanID)) { return(ValidatedView.Invalid(ErrorCode.CLAN_REQUEST_ALREADY_EXISTS)); } if (!await Model <ClanModel> .AsQueryable() .Any(x => x.ID == clanJoinView.ClanID)) { return(ValidatedView.Invalid(ErrorCode.CLAN_NOT_FOUND)); } await Model <ClanMemberPendingModel> .AsCollection().InsertOneAsync(new ClanMemberPendingModel { AccountID = accountId, ClanID = clanJoinView.ClanID, Message = clanJoinView.Description }); return(ValidatedView.Valid()); } catch (Exception e) { GameContext.Logger.LogError(e); } return(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED)); }
public static async Task <ValidatedView <AccountOverview> > RetrieveAccountOverview(int accountId) { try { // check if player is ingame if (GameManager.Players.TryGetValue(accountId, out PlayerController controller)) { AccountOverview accountOverview = Mapper <AccountView> .Map <AccountOverview>(controller.Account); accountOverview.ActiveShipID = controller.Account.CurrentHangar.ShipID; return(ValidatedView <AccountOverview> .Valid(accountOverview)); } AccountModel accountModel = await Model <AccountModel> .AsQueryable() .FirstOrDefault(x => x.ID == accountId); if (accountModel == null) { return(ValidatedView <AccountOverview> .Invalid(ErrorCode.ACCOUNT_NOT_FOUND)); } return(ValidatedView <AccountOverview> .Valid(Mapper <AccountModel> .Map <AccountOverview>(accountModel))); } catch (Exception e) { GameContext.Logger.LogError(e); } return(ValidatedView <AccountOverview> .Invalid(ErrorCode.OPERATION_FAILED)); }
public static async Task <ValidatedView <List <HangarOverview> > > RetrieveHangarOverviews(int accountId) { try { int?activeShipId = await Model <AccountModel> .AsQueryable() .Where(x => x.ID == accountId) .Select(x => (int?)x.ActiveShipID) .FirstOrDefault(); if (!activeShipId.HasValue) { return(ValidatedView <List <HangarOverview> > .Invalid(ErrorCode.NO_HANGAR_FOUND)); } return(ValidatedView <List <HangarOverview> > .Valid(await Model <HangarModel> .AsQueryable() .Where(x => x.AccountID == accountId) .Select(x => new HangarOverview { ShipID = x.ShipID, IsActive = x.ShipID == activeShipId.Value }).ToList() )); } catch (Exception e) { GameContext.Logger.LogError(e); } return(ValidatedView <List <HangarOverview> > .Invalid(ErrorCode.OPERATION_FAILED)); }
public static async Task <ValidatedView> UpdateHangar(int accountId, HangarView hangarView) { if (!hangarView.IsValid(out string message)) { return(ValidatedView.Invalid(message)); } try { HangarModel hangarModel = Mapper <HangarView> .Map(hangarView, new HangarModel { AccountID = accountId }); hangarModel.Configuration_1 = Mapper <ConfigurationView> .Map <Configuration>(hangarView.Configuration_1); hangarModel.Configuration_2 = Mapper <ConfigurationView> .Map <Configuration>(hangarView.Configuration_2); ReplaceOneResult result = await Model <HangarModel> .AsCollection() .ReplaceOneAsync(x => x.AccountID == accountId && x.ShipID == hangarView.ShipID, hangarModel); if (result.IsModifiedCountAvailable && result.ModifiedCount == 1) { return(ValidatedView.Valid()); } } catch (Exception e) { GameContext.Logger.LogError(e); } return(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED)); }
public static async Task <ValidatedView <ClanOverview> > RetrieveClanOverviewFromMember(int accountId) { try { ClanOverview clanOverview = null; ClanMemberModel clanMemberModel = await Model <ClanMemberModel> .AsQueryable().FirstOrDefault(x => x.AccountID == accountId); if (clanMemberModel != null) { ClanModel clanModel = await Model <ClanModel> .AsQueryable() .FirstOrDefault(x => x.ID == clanMemberModel.ClanID); if (clanModel == null) { GameContext.Logger.LogWarning($"Player [id: '{accountId}'] is member of a clan [id: '{clanMemberModel.ClanID}'] which does not even exist"); } else { clanOverview = Mapper <ClanModel> .Map <ClanOverview>(clanModel); } } return(ValidatedView <ClanOverview> .Valid(clanOverview)); } catch (Exception e) { GameContext.Logger.LogError(e); } return(ValidatedView <ClanOverview> .Invalid(ErrorCode.OPERATION_FAILED)); }
public static async Task <ValidatedView <GlobalRole> > Authenticate(AccountSessionView accountSessionView) { if (!accountSessionView.IsValid(out string message)) { return(ValidatedView <GlobalRole> .Invalid(message)); } try { if (!await Model <AccountSessionModel> .AsQueryable() .Any(x => x.AccountID == accountSessionView.AccountID && x.Token == accountSessionView.Token)) { return(ValidatedView <GlobalRole> .Invalid(ErrorCode.INVALID_SESSION)); } GlobalRole?role = await Model <AccountModel> .AsQueryable() .Where(x => x.ID == accountSessionView.AccountID) .Select(x => (GlobalRole?)x.Role).FirstOrDefault(); if (role.HasValue) { return(ValidatedView <GlobalRole> .Valid(role.Value)); } } catch (Exception e) { GameContext.Logger.LogError(e); } return(ValidatedView <GlobalRole> .Invalid(ErrorCode.OPERATION_FAILED)); }
public static async Task <ValidatedView <string> > RetrieveUsername(int accountId) { try { // check if player is ingame if (GameManager.Players.TryGetValue(accountId, out PlayerController controller)) { return(ValidatedView <string> .Valid(controller.Username)); } string username = await Model <AccountModel> .AsQueryable() .Where(x => x.ID == accountId) .Select(x => x.Username) .FirstOrDefault(); if (username == null) { return(ValidatedView <string> .Invalid(ErrorCode.ACCOUNT_NOT_FOUND)); } return(ValidatedView <string> .Valid(username)); } catch (Exception e) { GameContext.Logger.LogError(e); } return(ValidatedView <string> .Invalid(ErrorCode.OPERATION_FAILED)); }
public static async Task <ValidatedView <AccountClanView> > RetrieveSelf(int accountId) { try { ClanMemberModel clanMemberModel = await Model <ClanMemberModel> .AsQueryable().FirstOrDefault(x => x.AccountID == accountId); if (clanMemberModel != null) { ClanModel clanModel = await Model <ClanModel> .AsQueryable() .FirstOrDefault(x => x.ID == clanMemberModel.ClanID); if (clanModel == null) { GameContext.Logger.LogWarning($"Player [id: '{accountId}'] is member of a clan [id: '{clanMemberModel.ClanID}'] which does not even exist"); } else { AccountClanView accountClanView = new AccountClanView { Role = clanMemberModel.Role, JoinDate = clanMemberModel.CreationDate }; if (GameManager.Players.TryGetValue(clanMemberModel.AccountID, out PlayerController controller)) { accountClanView = Mapper <AccountView> .Map(controller.Account, accountClanView); accountClanView.ActiveShipID = controller.Account.CurrentHangar.ShipID; accountClanView.Online = true; accountClanView.Map = controller.HangarAssembly.Map.Name; Position actualPosition = controller.MovementAssembly.ActualPosition(); accountClanView.Position = (actualPosition.X, actualPosition.Y); } else { AccountModel accountModel = await Model <AccountModel> .AsQueryable() .FirstOrDefault(x => x.ID == clanMemberModel.AccountID); if (accountModel == null) { GameContext.Logger.LogCritical($"Player [id: '{clanMemberModel.AccountID}'] not found!"); return(ValidatedView <AccountClanView> .Invalid(ErrorCode.ACCOUNT_NOT_FOUND)); } accountClanView = Mapper <AccountModel> .Map(accountModel, accountClanView); } return(ValidatedView <AccountClanView> .Valid(accountClanView)); } } else { return(ValidatedView <AccountClanView> .Invalid(ErrorCode.CLAN_NOT_MEMBER)); } } catch (Exception e) { GameContext.Logger.LogError(e); } return(ValidatedView <AccountClanView> .Invalid(ErrorCode.OPERATION_FAILED)); }
public async Task <IActionResult> Post([FromBody] HangarDetailView hangarDetailView) { if (HttpContext.TryGetCurrentSession(out AccountSessionView accountSessionView)) { return(Ok(await HangarService.UpdateHangar(accountSessionView.AccountID, hangarDetailView))); } return(Ok(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED))); }
public async Task <IActionResult> AssingRole(int id, int role) { if (HttpContext.TryGetCurrentSession(out AccountSessionView accountSessionView)) { return(Ok(await ClanService.AssignRole(accountSessionView.AccountID, id, (ClanRole)role))); } return(Ok(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED))); }
public async Task <IActionResult> Get() { if (HttpContext.TryGetCurrentSession(out AccountSessionView accountSessionView)) { return(Ok(await HangarService.RetrieveHangarOverviews(accountSessionView.AccountID))); } return(Ok(ValidatedView <List <HangarOverview> > .Invalid(ErrorCode.OPERATION_FAILED))); }
public async Task <IActionResult> Get([FromQuery] string query, [FromQuery] int offset, [FromQuery] int count) { if (HttpContext.TryGetCurrentSession(out AccountSessionView accountSessionView)) { return(Ok(await ClanService.RetrieveClans(accountSessionView.AccountID, (query ?? "").ToLower(), offset, count))); } return(Ok(ValidatedView <EnumerableResultView <ClanView> > .Invalid(ErrorCode.OPERATION_FAILED))); }
public async Task <IActionResult> GetPending() { if (HttpContext.TryGetCurrentSession(out AccountSessionView accountSessionView)) { return(Ok(await ClanService.RetrievePendingFromMember(accountSessionView.AccountID))); } return(Ok(ValidatedView <List <AccountClanView> > .Invalid(ErrorCode.OPERATION_FAILED))); }
public async Task <IActionResult> Activate(int id) { if (HttpContext.TryGetCurrentSession(out AccountSessionView accountSessionView)) { return(Ok(await HangarService.ActivateHangar(accountSessionView.AccountID, id))); } return(Ok(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED))); }
public async Task <IActionResult> Leave() { if (HttpContext.TryGetCurrentSession(out AccountSessionView accountSessionView)) { return(Ok(await ClanService.Leave(accountSessionView.AccountID))); } return(Ok(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED))); }
public async Task <IActionResult> Post([FromBody] ClanCreateView clanCreateView) { if (HttpContext.TryGetCurrentSession(out AccountSessionView accountSessionView)) { return(Ok(await ClanService.CreateClan(accountSessionView.AccountID, clanCreateView))); } return(Ok(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED))); }
public async Task <IActionResult> RejectJoinRequest(int id) { if (HttpContext.TryGetCurrentSession(out AccountSessionView accountSessionView)) { return(Ok(await ClanService.RejectJoinRequest(accountSessionView.AccountID, id))); } return(Ok(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED))); }
public async Task <IActionResult> GetDiplomacies() { if (HttpContext.TryGetCurrentSession(out AccountSessionView accountSessionView)) { return(Ok(await ClanService.RetrieveDiplomacies(accountSessionView.AccountID))); } return(Ok(ValidatedView <List <ClanDiplomacyView> > .Invalid(ErrorCode.OPERATION_FAILED))); }
public static async Task <ValidatedView <AccountView> > RetrieveAccount(int accountId) { try { AccountModel accountModel = await Model <AccountModel> .AsQueryable() .FirstOrDefault(x => x.ID == accountId); if (accountModel == null) { return(ValidatedView <AccountView> .Invalid(ErrorCode.ACCOUNT_NOT_FOUND)); } AccountView accountView = Mapper <AccountModel> .Map <AccountView>(accountModel); accountView.GGRings = 64; ValidatedView <HangarView> validatedHangarView = await HangarService.RetrieveHangar(accountModel.ID, accountModel.ActiveShipID); if (!validatedHangarView.IsValid) { return(ValidatedView <AccountView> .Invalid(validatedHangarView.Message)); } accountView.CurrentHangar = validatedHangarView.Object; ValidatedView <VaultView> validatedVaultView = await RetrieveVault(accountId); if (!validatedVaultView.IsValid) { return(ValidatedView <AccountView> .Invalid(validatedVaultView.Message)); } accountView.Vault = validatedVaultView.Object; ValidatedView <CooldownView> validatedCooldownView = await RetrieveCooldown(accountId); if (!validatedCooldownView.IsValid) { return(ValidatedView <AccountView> .Invalid(validatedCooldownView.Message)); } accountView.Cooldown = validatedCooldownView.Object; accountView.Clan = new ClanOverview(); ValidatedView <ClanOverview> validatedClanOverview = await ClanService.RetrieveClanOverviewFromMember(accountId); if (validatedClanOverview.IsValid && validatedClanOverview.Object != null) { accountView.Clan = validatedClanOverview.Object; } return(ValidatedView <AccountView> .Valid(accountView)); } catch (Exception e) { GameContext.Logger.LogError(e); } return(ValidatedView <AccountView> .Invalid(ErrorCode.OPERATION_FAILED)); }
public static async Task <ValidatedView> UpdateAccount(AccountView accountView) { try { AccountModel accountModel = await Model <AccountModel> .AsQueryable() .Where(x => x.ID == accountView.ID).FirstOrDefault(); if (accountModel == null) { return(ValidatedView.Invalid(ErrorCode.ACCOUNT_NOT_FOUND)); } bool success = true; ReplaceOneResult result = await Model <AccountModel> .AsCollection() .ReplaceOneAsync(x => x.ID == accountView.ID, Mapper <AccountView> .Map(accountView, accountModel)); success &= result.IsModifiedCountAvailable && result.ModifiedCount == 1; ValidatedView validatedHangarResultView = await HangarService .UpdateHangar(accountView.ID, accountView.CurrentHangar); if (!validatedHangarResultView.IsValid) { GameContext.Logger.LogInformation($"Player: '{accountView.ID}': {validatedHangarResultView.Message}"); } success &= validatedHangarResultView.IsValid; ValidatedView validatedVaultResultView = await UpdateVault(accountView.ID, accountView.Vault); if (!validatedVaultResultView.IsValid) { GameContext.Logger.LogInformation($"Player: '{accountView.ID}': {validatedVaultResultView.Message}"); } success &= validatedVaultResultView.IsValid; ValidatedView validatedCooldownResultView = await UpdateCooldown(accountView.ID, accountView.Cooldown); if (!validatedCooldownResultView.IsValid) { GameContext.Logger.LogInformation($"Player: '{accountView.ID}': {validatedCooldownResultView.Message}"); } success &= validatedCooldownResultView.IsValid; if (success) { return(ValidatedView.Valid()); } } catch (Exception e) { GameContext.Logger.LogError(e); } return(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED)); }
public static async Task <ValidatedView> AcceptJoinRequest(int accountId, int targetId) { try { ClanMemberModel clanMemberModel = await Model <ClanMemberModel> .AsQueryable() .FirstOrDefault(x => x.AccountID == accountId); if (clanMemberModel == null || clanMemberModel.Role < ClanRole.VICE_LEADER) { return(ValidatedView.Invalid(ErrorCode.CLAN_ACCEPT_MEMBER_INSUFFICIENT_RIGHTS)); } if (await Model <ClanMemberModel> .AsQueryable().Count(x => x.ClanID == clanMemberModel.ClanID) >= 50) { return(ValidatedView.Invalid(ErrorCode.CLAN_FULL)); } ClanMemberPendingModel clanMemberPendingModel = await Model <ClanMemberPendingModel> .AsQueryable() .FirstOrDefault(x => x.AccountID == targetId && x.ClanID == clanMemberModel.ClanID); if (clanMemberPendingModel == null) { return(ValidatedView.Invalid(ErrorCode.CLAN_PENDING_DID_NOT_REQUEST)); } ClanMemberModel newClanMemberModel = new ClanMemberModel { ClanID = clanMemberModel.ClanID, AccountID = targetId }; await Model <ClanMemberPendingModel> .AsCollection().DeleteManyAsync(x => x.AccountID == targetId); await Model <ClanMemberModel> .AsCollection().InsertOneAsync(newClanMemberModel); if (GameManager.Get(accountId, out PlayerController controller)) { ValidatedView <ClanOverview> validatedView = await RetrieveClanOverviewFromMember(accountId); if (validatedView.IsValid) { controller.Account.Clan = validatedView.Object ?? new ClanOverview(); } ClanChangedCommand clanChangedCommand = PacketBuilder.ClanChangedCommand(controller); controller.Send(clanChangedCommand); controller.EntitesInRange(x => x.Send(clanChangedCommand)); } return(ValidatedView.Valid()); } catch (Exception e) { GameContext.Logger.LogError(e); } return(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED)); }
public static async Task <ValidatedView> CreateClan(int accountId, ClanCreateView clanCreateView) { if (!clanCreateView.IsValid(out string message)) { return(ValidatedView.Invalid(message)); } try { if (await Model <ClanMemberModel> .AsQueryable().Any(x => x.AccountID == accountId)) { GameContext.Logger.LogCritical($"Player [id: '{accountId}'] tries creating a clan while being member of another!"); return(ValidatedView.Invalid(ErrorCode.CLAN_ALREADY_MEMBER)); } if (await Model <ClanModel> .AsQueryable().Any(x => x.Name == clanCreateView.Name)) { return(ValidatedView.Invalid(ErrorCode.CLAN_NAME_ALREADY_IN_USE)); } if (await Model <ClanModel> .AsQueryable().Any(x => x.Tag == clanCreateView.Tag)) { return(ValidatedView.Invalid(ErrorCode.CLAN_TAG_ALREADY_IN_USE)); } ClanModel clanModel = Mapper <ClanCreateView> .Map <ClanModel>(clanCreateView); ClanMemberModel clanMemberModel = new ClanMemberModel { ClanID = clanModel.ID, AccountID = accountId, Role = ClanRole.LEADER }; await Model <ClanMemberPendingModel> .AsCollection().DeleteManyAsync(x => x.AccountID == accountId); await Model <ClanModel> .AsCollection().InsertOneAsync(clanModel); await Model <ClanMemberModel> .AsCollection().InsertOneAsync(clanMemberModel); if (GameManager.Get(accountId, out PlayerController controller)) { controller.Account.Clan = Mapper <ClanModel> .Map <ClanOverview>(clanModel); ClanChangedCommand clanChangedCommand = PacketBuilder.ClanChangedCommand(controller); controller.Send(clanChangedCommand); controller.EntitesInRange(x => x.Send(clanChangedCommand)); } return(ValidatedView.Valid()); } catch (Exception e) { GameContext.Logger.LogError(e); } return(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED)); }
public static async Task <ValidatedView <List <ClanDiplomacyView> > > RetrievePendingDiplomacies(int accountId) { try { ClanMemberModel clanMemberModel = await Model <ClanMemberModel> .AsQueryable().FirstOrDefault(x => x.AccountID == accountId); if (clanMemberModel != null) { ClanModel clanModel = await Model <ClanModel> .AsQueryable() .FirstOrDefault(x => x.ID == clanMemberModel.ClanID); if (clanModel == null) { return(ValidatedView <List <ClanDiplomacyView> > .Invalid(ErrorCode.CLAN_NOT_FOUND)); } else { List <ClanDiplomacyView> diplomacies = new List <ClanDiplomacyView>(); foreach (ClanRelationPendingModel clanRelationModel in await Model <ClanRelationPendingModel> .AsQueryable().Where(x => x.InitiatorID == clanModel.ID || x.TargetID == clanModel.ID) .ToList()) { ClanDiplomacyView clanDiplomacyView = Mapper <ClanRelationPendingModel> .Map <ClanDiplomacyView>(clanRelationModel); ValidatedView <ClanView> validatedView = await RetrieveClan(accountId, (clanRelationModel.InitiatorID == clanModel.ID ? clanRelationModel.TargetID : clanRelationModel.InitiatorID)); if (!validatedView.IsValid) { GameContext.Logger.LogWarning($"Failed to load pending diplomacy for {clanModel.ID}!"); continue; } clanDiplomacyView.Clan = validatedView.Object; diplomacies.Add(clanDiplomacyView); } return(ValidatedView <List <ClanDiplomacyView> > .Valid(diplomacies)); } } else { return(ValidatedView <List <ClanDiplomacyView> > .Invalid(ErrorCode.CLAN_NOT_MEMBER)); } } catch (Exception e) { GameContext.Logger.LogError(e); } return(ValidatedView <List <ClanDiplomacyView> > .Invalid(ErrorCode.OPERATION_FAILED)); }
public static async Task <ValidatedView> Register(AccountRegisterView accountRegisterView) { if (!accountRegisterView.IsValid(out string message)) { return(ValidatedView.Invalid(message)); } try { if (await Model <AccountModel> .AsQueryable() .Any(x => x.Username == accountRegisterView.Username)) { return(ValidatedView.Invalid(ErrorCode.USERNAME_ALREADY_IN_USE)); } AccountModel accountModel = new AccountModel(accountRegisterView.Username, accountRegisterView.Password, accountRegisterView.Email, accountRegisterView.Faction); int tries = 5; while (await Model <AccountModel> .AsQueryable().Any(x => x.ID == accountModel.ID)) { accountModel.ID = RandomGenerator.UniqueIdentifier(); if (tries-- == 0) { return(ValidatedView.Invalid(ErrorCode.PROBLEM_WHILE_CREATING_ACCOUNT)); } } AccountVaultModel accountVaultModel = new AccountVaultModel(accountModel.ID); List <HangarModel> hangarModels = accountVaultModel.Ships .Select(ship => new HangarModel(accountModel.ID, ship, accountModel.FactionID)) .ToList(); await Model <AccountModel> .AsCollection().InsertOneAsync(accountModel); await Model <AccountChatModel> .AsCollection().InsertOneAsync(new AccountChatModel(accountModel.ID)); await Model <AccountCooldownModel> .AsCollection().InsertOneAsync(new AccountCooldownModel(accountModel.ID)); await Model <AccountVaultModel> .AsCollection().InsertOneAsync(accountVaultModel); await Model <HangarModel> .AsCollection().InsertManyAsync(hangarModels); return(ValidatedView.Valid()); } catch (Exception e) { GameContext.Logger.LogError(e); } return(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED)); }
public static async Task <ValidatedView> UpdateHangar(int accountId, HangarDetailView hangarDetailView) { if (!hangarDetailView.IsValid(out string message)) { return(ValidatedView.Invalid(message)); } try { if (GameManager.Get(accountId, out PlayerController controller) && !controller.ZoneAssembly.CanEquip) { return(ValidatedView.Invalid(ErrorCode.EQUIPMENT_NOT_POSSIBLE)); } HangarModel hangarModel = await Model <HangarModel> .AsQueryable() .FirstOrDefault(x => x.AccountID == accountId && x.ShipID == hangarDetailView.ShipID); if (hangarModel == null) { return(ValidatedView <HangarView> .Invalid(ErrorCode.NO_HANGAR_FOUND)); } if (controller != null && controller.HangarAssembly.Ship.ID == hangarDetailView.ShipID) { HangarView hangarView = Mapper <HangarModel> .Map <HangarView>(hangarModel); hangarView.Configuration_1 = hangarDetailView.Configuration_1; hangarView.Configuration_2 = hangarDetailView.Configuration_2; UpdateHangarIngame(accountId, hangarView); } else { hangarModel.Configuration_1 = Mapper <ConfigurationView> .Map <Configuration>(hangarDetailView.Configuration_1); hangarModel.Configuration_2 = Mapper <ConfigurationView> .Map <Configuration>(hangarDetailView.Configuration_2); ReplaceOneResult result = await Model <HangarModel> .AsCollection() .ReplaceOneAsync(x => x.AccountID == accountId && x.ShipID == hangarDetailView.ShipID, hangarModel); } return(ValidatedView.Valid()); } catch (Exception e) { GameContext.Logger.LogError(e); } return(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED)); }
public static async Task <ValidatedView <ClanView> > RetrieveClanViewFromMember(int accountId) { try { ClanMemberModel clanMemberModel = await Model <ClanMemberModel> .AsQueryable().FirstOrDefault(x => x.AccountID == accountId); if (clanMemberModel != null) { return(await RetrieveClan(accountId, clanMemberModel.ClanID)); } return(ValidatedView <ClanView> .Valid(null)); } catch (Exception e) { GameContext.Logger.LogError(e); } return(ValidatedView <ClanView> .Invalid(ErrorCode.OPERATION_FAILED)); }
public static async Task <ValidatedView> RevokeJoinRequest(int accountId, int clanId) { try { var result = await Model <ClanMemberPendingModel> .AsCollection() .DeleteOneAsync(x => x.AccountID == accountId && x.ClanID == clanId); if (result.DeletedCount == 0) { return(ValidatedView.Invalid(ErrorCode.CLAN_FAILED_TO_REVOKE_REQUEST)); } return(ValidatedView.Valid()); } catch (Exception e) { GameContext.Logger.LogError(e); } return(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED)); }
public static async Task <ValidatedView> UpdateCooldown(int accountId, CooldownView cooldown) { try { ReplaceOneResult result = await Model <AccountCooldownModel> .AsCollection() .ReplaceOneAsync(x => x.AccountID == accountId, Mapper <CooldownView> .Map(cooldown, new AccountCooldownModel { AccountID = accountId })); if (result.IsModifiedCountAvailable && result.ModifiedCount == 1) { return(ValidatedView.Valid()); } } catch (Exception e) { GameContext.Logger.LogError(e); } return(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED)); }