public override (bool, int) Validate(Transaction transaction, FeatureData featureData)
{
var error = DataError.None;
var data = featureData as Data;
var items = data.Items;
if (items.Count == 0)
{
error = DataError.Empty;
goto end;
}
foreach (var item in items.Values)
{
if (!item.IsValid)
{
error = DataError.InvalidItem;
goto end;
}
}
end:
return(error == DataError.None, (int)error);
}
public override (bool, int) Validate(Transaction transaction, FeatureData featureData)
{
var error = EnforceReceiverFriendError.None;
var receivers = transaction.GetFeature <Receiver>(Receiver.FeatureId)?.Receivers;
if (receivers == null)
{
error = EnforceReceiverFriendError.ReceiversMissing;
goto end;
}
var friendContainer = _friendChain.GetFeatureAccount(transaction.AccountId)?.GetFeatureContainer <FriendContainer>(Friend.FeatureId);
if (friendContainer == null)
{
error = EnforceReceiverFriendError.InvalidFriend;
goto end;
}
foreach (var receiverId in receivers)
{
if (!friendContainer.HasFriend(receiverId))
{
error = EnforceReceiverFriendError.InvalidFriend;
goto end;
}
}
end:
return(error == EnforceReceiverFriendError.None, (int)error);
}
public override (bool, int) Validate(Transaction transaction, FeatureData featureData)
{
if (!transaction.HasFeature(Receiver.FeatureId))
{
return(false, (int)SharedAccountIndexError.ReceiverMissing);
}
return(true, 0);
}
public override (bool, int) Validate(Transaction transaction, FeatureData featureData)
{
var error = GroupAdministrationError.None;
var request = (transaction as IFeatureRequestTransaction)?.Request;
if (request == null)
{
error = GroupAdministrationError.InvalidFeatureRequest;
goto end;
}
end:
return(error == GroupAdministrationError.None, (int)error);
}
public override (bool, int) Validate(Transaction transaction, FeatureData featureData)
{
var error = ReceiverError.None;
if (!(featureData is Receiver receiverData) || !receiverData.Valid)
{
error = ReceiverError.InvalidReceiverData;
goto end;
}
var receivers = receiverData.Receivers;
if (receivers.Count > MaxReceivers)
{
error = ReceiverError.TooManyReceivers;
goto end;
}
if (receivers.Count == 0)
{
error = ReceiverError.InvalidReceiver;
goto end;
}
var receiversList = new HashSet <long>();
foreach (var receiverAccountId in receivers)
{
if (!CurrentChain.FeatureAccountExists(receiverAccountId))
{
error = ReceiverError.InvalidReceiver;
goto end;
}
if (receiversList.Contains(receiverAccountId))
{
error = ReceiverError.InvalidReceiver;
goto end;
}
receiversList.Add(receiverAccountId);
}
end:
return(error == ReceiverError.None, (int)error);
}
public override (bool, int) Validate(Transaction transaction, FeatureData featureData)
{
var group = featureData as Group;
var groupInfo = _chainHandler.GetGroupInfo(group.GroupId);
if (groupInfo == null)
{
return(false, (int)GroupError.InvalidGroup);
}
if (!groupInfo.IsGroupAccount(transaction.AccountId))
{
return(false, (int)GroupError.InvalidAccount);
}
return(true, 0);
}
public override (bool, int) Validate(Transaction transaction, FeatureData featureData)
{
var error = TransactionTargetError.None;
if (!(featureData is TransactionTarget targetData) || !targetData.Valid)
{
error = TransactionTargetError.InvalidTransactionTargetData;
goto end;
}
var targets = targetData.Targets;
if (targets.Count > MaxReceivers)
{
error = TransactionTargetError.TooManyTransactionTargets;
goto end;
}
if (targets.Count == 0)
{
error = TransactionTargetError.InvalidTarget;
goto end;
}
var transactoinTargets = new HashSet <long>();
foreach (var targetedTransactionId in targets)
{
if (targetedTransactionId > CurrentChain.LastProcessedTransactionId)
{
error = TransactionTargetError.InvalidTarget;
goto end;
}
if (transactoinTargets.Contains(targetedTransactionId))
{
error = TransactionTargetError.InvalidTarget;
goto end;
}
transactoinTargets.Add(targetedTransactionId);
}
end:
return(error == TransactionTargetError.None, (int)error);
}
public override (bool, int) Validate(Transaction transaction, FeatureData featureData)
{
var friendData = featureData as Friend;
if ((friendData.Flags & FriendFlags.ReceiversMustBeFriend) != 0)
{
var valid = true;
var receivers = transaction.GetFeature <Receiver>(Receiver.FeatureId)?.Receivers;
if (receivers != null)
{
var accountId = transaction.AccountId;
foreach (var receiverId in receivers)
{
var receiverAccount = CurrentChain.GetFeatureAccount(receiverId)?.GetFeatureContainer <FriendContainer>(FeatureId);
if (receiverAccount != null)
{
if (receiverAccount.HasFriend(accountId))
{
continue;
}
}
valid = false;
break;
}
}
else
{
valid = false;
}
return(valid, (int)(valid ? FriendError.None : FriendError.ReceiversMustBeFriends));
}
else
{
return(true, 0);
}
}
public override void UpdateMetaData(IFeatureChain featureChain, Transaction transaction, FeatureData featureData)
{
var receiverData = featureData as Receiver;
var receivers = receiverData.Receivers;
var count = receivers.Count;
for (var i = 0; i < count; i++)
{
var receiverId = receivers[i];
receiverData._previousReceiverTransactionId[i] = _lastTransactionIdLookup.Update(receiverId, transaction.TransactionId);
receiverData._receiverTransactionCount[i] = _lastTransactionCountLookup.Increase(receiverId);
}
}
public override void PreProcess(IFeatureChain featureChain, FeatureAccount featureAccount, Transaction transaction, FeatureData featureData)
{
var receiverData = featureData as Receiver;
var receivers = receiverData.Receivers;
foreach (var receiverId in receivers)
{
var receiverAccount = featureChain.GetFeatureAccount(receiverId);
var info = receiverAccount.GetFeatureContainer <ReceiverContainer>(featureData.FeatureId)?.LastReceiverTransactionInfo ?? LastTransactionCountInfo.Empty;
_lastTransactionIdLookup.Set(receiverId, info.TransactionId);
_lastTransactionCountLookup.Set(receiverId, info.Count);
}
}
public override void UpdateMetaData(IFeatureChain featureChain, Transaction transaction, FeatureData featureData)
{
var targetData = featureData as TransactionTarget;
var targets = targetData.Targets;
var count = targets.Count;
for (var i = 0; i < count; i++)
{
var receiverId = targets[i];
targetData._previousTargetedTransactionId[i] = _lastTransactionIdLookup.Update(receiverId, transaction.TransactionId);
targetData._targetedTransactionsCount[i] = _lastTransactionCountLookup.Increase(receiverId);
}
}
public override void Update(CommitItems commitItems, IFeatureChain chain, Transaction transaction, FeatureData featureData)
{
// done in ConsumeFeatureRequest
}
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 Update(CommitItems commitItems, IFeatureChain chain, Transaction transaction, FeatureData featureData)
{
}
public abstract void UpdateMetaData(IFeatureChain currentChain, Transaction transaction, FeatureData featureData);
public abstract void PreProcess(IFeatureChain currentChain, FeatureAccount featureAccount, Transaction transaction, FeatureData featureData);
public override void UpdateMetaData(IFeatureChain currentChain, Transaction transaction, FeatureData featureData)
{
var accountId = transaction.AccountId;
var feature = featureData as AccountIndexBase;
feature.PreviousTransactionId = _lastTransactionIdLookup.Update(accountId, transaction.TransactionId);
feature.TransactionCount = _lastTransactionCountLookup.Increase(accountId);
}
public override void PreProcess(IFeatureChain currentChain, FeatureAccount featureAccount, Transaction transaction, FeatureData featureData)
{
var feature = featureData as AccountIndexBase;
var featureId = featureData.FeatureId;
var accountId = featureAccount.AccountId;
var container = featureAccount.GetFeatureContainer <AccountIndexContainerBase>(featureId);
if (container != null)
{
var info = container.GetLastTransactionInfo(feature.Index);
_lastTransactionIdLookup.Set(accountId, info.TransactionId);
_lastTransactionCountLookup.Set(accountId, info.Count);
}
}
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 PreProcess(IFeatureChain featureChain, FeatureAccount featureAccount, Transaction transaction, FeatureData featureData)
{
if (_chainHandler == null)
{
_chainHandler = featureChain.GetFeatureChainHandler <GroupChainHandler>(featureData.FeatureId);
}
var group = featureData as Group;
var groupId = group.GroupId;
var index = group.GroupIndex;
var groupInfo = _chainHandler.GetGroupInfo(groupId);
var info = groupInfo.LastTransactionInfo;
PreviousGroupTransactions.Set(groupId, info.TransactionId);
GroupTransactionsCount.Set(groupId, info.Count);
if (index != null)
{
info = groupInfo.GetLastGroupIndexTransactionInfo(index, true);
PreviousGroupIndexTransactions.Set(groupId, index, info.TransactionId);
GroupIndexTransactionsCount.Set(groupId, info.Count);
}
}
public override void UpdateMetaData(IFeatureChain featureChain, Transaction transaction, FeatureData featureData)
{
if (_chainHandler == null)
{
_chainHandler = featureChain.GetFeatureChainHandler <GroupChainHandler>(featureData.FeatureId);
}
var group = featureData as Group;
var groupId = group.GroupId;
var index = group.GroupIndex;
var transactionId = transaction.TransactionId;
group.PreviousGroupTransactionId = PreviousGroupTransactions.Update(groupId, transactionId);
group.GroupTransactionCount = GroupTransactionsCount.Increase(groupId);
if (index != null)
{
group.PreviousGroupIndexTransactionId = PreviousGroupIndexTransactions.Update(groupId, index, transactionId);
group.GroupIndexTransactionCount = GroupIndexTransactionsCount.Increase(groupId);
}
}
public abstract void Update(CommitItems commitItems, IFeatureChain chain, Transaction transaction, FeatureData featureData);
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 PreProcess(IFeatureChain featureChain, FeatureAccount featureAccount, Transaction transaction, FeatureData transactionFeature)
{
if (featureAccount == null) // Join
{
return;
}
var featureId = transactionFeature.FeatureId;
var accountId = featureAccount.AccountId;
var container = featureAccount.GetFeatureContainer <PreviousAccountTransactionContainer>(featureId);
if (container != null)
{
var info = container.LastTransactionInfo;
_lastTransactionIdLookup.Set(accountId, info.TransactionId);
_lastTransactionCountLookup.Set(accountId, info.Count);
}
}
public override void UpdateMetaData(IFeatureChain featureChain, Transaction transaction, FeatureData featureData)
{
var request = (transaction as IFeatureRequestTransaction).Request;
var administration = featureData as GroupAdministration;
if (request.RequestId == GroupRegistrationRequest.GroupRegistrationRequestId)
{
administration.NewGroupId = _nextGroupId;
++_nextGroupId;
}
else if (request.RequestId == GroupAdministrationRequest.GroupAdministrationRequestId)
{
var groupId = ((GroupAdministrationRequest)(request)).GroupId;
administration.PreviousAdministrationTransactionId = _lastTransactionIdLookup.Update(groupId, transaction.TransactionId);
}
}
public override void PreProcess(IFeatureChain featureChain, FeatureAccount featureAccount, Transaction transaction, FeatureData featureData)
{
var targetData = featureData as TransactionTarget;
var targetHandler = featureChain.GetFeatureChainHandler <TransactionTargetChainHandler>(featureData.FeatureId);
var targets = targetData.Targets;
foreach (var targetId in targets)
{
var info = targetHandler?.GetTransactionTargetInfo(targetId)?.LastTransactionInfo ?? LastTransactionCountInfo.Empty;
_lastTransactionIdLookup.Set(targetId, info.TransactionId);
_lastTransactionCountLookup.Set(targetId, info.Count);
}
}
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);
}
}
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 UpdateMetaData(IFeatureChain featureChain, Transaction transaction, FeatureData transactionFeature)
{
var accountId = transaction.AccountId;
var feature = transactionFeature as PreviousAccountTransaction;
feature.PreviousTransactionId = _lastTransactionIdLookup.Update(accountId, transaction.TransactionId);
feature.TransactionCount = _lastTransactionCountLookup.Increase(accountId);
}
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);
}
}
}
}
