public void HandleRequest(IRequest request)
{
using (var scope = Db.CreateTransaction())
{
var corpName = request.Data.GetOrDefault <string>(k.name).Trim();
var nick = request.Data.GetOrDefault <string>(k.nick).Trim();
var character = request.Session.Character;
//get corp and role check
var corporation = character.GetCorporation().CheckAccessAndThrowIfFailed(character, CorporationRole.CEO, CorporationRole.DeputyCEO);
(corporation is PrivateCorporation).ThrowIfFalse(ErrorCodes.CorporationMustBePrivate);
//nick check
nick.Length.ThrowIfGreater(6, ErrorCodes.CorporationNickTooLong);
nick.Length.ThrowIfLess(2, ErrorCodes.CorporationNickTooShort);
nick.AllowExtras().ThrowIfFalse(ErrorCodes.CorporationNickNotAllowedCharacters);
string.IsNullOrEmpty(nick).ThrowIfTrue(ErrorCodes.CorporationNickNotDefined);
//name check
corpName.Length.ThrowIfGreater(128, ErrorCodes.CorporationNameTooLong);
corpName.Length.ThrowIfLessOrEqual(3, ErrorCodes.CorporationNameTooShort);
corpName.AllowExtras().ThrowIfFalse(ErrorCodes.CorporationNameNotAllowedCharacters);
string.IsNullOrEmpty(corpName).ThrowIfTrue(ErrorCodes.CorporationNameNotDefined);
//existence check
Corporation.IsNameOrNickTaken(corpName, nick).ThrowIfTrue(ErrorCodes.NameTaken);
//write OLD name to alias history
Corporation.WriteRenameHistory(corporation.Eid, character, corporation.CorporationName, corporation.CorporationNick);
var product = _mtProductHelper.GetByAccountTransactionType(AccountTransactionType.CorporationRename);
var account = _accountManager.Repository.Get(request.Session.AccountId).ThrowIfNull(ErrorCodes.AccountNotFound);
var wallet = _accountManager.GetWallet(account, AccountTransactionType.CorporationRename);
wallet.Balance -= product.price;
var e = new AccountTransactionLogEvent(account, AccountTransactionType.CorporationRename)
{
Credit = wallet.Balance, CreditChange = -product.price
};
_accountManager.LogTransaction(e);
corporation.SetName(corpName, nick);
_accountRepository.Update(account);
Transaction.Current.OnCommited(() =>
{
//force cache reload
CorporationData.RemoveFromCache(corporation.Eid);
//send to members
var corpInfo = corporation.GetInfoDictionaryForMember(character);
Message.Builder.SetCommand(Commands.CorporationGetMyInfo).WithData(corpInfo).ToCharacters(corporation.GetCharacterMembers()).Send();
});
scope.Complete();
}
}
public void HandleRequest(IRequest request)
{
using (var scope = Db.CreateTransaction())
{
var account = _accountManager.Repository.Get(request.Session.AccountId).ThrowIfNull(ErrorCodes.AccountNotFound);
var product = _mtProductHelper.GetByAccountTransactionType(AccountTransactionType.EpBoost);
var wallet = _accountManager.GetWallet(account, AccountTransactionType.EpBoost);
wallet.Balance -= product.price;
var e = new AccountTransactionLogEvent(account, AccountTransactionType.EpBoost)
{
Credit = wallet.Balance, CreditChange = -product.price
};
_accountManager.LogTransaction(e);
var currentValidUntil = account.ValidUntil ?? DateTime.MaxValue;
if (currentValidUntil == DateTime.MaxValue || currentValidUntil < DateTime.Now)
{
//validuntil is NULL -- never purchased an EP boost
//validUntil is in the past
var startTime = DateTime.Now;
var endTime = DateTime.Now.AddDays(EP_BOOST_PERIOD_LENGTH_IN_DAYS);
_accountManager.ExtensionSubscriptionStart(account, startTime, endTime);
account.ValidUntil = endTime;
}
else
{
//validUntil > now -- is in the future
//extend validuntil
var extendedValidUntil = currentValidUntil.AddDays(EP_BOOST_PERIOD_LENGTH_IN_DAYS);
_accountManager.ExtensionSubscriptionExtend(account, extendedValidUntil);
account.ValidUntil = extendedValidUntil;
}
//for stats and stuff
account.PayingCustomer = true;
_accountRepository.Update(account);
Transaction.Current.OnCommited(() =>
{
var info = new Dictionary <string, object>
{
{ k.validUntil, account.ValidUntil }
};
Message.Builder.FromRequest(request).WithData(info).Send();
});
scope.Complete();
}
}
public override void Activate(Account account, Character character)
{
AccountManager.AddExtensionPoints(account, ED.Options.ExtensionPoints);
var e = new AccountTransactionLogEvent(account, AccountTransactionType.EPRedeem)
{
Eid = Eid,
Definition = Definition
};
AccountManager.LogTransaction(e);
}
public override void Activate(Account account, Character character)
{
var wallet = AccountManager.GetWallet(account, AccountTransactionType.IceRedeem);
wallet.Balance += ICE_CREDIT_VALUE;
var e = new AccountTransactionLogEvent(account, AccountTransactionType.IceRedeem)
{
Credit = wallet.Balance,
CreditChange = ICE_CREDIT_VALUE,
Eid = Eid
};
AccountManager.LogTransaction(e);
}
public override void Activate(Account account, Character character)
{
var wallet = AccountManager.GetWallet(account, AccountTransactionType.CreditRedeem);
wallet.Balance += ED.Options.Credit;
var e = new AccountTransactionLogEvent(account, AccountTransactionType.CreditRedeem)
{
Credit = wallet.Balance,
CreditChange = ED.Options.Credit,
Eid = Eid
};
AccountManager.LogTransaction(e);
}
public void HandleRequest(IRequest request)
{
using (var scope = Db.CreateTransaction())
{
var account = _accountManager.Repository.Get(request.Session.AccountId).ThrowIfNull(ErrorCodes.AccountNotFound);
//the locked ep the user wants to release
var amount = request.Data.GetOrDefault <int>(k.amount);
(amount <= 0).ThrowIfTrue(ErrorCodes.WTFErrorMedicalAttentionSuggested);
var currentlockedEp = _accountManager.GetLockedEpByAccount(account);
(amount > currentlockedEp).ThrowIfTrue(ErrorCodes.InputTooHigh);
var creditCost = (int)Math.Ceiling(amount / 60.0);
var wallet = _accountManager.GetWallet(account, AccountTransactionType.FreeLockedEp);
wallet.Balance -= creditCost;
var e = new AccountTransactionLogEvent(account, AccountTransactionType.FreeLockedEp)
{
Credit = wallet.Balance, CreditChange = -1 * creditCost
};
_accountManager.LogTransaction(e);
//inject VS delete
//delete version
_accountManager.FreeLockedEp(account, amount);
_accountRepository.Update(account);
var character = request.Session.Character;
var data = _accountManager.GetEPData(account, character);
Message.Builder.FromRequest(request).WithData(data).Send();
scope.Complete();
}
}
public override void Activate(Account account, Character character)
{
if (_sparkHelper.IsSparkUnlocked(character, ED.Options.SparkID))
{
throw new PerpetuumException(ErrorCodes.SparkAlreadyUnlocked);
}
_sparkHelper.UnlockSpark(character, ED.Options.SparkID);
var e = new AccountTransactionLogEvent(account, AccountTransactionType.SparkRedeem)
{
Eid = Eid
};
AccountManager.LogTransaction(e);
Transaction.Current.OnCommited(() =>
{
_sparkHelper.CreateSparksListMessage(character).ToCharacter(character).Send();
});
}
public void HandleRequest(IRequest request)
{
using (var scope = Db.CreateTransaction())
{
var account = _accountManager.Repository.Get(request.Session.AccountId).ThrowIfNull(ErrorCodes.AccountNotFound);
var character = Character.Get(request.Data.GetOrDefault <int>(k.characterID));
if (character == Character.None)
{
throw new PerpetuumException(ErrorCodes.CharacterNotFound);
}
//only characters that belong to the issuers account
if (character.AccountId != account.Id)
{
throw new PerpetuumException(ErrorCodes.AccessDenied);
}
(character.IsDocked).ThrowIfFalse(ErrorCodes.CharacterHasToBeDocked);
var product = _mtProductHelper.GetByAccountTransactionType(AccountTransactionType.ExtensionReset);
var wallet = _accountManager.GetWallet(account, AccountTransactionType.ExtensionReset);
wallet.Balance -= product.price;
var e = new AccountTransactionLogEvent(account, AccountTransactionType.ExtensionReset)
{
Credit = wallet.Balance,
CreditChange = -product.price
};
_accountManager.LogTransaction(e);
_accountRepository.Update(account);
//current extensions
var extensionCollection = character.GetExtensions();
//default extensions
var defaultExtensionHandler = new CharacterDefaultExtensionHelper(character);
foreach (var extension in extensionCollection)
{
//returns 0 if the extension is not starter extension
//returns the minimum level if the extension is starter
int newLevel;
defaultExtensionHandler.IsStartingExtension(extension, out newLevel);
var resultExtension = new Extension(extension.id, newLevel);
character.SetExtension(resultExtension);
}
character.DeleteAllSpentPoints();
//ezt nem csinalja, csak nyersen reseteli az extensionoket
/*
* ExtensionHelper.DeleteAllNonForeverPenaltyPoints(character);
*/
// %%% itt hagytuk abba
Message.Builder.FromRequest(request).WithOk().Send();
scope.Complete();
}
}
public void HandleRequest(IRequest request)
{
using (var scope = Db.CreateTransaction())
{
var account = _accountManager.Repository.Get(request.Session.AccountId).ThrowIfNull(ErrorCodes.AccountNotFound);
var nick = request.Data.GetOrDefault <string>(k.nick).Trim();
var targetCharacter = Character.Get(request.Data.GetOrDefault <int>(k.characterID));
if (targetCharacter == Character.None)
{
throw new PerpetuumException(ErrorCodes.CharacterNotFound);
}
//only characters that belong to the issuers account
if (targetCharacter.AccountId != account.Id)
{
throw new PerpetuumException(ErrorCodes.AccessDenied);
}
//sosem fordulhat elo, de azert megis
if (!targetCharacter.IsActive)
{
throw new PerpetuumException(ErrorCodes.AccessDenied);
}
//check nick and other conditions
Character.CheckNickAndThrowIfFailed(nick, request.Session.AccessLevel, account);
//withdrw credit
var product = _mtProductHelper.GetByAccountTransactionType(AccountTransactionType.CharacterRename);
var wallet = _accountManager.GetWallet(account, AccountTransactionType.CharacterRename);
wallet.Balance -= product.price;
var e = new AccountTransactionLogEvent(account, AccountTransactionType.CharacterRename)
{
Credit = wallet.Balance,
CreditChange = -product.price
};
_accountManager.LogTransaction(e);
//do the heavy lifting
var oldNick = targetCharacter.Nick;
targetCharacter.Nick = nick;
//log
Db.Query().CommandText("INSERT dbo.characternickhistory ( characterid, accountid, nick ) VALUES ( @characterid, @accountid, @nick )")
.SetParameter("@characterid", targetCharacter.Id)
.SetParameter("@accountid", account.Id)
.SetParameter("@nick", oldNick)
.ExecuteNonQuery();
_accountRepository.Update(account);
Transaction.Current.OnCommited(() =>
{
var character = request.Session.Character;
if (_characterProfiles is CachedReadOnlyRepository <int, CharacterProfile> cached)
{
cached.Remove(character.Id);
}
var profile = character.GetFullProfile();
Message.Builder
.FromRequest(request)
.SetCommand(Commands.CharacterGetMyProfile)
.WithData(profile).Send();
});
scope.Complete();
}
}
public void HandleRequest(IRequest request)
{
using (var scope = Db.CreateTransaction())
{
var account = _accountManager.Repository.Get(request.Session.AccountId).ThrowIfNull(ErrorCodes.AccountNotFound);
var character = request.Session.Character;
var extensionId = request.Data.GetOrDefault <int>(k.extensionID);
var isAdmin = request.Session.AccessLevel.IsAdminOrGm();
//only docked
character.IsDocked.ThrowIfFalse(ErrorCodes.CharacterHasToBeDocked);
var extensionInfo = _extensionReader.GetExtensionByID(extensionId).ThrowIfNull(ErrorCodes.ExtensionNotFound);
//validate extension
var currentExtensionLevel = character.GetExtensionLevel(extensionId);
//this extension is not learnt for this character yet
currentExtensionLevel.ThrowIfLessOrEqual(0, ErrorCodes.ItemNotFound);
var defaultExtensionHandler = new CharacterDefaultExtensionHelper(character);
if (defaultExtensionHandler.IsStartingExtension(extensionInfo, out int minimumLevel))
{
(currentExtensionLevel == minimumLevel).ThrowIfTrue(ErrorCodes.ExtensionMinimumReached);
}
if (currentExtensionLevel == 1)
{
//extension is getting deleted
}
// these extensions need the current one on a specific level as a requirement
var prerequiredOf = _extensionReader.GetPrerequiredExtensionsOf(extensionId);
var learntExtensions = character.GetExtensions().ToList();
foreach (var requiresExtension in prerequiredOf)
{
foreach (var learntExtension in learntExtensions)
{
if (learntExtension.id != requiresExtension.id)
{
continue;
}
if (requiresExtension.level < currentExtensionLevel)
{
continue;
}
//extension cant be downgraded because
Logger.DebugWarning($"extension:{_extensionReader.GetExtensionName(requiresExtension.id)} requires:{_extensionReader.GetExtensionName(extensionId)} on level:{requiresExtension.level} current level:{currentExtensionLevel} requests:{requiresExtension.id}->this:{extensionId}");
throw PerpetuumException.Create(ErrorCodes.ExtensionIsRequired)
.SetData("thisNeeds", requiresExtension.id)
.SetData("level", requiresExtension.level)
.SetData("downgrading", extensionId);
}
}
var spentId = 0;
var spentPoints = 0;
character.GetTableIndexForAccountExtensionSpent(extensionId, currentExtensionLevel, ref spentId, ref spentPoints);
if (spentId == 0)
{
isAdmin.ThrowIfFalse(ErrorCodes.ExtensionLevelCantBeRemoved);
}
//add negative spent points
var spentPoints1 = -1 * spentPoints;
var extensionLevel = currentExtensionLevel - 1;
_accountManager.AddExtensionPointsSpent(account, character, spentPoints1, extensionId, extensionLevel);
//insert log
_accountManager.InsertExtensionRemoveLog(account, character, extensionId, currentExtensionLevel, spentPoints);
character.SetExtension(new Extension(extensionId, currentExtensionLevel - 1));
var price = spentPoints / 60;
//var priceBase = AccountWallet.GetProductPrice(AccountTransactionType.extensionRemoveLevel.ToString().ToLower());
//var price = currentExtensionLevel * priceBase; //current level * base price
var wallet = _accountManager.GetWallet(account, AccountTransactionType.ExtensionRemoveLevel);
wallet.Balance -= price;
var e = new AccountTransactionLogEvent(account, AccountTransactionType.ExtensionRemoveLevel)
{
Credit = wallet.Balance, CreditChange = -price
};
_accountManager.LogTransaction(e);
_accountRepository.Update(account);
var result = _accountManager.GetEPData(account, character);
//The amount of EP gained
result.Add("pointsReturned", spentPoints);
result.Add(k.extensionID, extensionId);
result.Add(k.extensionLevel, currentExtensionLevel - 1);
Message.Builder.FromRequest(request).WithData(result).Send();
scope.Complete();
}
}
