public override Empty UpdateCoefficientFromSender(CoefficientFromSender coefficientInput)
{
if (coefficientInput == null)
{
return(new Empty());
}
Assert(Context.Sender == State.ControllerForUserFee.Value.RootController, "no permission");
var coefficientInfoInState = State.CalculateCoefficientOfSender.Value;
if (coefficientInfoInState == null)
{
return(new Empty());
}
var funcCoefficient =
coefficientInfoInState.Coefficients.SingleOrDefault(x => x.PieceKey == coefficientInput.PieceKey);
Assert(funcCoefficient != null, $"piece key:{coefficientInput.PieceKey} does not exist");
if (!IsModifiedDbData(coefficientInput, funcCoefficient))
{
return(new Empty());
}
State.CalculateCoefficientOfSender.Value = coefficientInfoInState;
Context.Fire(new NoticeUpdateCalculateFeeAlgorithm
{
AllCoefficient = coefficientInfoInState
});
return(new Empty());
}
private bool UpdatePowerAlgorithm(CoefficientFromSender sender, CalculateFeeCoefficient dbData)
{
var coefficient = sender.PowerCoefficient;
if (coefficient.Denominator <= 0)
{
return(false);
}
if (coefficient.Numerator < 0)
{
return(false);
}
if (coefficient.Weight <= 0)
{
return(false);
}
if (coefficient.WeightBase <= 0)
{
return(false);
}
if (coefficient.ChangeSpanBase <= 0)
{
return(false);
}
dbData.CoefficientDic[nameof(coefficient.Denominator).ToLower()] = coefficient.Denominator;
dbData.CoefficientDic[nameof(coefficient.Numerator).ToLower()] = coefficient.Numerator;
dbData.CoefficientDic[nameof(coefficient.Weight).ToLower()] = coefficient.Weight;
dbData.CoefficientDic[nameof(coefficient.WeightBase).ToLower()] = coefficient.WeightBase;
dbData.CoefficientDic[nameof(coefficient.ChangeSpanBase).ToLower()] = coefficient.ChangeSpanBase;
return(true);
}
public async Task Update_Coefficient_For_Sender_Should_Success()
{
await CreateAndIssueVoteToken();
const int pieceKey = 1000000;
var updateInput = new CoefficientFromSender
{
LinerCoefficient = new LinerCoefficient
{
ConstantValue = 1,
Denominator = 2,
Numerator = 3
},
PieceKey = pieceKey,
IsLiner = true
};
var proposalId = await CreateToRootForUserFeeByTwoLayer(updateInput);
await ApproveToRootForUserFeeByTwoLayer(proposalId);
await VoteToReferendum(proposalId);
await ReleaseToRootForUserFeeByTwoLayer(proposalId);
var userCoefficientRet = await MainChainTester.ExecuteContractWithMiningAsync(TokenContractAddress,
nameof(TokenContractContainer.TokenContractStub.GetCalculateFeeCoefficientOfSender), new Empty());
userCoefficientRet.Status.ShouldBe(TransactionResultStatus.Mined);
var userCoefficient = new CalculateFeeCoefficientsOfType();
userCoefficient.MergeFrom(userCoefficientRet.ReturnValue);
var hasModified = userCoefficient.Coefficients.Single(x => x.PieceKey == pieceKey);
hasModified.CoefficientDic["ConstantValue".ToLower()].ShouldBe(1);
hasModified.CoefficientDic["Denominator".ToLower()].ShouldBe(2);
hasModified.CoefficientDic["Numerator".ToLower()].ShouldBe(3);
}
private bool ChangeFeePieceKey(CoefficientFromSender coefficient, CalculateFeeCoefficient dbData)
{
var newPieceKey = coefficient.NewPieceKeyCoefficient.NewPieceKey;
if (newPieceKey == coefficient.PieceKey || newPieceKey <= 0)
{
return(false);
}
dbData.PieceKey = newPieceKey;
return(true);
}
private bool IsModifiedDbData(CoefficientFromSender coefficientInput, CalculateFeeCoefficient funcCoefficient)
{
bool isChanged;
if (coefficientInput.IsChangePieceKey)
{
isChanged = ChangeFeePieceKey(coefficientInput, funcCoefficient);
}
else if (coefficientInput.IsLiner)
{
isChanged = UpdateLinerAlgorithm(coefficientInput, funcCoefficient);
}
else
{
isChanged = UpdatePowerAlgorithm(coefficientInput, funcCoefficient);
}
return(isChanged);
}
private bool UpdateLinerAlgorithm(CoefficientFromSender sender, CalculateFeeCoefficient dbData)
{
var coefficient = sender.LinerCoefficient;
if (coefficient.Denominator <= 0)
{
return(false);
}
if (coefficient.Numerator < 0)
{
return(false);
}
if (coefficient.ConstantValue < 0)
{
return(false);
}
dbData.CoefficientDic[nameof(coefficient.Denominator).ToLower()] = coefficient.Denominator;
dbData.CoefficientDic[nameof(coefficient.Numerator).ToLower()] = coefficient.Numerator;
dbData.CoefficientDic[nameof(coefficient.ConstantValue).ToLower()] = coefficient.ConstantValue;
return(true);
}
private async Task <Hash> CreateToRootForUserFeeByTwoLayer(CoefficientFromSender input)
{
var organizations = await GetControllerForUserFee();
var createNestProposalInput = new CreateProposalInput
{
ToAddress = TokenContractAddress,
Params = input.ToByteString(),
OrganizationAddress = organizations.RootController,
ContractMethodName = nameof(TokenContractContainer.TokenContractStub.UpdateCoefficientFromSender),
ExpiredTime = TimestampHelper.GetUtcNow().AddHours(1)
};
var createProposalInput = new CreateProposalInput
{
ToAddress = AssociationAddress,
Params = createNestProposalInput.ToByteString(),
OrganizationAddress = organizations.ParliamentController,
ContractMethodName = nameof(AssociationContractContainer.AssociationContractStub.CreateProposal),
ExpiredTime = TimestampHelper.GetUtcNow().AddHours(1)
};
var parliamentCreateProposal = await MainChainTester.ExecuteContractWithMiningAsync(ParliamentAddress,
nameof(ParliamentContractContainer.ParliamentContractStub.CreateProposal),
createProposalInput);
parliamentCreateProposal.Status.ShouldBe(TransactionResultStatus.Mined);
var parliamentProposalId = new Hash();
parliamentProposalId.MergeFrom(parliamentCreateProposal.ReturnValue);
await ApproveWithMinersAsync(parliamentProposalId, ParliamentAddress, MainChainTester);
var releaseRet = await ReleaseProposalAsync(parliamentProposalId, ParliamentAddress, MainChainTester);
var id = ProposalCreated.Parser
.ParseFrom(releaseRet.Logs.First(l => l.Name.Contains(nameof(ProposalCreated)))
.NonIndexed).ProposalId;
return(id);
}
