public static ActionDto FromDomainModel(TxAction action)
{
return(new ActionDto
{
ActionNumber = action.ActionNumber,
ActionType = action.ActionType,
ActionData = action.ActionData
});
}
public static string GetActionString(TxAction action)
{
if (action == TxAction.Sent)
{
return(TextTools.RetrieveStringFromResource("Sent"));
}
else if (action == TxAction.Received)
{
return(TextTools.RetrieveStringFromResource("Received"));
}
else
{
return("NA");
}
}
public Result <TxAction> ImportAction(ActionDto actionDto, int actionNumber)
{
using (var uow = NewUnitOfWork(UnitOfWorkMode.Writable))
{
var action = new TxAction
{
ActionNumber = actionNumber,
ActionType = actionDto.ActionType,
ActionData = JsonConvert.SerializeObject(actionDto.ActionData),
};
NewRepository <TxAction>(uow).Insert(action);
uow.Commit();
return(Result.Success(action));
}
}
public Result CreateAccount(
List <BlockchainEvent> events,
IUnitOfWork uow,
Address senderAddress,
TxAction action)
{
var addressRepo = NewRepository <Address>(uow);
var account = new Account()
{
Hash = _blockchainCryptoProvider.DeriveHash(
senderAddress.BlockchainAddress,
senderAddress.Nonce,
(short)action.ActionNumber),
ControllerAddress = senderAddress.BlockchainAddress
};
NewRepository <Account>(uow).Insert(account);
events.First().Account = account;
return(Result.Success());
}
public AddingTxEventArgs Set(TxAction action, string reason)
{
Action = action;
Reason = reason;
return(this);
}
public Result <IEnumerable <BlockchainEvent> > ImportEvents(
TxAction action,
Address senderAddress,
Block block,
Transaction tx,
JObject actionDataObj)
{
using (var uow = NewUnitOfWork(UnitOfWorkMode.Writable))
{
List <BlockchainEvent> events = new List <BlockchainEvent>
{
new BlockchainEvent
{
AddressId = senderAddress.AddressId,
TxActionId = action.TxActionId,
BlockId = block.BlockId,
Fee = tx.ActionFee,
Amount = 0,
TransactionId = tx.TransactionId,
EventType = EventType.Action.ToString()
}
};
senderAddress.AvailableBalance -= tx.ActionFee;
if (tx.Status == TxStatus.Success.ToString())
{
Result result = Result.Success();
switch (action.ActionType.ToEnum <ActionType>())
{
case ActionType.TransferChx:
result = _actionService.TransferChx(
events,
actionDataObj.ToObject <TransferChxData>(),
uow,
senderAddress);
break;
case ActionType.DelegateStake:
result = _actionService.DelegateStake(
events,
actionDataObj.ToObject <DelegateStakeData>(),
uow,
senderAddress);
break;
case ActionType.ConfigureValidator:
result = _actionService.ConfigureValidator(
events,
actionDataObj.ToObject <ConfigureValidatorData>(),
uow,
senderAddress);
break;
case ActionType.RemoveValidator:
result = _actionService.RemoveValidator(events, uow, senderAddress);
break;
case ActionType.SetAssetCode:
result = _actionService.SetAssetCode(
events,
actionDataObj.ToObject <SetAssetCodeData>(),
uow);
break;
case ActionType.SetAssetController:
result = _actionService.SetAssetController(
events,
actionDataObj.ToObject <SetAssetControllerData>(),
uow);
break;
case ActionType.SetAccountController:
result = _actionService.SetAccountController(
events,
actionDataObj.ToObject <SetAccountControllerData>(),
uow);
break;
case ActionType.TransferAsset:
result = _actionService.TransferAsset(
events,
actionDataObj.ToObject <TransferAssetData>(),
uow);
break;
case ActionType.CreateAssetEmission:
result = _actionService.CreateAssetEmission(
events,
actionDataObj.ToObject <CreateAssetEmissionData>(),
uow);
break;
case ActionType.CreateAsset:
result = _actionService.CreateAsset(events, uow, senderAddress, action);
break;
case ActionType.CreateAccount:
result = _actionService.CreateAccount(events, uow, senderAddress, action);
break;
case ActionType.SubmitVote:
result = _actionService.SubmitVote(events, actionDataObj.ToObject <SubmitVoteData>(), uow);
break;
case ActionType.SubmitVoteWeight:
result = _actionService.SubmitVoteWeight(
events,
actionDataObj.ToObject <SubmitVoteWeightData>(),
uow);
break;
case ActionType.SetAccountEligibility:
result = _actionService.SetAccountEligibility(
events,
actionDataObj.ToObject <SetAccountEligibilityData>(),
uow);
break;
case ActionType.SetAssetEligibility:
result = _actionService.SetAssetEligibility(
events,
actionDataObj.ToObject <SetAssetEligibilityData>(),
uow);
break;
case ActionType.ChangeKycControllerAddress:
result = _actionService.ChangeKycControllerAddress(
events,
actionDataObj.ToObject <ChangeKycControllerAddressData>(),
uow);
break;
case ActionType.AddKycProvider:
result = _actionService.AddKycProvider(
events,
actionDataObj.ToObject <AddKycProviderData>(),
uow);
break;
case ActionType.RemoveKycProvider:
result = _actionService.RemoveKycProvider(
events,
actionDataObj.ToObject <RemoveKycProviderData>(),
uow);
break;
default:
result = Result.Failure("Unsupported action type.");
break;
}
if (result.Failed)
{
return(Result.Failure <IEnumerable <BlockchainEvent> >(result.Alerts));
}
}
NewRepository <BlockchainEvent>(uow).Insert(events);
NewRepository <Address>(uow).Update(senderAddress);
uow.Commit();
return(Result.Success(events.AsEnumerable()));
}
}
