void ConsumeTransaction(CommitItems commitItems, TransactionItem <DataTransaction> dataItem)
{
var transaction = dataItem.Transaction;
var transactionId = transaction.TransactionId;
if (transactionId <= LastProcessedTransactionId)
{
return;
}
if (transaction.TargetChainId == ChainId)
{
var accountId = transaction.AccountId;
var account = GetDataAccount(accountId);
var type = transaction.TransactionType;
if (type == DataTransactionTypes.Attachement)
{
var attTransaction = transaction as AttachementDataTransaction;
Attachements.StoreAttachements(attTransaction);
}
ConsumeTransactionFeatures((ushort)DataTransactionTypes.FeatureRequest, transaction, account, commitItems);
}
}
public override void ConsumeTransactionFeature(CommitItems commitItems, Commit commit, Transaction transaction, FeatureAccount featureAccount, FeatureData featureData)
{
var targetData = featureData as TransactionTarget;
for (var i = 0; i < targetData.Targets.Count; i++)
{
var targetTransactionId = targetData.Targets[i];
var targetedCount = targetData._targetedTransactionsCount[i];
var info = GetTransactionTargetInfo(targetTransactionId);
if (info == null)
{
info = new TransactionTargetInfo(targetTransactionId, transaction, targetedCount);
lock (this)
_transactionTargets[targetTransactionId] = info;
_transactionTargetsStorage.Storage.AddEntry(targetTransactionId, info.ToByteArray());
}
else
{
info.UpdateLastTransaction(transaction, targetedCount);
commit.DirtyIds.Add(targetTransactionId);
}
}
}
public override void ConsumeFeatureRequest(CommitItems commitItems, Commit commit, FeatureRequest featureRequest, Transaction transaction)
{
var fanRequest = featureRequest as FanRequest;
var fanMode = fanRequest.FanMode;
var receiverData = transaction.GetFeature <Receiver>(Receiver.FeatureId);
var accountId = transaction.AccountId;
var fanId = receiverData.Receivers[0];
var accountContainer = CurrentChain.GetFeatureAccount(accountId).GetOrAddFeatureContainer <FanContainer>(FeatureId);
var fanContainer = CurrentChain.GetFeatureAccount(fanId).GetOrAddFeatureContainer <FanContainer>(FeatureId);
if (fanMode == FanRequestMode.AddFanOf)
{
accountContainer.AddFanOf(fanId, transaction);
fanContainer.AddFan(accountId, transaction);
}
else if (fanMode == FanRequestMode.RemoveFanOf)
{
accountContainer.RemoveFanOf(fanId, transaction);
fanContainer.RemoveFan(accountId, transaction);
}
commitItems.DirtyAccounts.Add(accountId);
commitItems.DirtyAccounts.Add(fanId);
}
void CommmitDirtyAccounts(CommitItems commitItems)
{
foreach (var accountId in commitItems.DirtyAccounts)
{
var account = GetDataAccount(accountId);
_dataAccountStorage.UpdateEntry(accountId, account.ToByteArray());
}
}
public override void Update(CommitItems commitItems, IFeatureChain featureChain, Transaction transaction, FeatureData transactionFeature)
{
var feature = transactionFeature as AccountIndex;
var info = new LastTransactionCountInfo(transaction.TransactionId, transaction.Timestamp, feature.TransactionCount);
UpdateLastTransactionInfo(feature.Index, info);
commitItems.DirtyAccounts.Add(transaction.AccountId);
}
public override void Update(CommitItems commitItems, IFeatureChain featureChain, Transaction transaction, FeatureData featureData)
{
var feature = featureData as PreviousAccountTransaction;
if (transaction.MetaData.TransactionId > LastTransactionInfo.TransactionId)
{
LastTransactionInfo = new LastTransactionCountInfo(transaction.TransactionId, transaction.Timestamp, feature.TransactionCount);
commitItems.DirtyAccounts.Add(transaction.AccountId);
}
}
void ConsumeTransaction(DirtyData dirtyData, CommitItems commitItems, TransactionItem <MaintainTransaction> dataItem)
{
var transaction = dataItem.Transaction;
var transactionId = transaction.TransactionId;
if (transactionId <= LastProcessedTransactionId)
{
return;
}
if (transaction.TargetChainId == ChainId)
{
var type = transaction.TransactionType;
if (type == MainTainTransactionTypes.Revenue)
{
var rev = transaction as RevenueMaintainTransaction;
var revenueInfo = rev.RevenueInfo;
var tick = rev.Tick;
lock (_revenueLock)
{
var revenues = GetRevenueReceivers(tick);
if (revenues == null)
{
revenues = new RevenueReceivers(tick, rev.PreviousTick, revenueInfo);
_revenueReceivers[tick] = revenues;
_revenueReceiversStroage.AddEntry(tick, revenues.ToByteArray());
}
if (revenueInfo.Index > revenues.RevenueInfo.Index)
{
revenues.RevenueInfo = revenueInfo;
}
foreach (var aId in rev.Accounts)
{
revenues.Accounts.Add(aId);
}
}
dirtyData.DirtyRevenueTicks.Add(tick);
}
ConsumeTransactionFeatures(0, transaction, null, commitItems);
}
}
public override void ConsumeTransactionFeature(CommitItems commitItems, Commit commit, Transaction transaction, FeatureAccount featureAccount, FeatureData featureData)
{
var group = featureData as Group;
var groupId = group.GroupId;
var groupAdministrationInfo = GroupAdministrationChainHandler.GetGroupInfo(groupId);
if (groupAdministrationInfo != null)
{
if (groupAdministrationInfo.IsGroupAccount(transaction.AccountId))
{
var groupInfo = GetGroupInfo(groupId);
groupInfo.ConsumeGroup(transaction, group);
commit.DirtyIds.Add(groupId);
}
}
}
public override void ConsumeFeatureRequest(CommitItems commitItems, Commit commit, FeatureRequest featureRequest, Transaction transaction)
{
var accountId = transaction.AccountId;
if (featureRequest.RequestId == GroupRegistrationRequest.GroupRegistrationRequestId)
{
var feature = transaction.GetFeature <GroupAdministration>(FeatureId);
var container = CurrentChain.GetFeatureAccount(accountId).GetOrAddFeatureContainer <GroupAdministrationContainer>(FeatureId);
var registration = featureRequest as GroupRegistrationRequest;
var groupid = feature.NewGroupId;
var group = new GroupAdministrationInfo(groupid, accountId, transaction.TransactionId, transaction.Timestamp, registration.GroupFlags);
lock (this)
_groups[groupid] = group;
_groupStorage.Storage.AddEntry(groupid, group.ToByteArray());
container.AddGroup(groupid);
commitItems.DirtyAccounts.Add(accountId);
}
else if (featureRequest.RequestId == GroupAdministrationRequest.GroupAdministrationRequestId)
{
var request = featureRequest as GroupAdministrationRequest;
var groupId = request.GroupId;
var group = GetGroupInfo(groupId);
group.ConsumeGroupAdministrationRequest(transaction, request, out var dirtyGroupAccounts);
commit.DirtyIds.Add(groupId);
foreach (var added in dirtyGroupAccounts.AddedAccounts)
{
var container = CurrentChain.GetFeatureAccount(added).GetOrAddFeatureContainer <GroupAdministrationContainer>(FeatureId);
container.AddGroup(groupId);
commitItems.DirtyAccounts.Add(added);
}
foreach (var removed in dirtyGroupAccounts.RemovedAccounts)
{
var container = CurrentChain.GetFeatureAccount(removed).GetOrAddFeatureContainer <GroupAdministrationContainer>(FeatureId);
container.RemoveGroup(groupId);
commitItems.DirtyAccounts.Add(removed);
}
}
}
public override void Update(CommitItems commitItems, IFeatureChain chain, Transaction transaction, FeatureData featureData)
{
var receivers = transaction.GetFeature <Receiver>(Receiver.FeatureId).Receivers;
var sharedIndex = featureData as SharedAccountIndex;
var index = sharedIndex.Index;
var info = new LastTransactionCountInfo(transaction.TransactionId, transaction.Timestamp, sharedIndex.TransactionCount);
UpdateLastTransactionInfo(index, info);
commitItems.DirtyAccounts.Add(AccountId);
foreach (var receiverId in receivers)
{
var account = chain.GetFeatureAccount(receiverId).GetOrAddFeatureContainer <SharedAccountIndexContainer>(SharedAccountIndex.FeatureId);
account.UpdateLastTransactionInfo(index, info);
commitItems.DirtyAccounts.Add(receiverId);
}
}
public override void Update(CommitItems commitItems, IFeatureChain chain, Transaction transaction, FeatureData featureData)
{
var receiverData = featureData as Receiver;
for (var i = 0; i < receiverData.Receivers.Count; i++)
{
var receiverAccountId = receiverData.Receivers[i];
var receiverAccount = chain.GetFeatureAccount(receiverAccountId);
var receiverContainer = receiverAccount.GetOrAddFeatureContainer <ReceiverContainer>(FeatureId);
if (receiverContainer != null)
{
if (receiverContainer.SetLastReceiverInfo(transaction, receiverData._receiverTransactionCount[i]))
{
commitItems.DirtyAccounts.Add(receiverAccountId);
}
}
}
}
public override void ConsumeFeatureRequest(CommitItems commitItems, Commit commit, FeatureRequest featureRequest, Transaction transaction)
{
var friendRequest = featureRequest as FriendRequest;
var friendMode = friendRequest.FriendMode;
var receiverData = transaction.GetFeature <Receiver>(Receiver.FeatureId);
var accountId = transaction.AccountId;
var friendId = receiverData.Receivers[0];
var accountContainer = CurrentChain.GetFeatureAccount(accountId).GetOrAddFeatureContainer <FriendContainer>(FeatureId);
var friendContainer = CurrentChain.GetFeatureAccount(friendId).GetOrAddFeatureContainer <FriendContainer>(FeatureId);
if (friendMode == FriendRequestMode.SendInvitation)
{
accountContainer.AddFriendInvitation(new FriendInvitation(accountId, friendId, accountId), transaction);
friendContainer.AddFriendInvitation(new FriendInvitation(friendId, accountId, accountId), transaction);
}
else if (friendMode == FriendRequestMode.AcceptInvitation)
{
accountContainer.AcceptFriendInvitation(friendId, transaction);
friendContainer.AcceptFriendInvitation(accountId, transaction);
}
else if (friendMode == FriendRequestMode.RejectInvitation)
{
accountContainer.RejectFriendInvitation(friendId, transaction);
friendContainer.RejectFriendInvitation(accountId, transaction);
}
else if (friendMode == FriendRequestMode.Remove)
{
accountContainer.RemoveFriend(friendId, transaction);
friendContainer.RemoveFriend(accountId, transaction);
}
commitItems.DirtyAccounts.Add(accountId);
commitItems.DirtyAccounts.Add(friendId);
}
protected void ConsumeTransactionFeatures(ushort featureRequestTransactionType, Transaction transaction, FeatureAccount featureAccount, CommitItems commitItems)
{
var transactionType = transaction.OperationType;
if (transactionType == featureRequestTransactionType)
{
var featAtt = transaction as FeatureRequestDataTransaction;
var(handler, commit) = commitItems.Get(featAtt.FeatureId);
if (handler != null)
{
try
{
handler.ConsumeFeatureRequest(commitItems, commit, featAtt.Request, transaction);
}
catch (Exception ex)
{
Log.HandleException(ex, this);
}
}
else
{
Log.Warn($"FeatureChainHanler {featAtt.FeatureId} not found, couldn't consume request {featAtt?.Request?.GetType()?.Name}");
}
}
foreach (var featureData in transaction.Features)
{
try
{
if (featureData.Feature.HasAccountContainer)
{
var container = featureAccount.GetOrAddFeatureContainer(featureData.FeatureId);
container.Update(commitItems, this, transaction, featureData);
}
#if DEBUG
else
{
try
{
var container = featureAccount.GetOrAddFeatureContainer(featureData.FeatureId);
if (container != null)
{
Log.Warn($"FeatureContainer not null for {featureData.Feature.GetType().Name}", this);
}
} catch { }
}
#endif
var(handler, commit) = commitItems.Get(featureData.FeatureId);
if (handler != null)
{
handler.ConsumeTransactionFeature(commitItems, commit, transaction, featureAccount, featureData);
}
}
catch (Exception ex)
{
Log.HandleException(ex, this);
}
}
}
public abstract void Update(CommitItems commitItems, IFeatureChain chain, Transaction transaction, FeatureData featureData);
public override void Update(CommitItems commitItems, IFeatureChain chain, Transaction transaction, FeatureData featureData)
{
}
void ConsumeTransaction(CommitItems commitItems, TransactionItem <ServiceTransaction> item)
{
var transaction = item.Transaction;
if (transaction.TransactionId <= LastProcessedTransactionId)
{
return;
}
if (transaction.TargetChainId == ChainId)
{
var type = transaction.TransactionType;
var accountId = transaction.AccountId;
var account = GetServiceAccount(accountId);
if (type == ServiceTransactionTypes.Join)
{
var joinTransaction = transaction as JoinServiceTransaction;
if (account == null)
{
account = new ServiceAccount(accountId, ChainId, joinTransaction.Timestamp);
if (joinTransaction.AccountKey != null)
{
account.AddAccountKey(joinTransaction.AccountKey, joinTransaction.Timestamp);
}
lock (_lock)
_serviceAccounts[accountId] = account;
_serviceAccountStorage.AddEntry(accountId, account.ToByteArray());
return; // skip dirty account stuff
}
if (joinTransaction.AccountKey != null)
{
account.AddAccountKey(joinTransaction.AccountKey, joinTransaction.Timestamp);
commitItems.DirtyAccounts.Add(accountId);
}
}
else if (type == ServiceTransactionTypes.Purchase)
{
var purchaseTransaction = transaction as PurchaseServiceTransaction;
var purchase = CoreChain.GetChainInfo(ChainId).GetPurchase(purchaseTransaction.PurchaseGroupId, purchaseTransaction.PurchaseItemId);
if (purchase != null)
{
var targetAccount = GetServiceAccount(purchaseTransaction.ReceiverAccountId);
if (targetAccount != null && purchase != null)
{
targetAccount.AddPurchase(purchaseTransaction, purchase);
commitItems.DirtyAccounts.Add(targetAccount.AccountId);
}
}
}
else if (type == ServiceTransactionTypes.RequestRevenue)
{
var revenueTransaction = transaction as RequestRevenueServiceTransaction;
account.UpdateTotelRevenuePayout(revenueTransaction.CurrentTotalRevenuePayout + revenueTransaction.PayoutAmount);
}
ConsumeTransactionFeatures((ushort)ServiceTransactionTypes.FeatureRequest, transaction, account, commitItems);
commitItems.DirtyAccounts.Add(accountId);
}
}
void CommmitDirtyData(DirtyData dirtyData, CommitItems commitItems)
{
lock (_revenueLock)
{
foreach (var tick in dirtyData.DirtyRevenueTicks)
{
var revenues = GetRevenueReceivers(tick);
_revenueReceiversStroage.UpdateEntry(tick, revenues.ToByteArray());
_revenueReceiversStroage.LastAvailableTick = Math.Max(tick, _revenueReceiversStroage.LastAvailableTick);
}
var last = GetRevenueReceivers(_revenueReceiversStroage.LastAvailableTick);
if (last != null)
{
var previous = GetRevenueReceivers(last.PreviousTick);
var lastProcessed = _revenueReceiversStroage.LastProcessedTick;
while (previous != null)
{
if (previous.Tick <= lastProcessed)
{
break;
}
var tick = previous.Tick;
var accounts = previous.Accounts;
var count = accounts.Count;
var revenueInfo = previous.RevenueInfo;
var tickRevenue = revenueInfo.Revenue * revenueInfo.AccountRevenueFactor;
var accountRevenue = tickRevenue / count;
var maxCount = tickRevenue / Currency.OneCen;
if (count > maxCount)
{
var list = new List <long>(accounts);
list.Sort((a, b) => a.CompareTo(b));
var rand = new Lehmer(count);
for (var i = 0; i < count; i++)
{
var a = rand.Next(count);
var tmp = list[i];
list[i] = list[a];
list[a] = tmp;
}
for (var i = 0; i < maxCount; i++)
{
var accountId = list[i];
var account = GetMaintainAccount(accountId);
account.AddRevenue(tick, (int)Currency.OneCen);
commitItems.DirtyAccounts.Add(accountId);
}
}
else
{
foreach (var accountId in accounts)
{
var account = GetMaintainAccount(accountId);
account.AddRevenue(tick, accountRevenue);
commitItems.DirtyAccounts.Add(accountId);
}
}
previous = GetRevenueReceivers(previous.PreviousTick);
}
_revenueReceiversStroage.LastProcessedTick = last.PreviousTick;
}
}
foreach (var accountId in commitItems.DirtyAccounts)
{
var account = GetMaintainAccount(accountId);
_maintainAccountStorage.UpdateEntry(accountId, account.ToByteArray());
}
}
public override void Update(CommitItems commitItems, IFeatureChain chain, Transaction transaction, FeatureData featureData)
{
// done in ConsumeFeatureRequest
}
