public override Hash CreateProposal(CreateProposalInput input)
{
// check authorization of proposer public key
var organization = State.Organisations[input.OrganizationAddress];
Assert(organization != null, "No registered organization.");
AssertSenderIsAuthorizedProposer(organization);
Hash hash = Hash.FromMessage(input);
var proposal = new ProposalInfo
{
ContractMethodName = input.ContractMethodName,
ExpiredTime = input.ExpiredTime,
Params = input.Params,
ToAddress = input.ToAddress,
OrganizationAddress = input.OrganizationAddress,
ProposalId = hash,
Proposer = Context.Sender
};
Assert(Validate(proposal), "Invalid proposal.");
//TODO: Proposals with the same input is not supported.
Assert(State.Proposals[hash] == null, "Proposal already exists.");
State.Proposals[hash] = proposal;
return(hash);
}
public ProposalInfoReturn GetProposalInfo(SvcHdr svcHdr, AppHdr appHdr, ProposalInfo appBody)
{
ProposalInfoReturn svcReturn = new ProposalInfoReturn();
svcReturn.SvcHdr.RCODE = "F";
try
{
ProposalBonusEntity Proposal = new ProposalBonusEntity();
Proposal.ResetForSearch();
Proposal.SqlCustomer = " and CreateDate between '" + appBody.Startime.ToString() + "' and '" + appBody.Endtime.ToString() + "' ";
Proposal.PageSize = 0;
List <ProposalBonusEntity> list = Proposal.ToList <ProposalBonusEntity>();
foreach (var obj in list)
{
ProposalInfoReturn.ProposalInfoBodyObj tmp = new ProposalInfoReturn.ProposalInfoBodyObj();
StringUtil.SetObjectPro(obj, tmp);
svcReturn.AppBody.ListProposalInfo.Add(tmp);
}
svcReturn.AppBody.DataSetXml = StringUtil.ConvertDataSetToXML(Proposal.Dt.DataSet);
svcReturn.AppBody.RecordCount = Proposal.RecordCount;
svcReturn.SvcHdr.RCODE = "S";
}
catch (Exception ex)
{
svcReturn.SvcHdr.RDESC = ex.Message;
}
//StringUtil.SetObjectPro(obj, tmp);
return(svcReturn);
}
private bool IsReleaseThresholdReached(ProposalInfo proposal, Organization organization)
{
var proposalReleaseThreshold = organization.ProposalReleaseThreshold;
var enoughVote = proposal.RejectionCount.Add(proposal.AbstentionCount).Add(proposal.ApprovalCount) >=
proposalReleaseThreshold.MinimalVoteThreshold;
if (!enoughVote)
{
return(false);
}
var isRejected = proposal.RejectionCount > proposalReleaseThreshold.MaximalRejectionThreshold;
if (isRejected)
{
return(false);
}
var isAbstained = proposal.AbstentionCount > proposalReleaseThreshold.MaximalAbstentionThreshold;
if (isAbstained)
{
return(false);
}
return(proposal.ApprovalCount >= proposalReleaseThreshold.MinimalApprovalThreshold);
}
private Hash CreateNewProposal(CreateProposalInput input)
{
Hash proposalId = Hash.FromTwoHashes(Hash.FromTwoHashes(Hash.FromMessage(input), Context.TransactionId),
Hash.FromRawBytes(Context.CurrentBlockTime.ToByteArray()));
Assert(State.Proposals[proposalId] == null, "Proposal already exists.");
var proposal = new ProposalInfo
{
ContractMethodName = input.ContractMethodName,
ToAddress = input.ToAddress,
ExpiredTime = input.ExpiredTime,
Params = input.Params,
OrganizationAddress = input.OrganizationAddress,
Proposer = Context.Sender,
ProposalDescriptionUrl = input.ProposalDescriptionUrl
};
Assert(Validate(proposal), "Invalid proposal.");
State.Proposals[proposalId] = proposal;
Context.Fire(new ProposalCreated {
ProposalId = proposalId
});
return(proposalId);
}
private Hash CreateNewProposal(CreateProposalInput input)
{
Hash proposalId = GenerateProposalId(input);
var proposal = new ProposalInfo
{
ContractMethodName = input.ContractMethodName,
ExpiredTime = input.ExpiredTime,
Params = input.Params,
ToAddress = input.ToAddress,
OrganizationAddress = input.OrganizationAddress,
ProposalId = proposalId,
Proposer = Context.Sender,
ProposalDescriptionUrl = input.ProposalDescriptionUrl
};
Assert(Validate(proposal), "Invalid proposal.");
Assert(State.Proposals[proposalId] == null, "Proposal already exists.");
State.Proposals[proposalId] = proposal;
Context.Fire(new ProposalCreated
{
ProposalId = proposalId,
OrganizationAddress = input.OrganizationAddress
});
return(proposalId);
}
// GET: /ProposalInfo/View/1
//Social Service, Replication ...
public ActionResult ReportByGrantType(int?id)
{
if (!id.HasValue)
{
return(RedirectToAction("Index"));
}
//Reports Generated Here...
//report(id.Value);
//---------------------
//LEFT COLUMN. REPPERs
IEnumerable <ReportPeriodListR> reps = budservice.GetFinPeriods(id.Value);
//RIGHT COLUMN PAYMENTS.
List <BudgetPaymentReport> _bpayrep = report(id.Value);
ProposalInfo propInfo = projservice.GetProposalInfoOnly(id.Value);
ProjectInfo projinfo = projservice.GetProjInfoOnly(id.Value);
//(List<BudgetPaymentReport> _bpayrep, ProposalInfo _propInfo, ProjectInfo _projInfo)
FinReportsByGrantTypeView finrepbygranttype = new FinReportsByGrantTypeView(_bpayrep, propInfo, projinfo);
finrepbygranttype.InflateReport();
ViewData["finrepbygranttype"] = finrepbygranttype;
// ViewData["PaymentReports"] = report(id.Value);
return(View());
}
private bool IsProposalRejected(ProposalInfo proposal, Organization organization)
{
var rejectionMemberCount =
proposal.Rejections.Count(organization.OrganizationMemberList.Contains);
return(rejectionMemberCount > organization.ProposalReleaseThreshold.MaximalRejectionThreshold);
}
public override Hash CreateProposal(CreateProposalInput input)
{
var organization = State.Organisations[input.OrganizationAddress];
Assert(organization != null, "No registered organization.");
AssertSenderIsAuthorizedProposer(organization);
Hash hash = Hash.FromTwoHashes(Hash.FromMessage(input), Context.TransactionId);
var proposal = new ProposalInfo
{
ContractMethodName = input.ContractMethodName,
ExpiredTime = input.ExpiredTime,
Params = input.Params,
ToAddress = input.ToAddress,
OrganizationAddress = input.OrganizationAddress,
ProposalId = hash,
Proposer = Context.Sender
};
Assert(Validate(proposal), "Invalid proposal.");
Assert(State.Proposals[hash] == null, "Proposal already exists.");
State.Proposals[hash] = proposal;
Context.Fire(new ProposalCreated {
ProposalId = hash
});
return(hash);
}
public ActionMessage createProposal(ProposalInfo _Proposal, string _userI)
{
ActionMessage ret = new ActionMessage();
SqlConnectionFactory sqlConnection = new SqlConnectionFactory();
using (SqlConnection connection = sqlConnection.GetConnection())
{
try
{
int year = DateTime.Now.Year;
int maxPropCode = ProposalDataLayer.GetInstance().GetMaxPropCode(connection, year);
string departmentCode = DepartmentDataLayer.GetInstance().GetDepartmentCodeById(connection, _Proposal.DepartmentID);
_Proposal.ProposalCode = departmentCode + year.ToString() + maxPropCode;
ret.id = ProposalDataLayer.GetInstance().InsertProposal(connection, _Proposal, _userI);
ProposalDataLayer.GetInstance().UpdateMaxCode(connection, maxPropCode, year);
ret.isSuccess = true;
}
catch (Exception ex)
{
ret.isSuccess = false;
ret.err.msgCode = "Internal Error";
ret.err.msgString = ex.Message;
}
}
return(ret);
}
private void AssertProposalNotYetVotedBySender(ProposalInfo proposal, Address sender)
{
var isAlreadyVoted = proposal.Approvals.Contains(sender) || proposal.Rejections.Contains(sender) ||
proposal.Abstentions.Contains(sender);
Assert(!isAlreadyVoted, "Sender already voted.");
}
public ProposalRepository()
{
sqlcmd = SqlFactory.MSSQL();
prop = new Proposal();
propinfo = new ProposalInfo();
// ...MoreComing.
}
private bool Validate(ProposalInfo proposal)
{
var validDestinationAddress = proposal.ToAddress != null;
var validDestinationMethodName = !string.IsNullOrWhiteSpace(proposal.ContractMethodName);
var validExpiredTime = proposal.ExpiredTime != null && Context.CurrentBlockTime < proposal.ExpiredTime;
return(validDestinationAddress && validDestinationMethodName && validExpiredTime);
}
private bool IsProposalAbstained(ProposalInfo proposal, Organization organization,
ICollection <Address> parliamentMembers)
{
var abstentionMemberCount = proposal.Abstentions.Count(parliamentMembers.Contains);
return(abstentionMemberCount * AbstractVoteTotal >
organization.ProposalReleaseThreshold.MaximalAbstentionThreshold * parliamentMembers.Count);
}
private bool Validate(ProposalInfo proposal)
{
var validDestinationAddress = proposal.ToAddress != null;
var validDestinationMethodName = !string.IsNullOrWhiteSpace(proposal.ContractMethodName);
var validExpiredTime = CheckProposalNotExpired(proposal);
var hasOrganizationAddress = proposal.OrganizationAddress != null;
return(validDestinationAddress && validDestinationMethodName && validExpiredTime && hasOrganizationAddress);
}
private bool IsReadyToRelease(ProposalInfo proposal, Organization organization,
IEnumerable <Address> representatives)
{
var validApprovalWeights = proposal.ApprovedRepresentatives.Aggregate(0,
(weights, address) =>
weights + (representatives.FirstOrDefault(r => r.Equals(address)) == null ? 0 : 1));
return(validApprovalWeights * 10000 >= organization.ReleaseThreshold * representatives.Count());
}
private bool IsVoteThresholdReached(ProposalInfo proposal, Organization organization,
ICollection <Address> parliamentMembers)
{
var isVoteThresholdReached =
proposal.Abstentions.Concat(proposal.Approvals).Concat(proposal.Rejections)
.Count(parliamentMembers.Contains) * AbstractVoteTotal >=
organization.ProposalReleaseThreshold.MinimalVoteThreshold * parliamentMembers.Count;
return(isVoteThresholdReached);
}
private bool Validate(ProposalInfo proposal)
{
if (proposal.ToAddress == null || string.IsNullOrWhiteSpace(proposal.ContractMethodName) ||
!ValidateDescriptionUrlScheme(proposal.ProposalDescriptionUrl))
{
return(false);
}
return(proposal.ExpiredTime != null && Context.CurrentBlockTime < proposal.ExpiredTime);
}
private bool IsReleaseThresholdReached(ProposalInfo proposal, Organization organization,
IEnumerable <Address> currentRepresentatives)
{
var currentParliament = new HashSet <Address>(currentRepresentatives);
var approvalsCollectedFromCurrentParliament =
proposal.ApprovedRepresentatives.Count(a => currentParliament.Contains(a));
// approved >= (threshold/max) * representativeCount
return(approvalsCollectedFromCurrentParliament * MaxThreshold >=
organization.ReleaseThreshold * currentParliament.Count);
}
public ProposalInfo getProposalbyId(int _ID, string _userID)
{
SqlConnectionFactory sqlConnection = new SqlConnectionFactory();
using (SqlConnection connection = sqlConnection.GetConnection())
{
List <ProposalInfo> ListProposal = ProposalDataLayer.GetInstance().GetAllProposal(connection, _userID);
ProposalInfo findProposal = ListProposal.Where(i => i.ProposalID == _ID).First();
return(findProposal);
}
}
public ProposalInfo GetDetail(string id)
{
SqlConnectionFactory sqlConnection = new SqlConnectionFactory();
ProposalInfo record = new ProposalInfo();
using (SqlConnection connection = sqlConnection.GetConnection())
{
//record = PracticeDataLayer.GetInstance().GetUser(connection, id);
return(null);
}
}
private bool IsReleaseThresholdReached(ProposalInfo proposal, Organization organization)
{
var isRejected = IsProposalRejected(proposal, organization);
if (isRejected)
{
return(false);
}
var isAbstained = IsProposalAbstained(proposal, organization);
return(!isAbstained && CheckEnoughVoteAndApprovals(proposal, organization));
}
public async Task <ActionMessage> Put(int id, [FromForm] ProposalInfo _proposal, [FromForm] List <IFormFile> files)
{
ActionMessage ret = new ActionMessage();
ret.isSuccess = true;
try
{
ret = ProposalService.GetInstance().editProposal(id, _proposal, GetUserId());
//update list file
//ProposalService.GetInstance().DelteDocument(id.ToString());
if (ret.isSuccess == false)
{
return(ret);
}
//++edit item
ret = ProposalService.GetInstance().EditItems(id, _proposal.Items);
if (ret.isSuccess == false)
{
return(ret);
}
//++EDIT document
//delete old document
DocumentService.GetInstance().DeleteDocumentsNotExitsInList(_proposal.Documents, TableFile.Proposal.ToString(), id);
//add new document
foreach (var item in files)
{
DocumentInfo documentInfo = new DocumentInfo();
documentInfo.TableName = TableFile.Proposal.ToString();
documentInfo.PreferId = id.ToString();
documentInfo.FileName = item.FileName;
documentInfo.Link = DateTime.Now.ToString("yyMMddHHmmssfff") + "-" + Utils.ChuyenTVKhongDau(item.FileName);
documentInfo.Length = item.Length.ToString();
documentInfo.Type = item.ContentType;
ret = await FilesHelpers.UploadFile(TableFile.Proposal.ToString(), _proposal.ProposalID.ToString(), item, documentInfo.Link);
DocumentService.GetInstance().InsertDocument(documentInfo, GetUserId());
}
//--EDIT document
}
catch (Exception ex)
{
ret.isSuccess = false;
ret.err.msgCode = "Internal Error !!!";
ret.err.msgString = ex.ToString();
}
return(ret);
}
public async Task <ActionMessage> PostwithAttFile([FromForm] ProposalInfo propsalObj, [FromForm] List <IFormFile> files)
{
ActionMessage ret = new ActionMessage();
int insetId = -1;
try
{
ret.isSuccess = true;
insetId = ProposalService.GetInstance().createProposal2(propsalObj, GetUserId());
if (insetId > -1)
{
// upload file
//ret = await FilesHelpers.UploadFiles("proposal", insetId.ToString(), files);
// update list file
ret = ProposalService.GetInstance().insertItems(insetId, propsalObj.Items, propsalObj.DateIn, propsalObj.DepartmentID);
if (ret.isSuccess == false)
{
return(ret);
}
foreach (var item in files)
{
DocumentInfo documentInfo = new DocumentInfo();
documentInfo.TableName = TableFile.Proposal.ToString();
documentInfo.PreferId = insetId.ToString();
documentInfo.Link = DateTime.Now.ToString("yyMMddHHmmssfff") + "-" + Utils.ChuyenTVKhongDau(item.FileName);
documentInfo.FileName = item.FileName;
documentInfo.Length = item.Length.ToString();
documentInfo.Type = item.ContentType;
ret = await FilesHelpers.UploadFile(TableFile.Proposal.ToString(), insetId.ToString(), item, documentInfo.Link);
DocumentService.GetInstance().InsertDocument(documentInfo, GetUserId());
}
}
else
{
ret.isSuccess = false;
ret.err.msgCode = "lỗi thêm proposal";
ret.err.msgString = "lỗi thêm proposal";
}
}
catch (Exception ex)
{
ret.isSuccess = false;
ret.err.msgCode = "Internal Error !!!";
ret.err.msgString = ex.ToString();
}
return(ret);
}
public ActionMessage Put(int id, [FromForm] ProposalInfo _proposal)
{
ActionMessage ret = new ActionMessage();
try
{
ret = ProposalService.GetInstance().editProposal(id, _proposal, GetUserId());
}
catch (Exception ex)
{
ret.isSuccess = false;
ret.err.msgCode = "Internal Error !!!";
ret.err.msgString = ex.ToString();
}
return(ret);
}
public ActionMessage Post([FromBody] ProposalInfo _proposal)
{
ActionMessage ret = new ActionMessage();
try
{
string user = GetUserId();
ret = ProposalService.GetInstance().createProposal(_proposal, user);
}
catch (Exception ex)
{
ret.isSuccess = false;
ret.err.msgCode = "Internal Error !!!";
ret.err.msgString = ex.ToString();
}
return(ret);
}/*
private bool CheckEnoughVoteAndApprovals(ProposalInfo proposal, Organization organization,
ICollection <Address> parliamentMembers)
{
var approvedMemberCount = proposal.Approvals.Count(parliamentMembers.Contains);
var isApprovalEnough = approvedMemberCount * AbstractVoteTotal >=
organization.ProposalReleaseThreshold.MinimalApprovalThreshold *
parliamentMembers.Count;
if (!isApprovalEnough)
{
return(false);
}
var isVoteThresholdReached = IsVoteThresholdReached(proposal, organization, parliamentMembers);
return(isVoteThresholdReached);
}
private bool CheckEnoughVoteAndApprovals(ProposalInfo proposal, Organization organization)
{
var approvedMemberCount = proposal.Approvals.Count(organization.OrganizationMemberList.Contains);
var isApprovalEnough =
approvedMemberCount >= organization.ProposalReleaseThreshold.MinimalApprovalThreshold;
if (!isApprovalEnough)
{
return(false);
}
var isVoteThresholdReached =
proposal.Abstentions.Concat(proposal.Approvals).Concat(proposal.Rejections).Count() >=
organization.ProposalReleaseThreshold.MinimalVoteThreshold;
return(isVoteThresholdReached);
}
private bool IsProposalStillPending(ProposalInfo proposal, Organization organization,
ICollection <Address> parliamentMembers)
{
var isRejected = IsProposalRejected(proposal, organization, parliamentMembers);
if (isRejected)
{
return(false);
}
var isAbstained = IsProposalAbstained(proposal, organization, parliamentMembers);
if (isAbstained)
{
return(false);
}
return(!CheckEnoughVoteAndApprovals(proposal, organization, parliamentMembers));
}
private bool IsReleaseThresholdReached(ProposalInfo proposal, Organization organization)
{
var parliamentMembers = GetCurrentMinerList();
var isRejected = IsProposalRejected(proposal, organization, parliamentMembers);
if (isRejected)
{
return(false);
}
var isAbstained = IsProposalAbstained(proposal, organization, parliamentMembers);
if (isAbstained)
{
return(false);
}
return(CheckEnoughVoteAndApprovals(proposal, organization, parliamentMembers));
}
public int createProposal2(ProposalInfo _Proposal, string _userI)
{
int ret = -1;
SqlConnectionFactory sqlConnection = new SqlConnectionFactory();
using (SqlConnection connection = sqlConnection.GetConnection())
{
try
{
int year = DateTime.Now.Year;
int maxPropCode = ProposalDataLayer.GetInstance().GetMaxPropCode(connection, year);
string departmentCode = DepartmentDataLayer.GetInstance().GetDepartmentCodeById(connection, _Proposal.DepartmentID);
_Proposal.ProposalCode = departmentCode + year.ToString() + maxPropCode.ToString().PadLeft(4, '0');
UserLogInfo info = new UserLogInfo();
info.Action = "Insert";
info.Description = "ngày : " + _Proposal.DateIn + " khoa/phòng chịu trách nhiệm ID " + _Proposal.CurDepartmentID + " code " + _Proposal.ProposalCode
+ " khoa phòng đề xuất ID : " + _Proposal.DepartmentID + " trạng thái : " + _Proposal.Status;
info.Feature = TableFile.Proposal.ToString();
info.Time = DateTime.Now;
info.UserName = _userI;
info.UserID = 1;
UserService.GetInstance().TrackUserAction(info);
ret = ProposalDataLayer.GetInstance().InsertProposal(connection, _Proposal, _userI);
ProposalDataLayer.GetInstance().UpdateMaxCode(connection, maxPropCode, year);
// ret.isSuccess = true;
}
catch (Exception ex)
{
throw ex;
}
}
return(ret);
}
