public override Result QueryFeature(FeatureQuery query)
{
if (query.GetLong(0, out var accountId))
{
var account = CurrentChain.GetFeatureAccount(accountId);
if (account != null)
{
var container = account.GetFeatureContainer <FanContainer>(FeatureId);
if (container != null)
{
var action = query.Action;
if (action == FansAction)
{
return(new PackableResult(container.GetFans()));
}
else if (action == FanOfAction)
{
return(new PackableResult(container.GetFanOf()));
}
else if (action == FansLastTransactionInfoAction)
{
return(new PackableResult(container.LastFansTransactionInfo));
}
else if (action == FanOfLastTransactionInfoAction)
{
return(new PackableResult(container.LastFanOfTransactionInfo));
}
}
return(Result.DataNotFound);
}
return(Result.AccountNotFound);
}
return(Result.InvalidQuery);
}
public override Result QueryFeature(FeatureQuery query)
{
if (query.Action == LastTransactionInfoAction)
{
return(GetAccountData <PreviousAccountTransactionContainer>(query, 0, (container) =>
{
return new PackableResult(container?.LastTransactionInfo ?? LastTransactionCountInfo.Empty);
}));
}
else if (query.Action == LastTransactionInfoBatchAction)
{
return(GetBatchData <long>(query, 0, (u, l) => u.Unpack(l), (accountIds) =>
{
var batchResult = new LastTransactionCountInfoBatch();
foreach (var accountId in accountIds)
{
var account = CurrentChain.GetFeatureAccount(accountId);
var info = account?.GetFeatureContainer <PreviousAccountTransactionContainer>(FeatureId)?.LastTransactionInfo ?? LastTransactionCountInfo.Empty;
batchResult.Add(account != null, accountId, info);
}
return new PackableResult(batchResult);
}));
}
return(Result.InvalidQuery);
}
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);
}
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 (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 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);
}
public override (bool, int) ValidateFeatureRequest(FeatureRequest featureRequest, Transaction transaction)
{
var error = FriendError.None;
var receiverData = transaction.GetFeature <Receiver>(Receiver.FeatureId);
if (receiverData == null)
{
error = FriendError.ReceiverFeatureRequired;
goto end;
}
if (receiverData.Receivers.Count != 1)
{
error = FriendError.InvalidFeatureRequest;
goto end;
}
if (!(featureRequest is FriendRequest friendRequest))
{
error = FriendError.InvalidFeatureRequest;
goto end;
}
var accountId = transaction.AccountId;
var fanId = receiverData.Receivers[0];
var friendId = transaction.GetFeature <Receiver>(Receiver.FeatureId).Receivers[0];
var friendTransaction = friendRequest;
var dataAccount = CurrentChain.GetFeatureAccount(accountId).GetFeatureContainer <FriendContainer>(FeatureId);
var friendAccount = CurrentChain.GetFeatureAccount(fanId).GetFeatureContainer <FriendContainer>(FeatureId);
var friendMode = friendTransaction.FriendMode;
if (friendMode == FriendRequestMode.SendInvitation)
{
if (friendId == accountId)
{
error = FriendError.InvalidFriend;
goto end;
}
var hasError = false;
if (dataAccount != null)
{
if (dataAccount.HasFriend(friendId))
{
error = FriendError.AlreadyFriends;
goto end;
}
if (dataAccount.GetFriendInvitation(friendId) != null)
{
hasError = true;
}
}
else
{
if (friendAccount != null && friendAccount.GetFriendInvitation(accountId) != null)
{
hasError = true;
}
}
if (hasError)
{
error = FriendError.AlreadyInvited;
goto end;
}
}
else if (friendMode == FriendRequestMode.AcceptInvitation || friendMode == FriendRequestMode.RejectInvitation)
{
if (dataAccount == null || friendAccount == null)
{
error = FriendError.Unknown;
goto end;
}
var invitation = dataAccount.GetFriendInvitation(friendId);
var friendInvitation = friendAccount.GetFriendInvitation(accountId);
if (invitation == null || !invitation.HasFriendAccountApproval || friendInvitation == null || !friendInvitation.HasAccountApproval)
{
error = FriendError.InvalidFriend;
goto end;
}
}
else if (friendMode == FriendRequestMode.Remove)
{
if (dataAccount == null || friendAccount == null)
{
error = FriendError.Unknown;
goto end;
}
var isFriend = dataAccount.HasFriend(friendId);
var hasInvitation = dataAccount.GetFriendInvitation(friendId) != null;
if (!(isFriend || hasInvitation))
{
error = FriendError.InvalidFriend;
goto end;
}
}
else
{
error = FriendError.Unknown;
goto end;
}
end:
return(error == FriendError.None, (int)error);
}
public override Result QueryFeature(FeatureQuery query)
{
if (query.Action == LastTransactionInfoAction)
{
if (query.GetString(1, out var indexHex))
{
var index = new Chain.Index(indexHex);
return(GetAccountData <AccountIndexContainerBase>(query, 0, (container) =>
{
return new PackableResult(container?.GetLastTransactionInfo(index) ?? LastTransactionCountInfo.Empty);
}));
}
}
else if (query.Action == LastTransactionInfoBatchAction)
{
if (query.GetString(1, out var indexHex))
{
var index = new Chain.Index(indexHex);
return(GetBatchData <long>(query, 0, (u, l) => u.Unpack(l), (accountIds) =>
{
var batchResult = new LastTransactionCountInfoBatch();
foreach (var accountId in accountIds)
{
var account = CurrentChain.GetFeatureAccount(accountId);
var info = account?.GetFeatureContainer <AccountIndexContainerBase>(FeatureId)?.GetLastTransactionInfo(index) ?? LastTransactionCountInfo.Empty;
batchResult.Add(info != null, accountId, info);
}
return new PackableResult(batchResult);
}));
}
}
else if (query.Action == LastTransactionInfoIndicesBatchAction)
{
if (query.GetLong(0, out var accountId) && query.GetString(1, out var indicesHex))
{
return(GetBatchData <Chain.Index>(query, 1, (unpacker, list) => unpacker.Unpack(list, (u) => new Chain.Index(u)), (indices) =>
{
var account = CurrentChain.GetFeatureAccount(accountId);
var container = account?.GetFeatureContainer <AccountIndexContainerBase>(FeatureId);
if (account != null)
{
var batchResult = new LastTransactionCountInfoBatch();
foreach (var index in indices)
{
var info = container?.GetLastTransactionInfo(index);
batchResult.Add(info != null, accountId, info);
}
return new PackableResult(batchResult);
}
return Result.AccountNotFound;
}));
}
}
return(Result.InvalidQuery);
}
public override (bool, int) ValidateFeatureRequest(FeatureRequest featureRequest, Transaction transaction)
{
var error = FanError.None;
var receiverData = transaction.GetFeature <Receiver>(Receiver.FeatureId);
if (receiverData == null)
{
error = FanError.ReceiverFeatureRequired;
goto end;
}
if (receiverData.Receivers.Count != 1)
{
error = FanError.InvalidFeatureRequest;
goto end;
}
if (!(featureRequest is FanRequest fanRequest))
{
error = FanError.InvalidFeatureRequest;
goto end;
}
var accountId = transaction.AccountId;
var fanId = receiverData.Receivers[0];
if (fanId == accountId)
{
error = FanError.InvalidFan;
goto end;
}
var accountContainer = CurrentChain.GetFeatureAccount(accountId).GetFeatureContainer <FanContainer>(FeatureId);
var fanContainer = CurrentChain.GetFeatureAccount(fanId).GetFeatureContainer <FanContainer>(FeatureId);
if (accountContainer != null)
{
var fanOf = accountContainer.IsFanOf(fanId);
if (fanRequest.FanMode == FanRequestMode.AddFanOf)
{
if (fanOf)
{
error = FanError.AlreadyFan;
goto end;
}
}
else if (fanRequest.FanMode == FanRequestMode.RemoveFanOf)
{
if (!fanOf)
{
error = FanError.InvalidFan;
goto end;
}
}
else
{
error = FanError.Unknown;
goto end;
}
}
else
{
if (fanContainer != null)
{
var isFan = fanContainer.IsFan(accountId);
if (fanRequest.FanMode == FanRequestMode.AddFanOf)
{
if (isFan)
{
error = FanError.AlreadyFan;
goto end;
}
}
else if (fanRequest.FanMode == FanRequestMode.RemoveFanOf)
{
if (!isFan)
{
error = FanError.InvalidFan;
goto end;
}
}
else
{
error = FanError.Unknown;
goto end;
}
}
}
end:
return(error == FanError.None, (int)error);
}
