public override bool ProcessContract(ParticipantHandler participantHandler, List <Chain> chains)
{
if (ValidateContextual(participantHandler, chains))
{
var k = participantHandler.CountSimilarPatients(Country, Region, Birthyear);
if (k < 3)
{
throw new TransactionParkedException();
}
else
{
participantHandler.AddPatient(new Patient()
{
Address = TransactionId
,
Country = Country
,
Region = Region
,
Birthyear = Birthyear
});
return(true);
}
}
return(false);
}
protected void ParticipantList_Click(object sender, EventArgs e)
{
LinkButton btn = (LinkButton)sender;
//Response.Write(btn.CommandArgument);
int participantid = Convert.ToInt32(btn.CommandArgument);
int userLoggedId = -1;
HttpCookie c1 = Request.Cookies["UserID"];
if (c1 == null)
{
//Do nothing
}
else
{
// not add the same user
userLoggedId = Convert.ToInt32(c1.Value);
Participant participant = ParticipantHandler.getInstance().Recover(participantid);
if (userLoggedId != participant.GetId())
{
participantFactory.addItem(participant);
DataListParticipantsSelected.DataBind();
}
}
/*
* Application["regNo"] = Convert.ToInt32(btn.Text);
* Response.Redirect("EditClub.aspx");*/
}
public bool ProcessContracts(ParticipantHandler participantHandler, List <Chain> context)
{
var ret = true;
foreach (var t in TransactionList)
{
try
{
ret &= t.ProcessContract(participantHandler, context);
} catch (TransactionParkedException)
{
ret &= true;
if (t.GetType() == typeof(PatientRegistrationTransaction))
{
var prt = (PatientRegistrationTransaction)t;
participantHandler.AddPatient(new Entities.Patient()
{
Address = prt.TransactionId,
Country = prt.Country,
Region = prt.Region,
Birthyear = prt.Birthyear
});
}
}
}
return(ret);
}
public override bool ValidateContextual(ParticipantHandler participantHandler, List <Chain> chains)
{
return
((participantHandler.IsEmpty() && participantHandler.IsVotablePublisher(TransactionAddress)) ||
((participantHandler.IsVotablePublisher(TransactionAddress) || participantHandler.IsVotablePhysician(TransactionAddress)) &&
participantHandler.HasSender(SenderAddress) &&
ValidateTransactionIntegrity(participantHandler.GetSenderKey(SenderAddress))));
}
public void UpdateChain(Chain chain)
{
participantHandler = new ParticipantHandler();
chain.ProcessContracts(participantHandler, new List <Chain>()
{
chain
});
}
//Will be only one instance
public static ParticipantHandler getInstance()
{
if (instance == null)
{
instance = new ParticipantHandler();
}
return(instance);
}
public override bool ValidateContextual(ParticipantHandler participantHandler, List <Chain> chains)
{
var ret = participantHandler.HasSender(SenderAddress) &&
ValidateTransactionIntegrity(participantHandler.GetSenderKey(SenderAddress));
ret &= participantHandler.HasSender(PhysicianAddress) && participantHandler.HasPatient(PatientAddress);
return(ret);
}
new public bool LoadChain()
{
var success = base.LoadChain();
if (success)
{
participantHandler_Buffered = participantHandler.Clone();
}
return(success);
}
public bool LoadChain()
{
chain = new Chain(FileHandler.Read(User.Username + FileHandler.ChainPath));
participantHandler = new ParticipantHandler();
var success = chain.ProcessContracts(participantHandler, new List <Chain>()
{
chain
});
return(success);
}
public bool ProcessContracts(ParticipantHandler participantHandler, List <Chain> context)
{
var ret = true;
var blockList = GetBlocks();
foreach (var b in blockList)
{
ret &= b.ProcessContracts(participantHandler, context);
}
return(ret);
}
protected void ParticipantList_Click(object sender, EventArgs e)
{
LinkButton btn = (LinkButton)sender;
//Response.Write(btn.CommandArgument);
Participant participant = ParticipantHandler.getInstance().Recover(Convert.ToInt32(btn.CommandArgument));
participantFactory.addItem(participant);
DataListParticipantsSelected.DataBind();
/*
* Application["regNo"] = Convert.ToInt32(btn.Text);
* Response.Redirect("EditClub.aspx");*/
}
public void UpdateChain()
{
if (!IsChainInitialized())
{
var initialized = false;
foreach (var n in knownNodes)
{
try
{
chain = new QueryClient(n).RequestFullChain();
initialized |= !chain.IsEmpty();
} catch (RpcException) { }
if (initialized)
{
break;
}
}
if (!initialized)
{
return;
}
participantHandler = new ParticipantHandler();
chain.ProcessContracts(participantHandler, new List <Chain>()
{
chain
});
}
long currentIndex = chain.Blockhead.Index;
foreach (var n in knownNodes)
{
try
{
var update = new QueryClient(n).RequestDeltaChain(currentIndex);
if (!update.IsEmpty())
{
update.ProcessContracts(participantHandler, new List <Chain>()
{
chain
});
chain.Add(update);
currentIndex = chain.Blockhead.Index;
}
} catch (RpcException) { }
}
}
public bool CastVoteForPublisher(ParticipantHandler participantHandler, Guid publisherAddress, Guid senderAddress)
{
//If the publisher has already been confirmed, do nothing
if (participantHandler.HasPublisher(publisherAddress))
{
return(true);
}
if (!(participantHandler.proposedPublishers.Where(p => p.Address == publisherAddress).Count() > 0))
{
return(false);
}
//If the publisher is still proposed
//Add Vote to list of votes (if not already present from the current sender)
var votesFromSender = from v in participantHandler.pendingVotes
where v.VoteFor == publisherAddress && v.VoteFrom == senderAddress
select v;
if (votesFromSender.Count() > 0)
{
var hit = votesFromSender.FirstOrDefault();
hit.Confirmed = true;
}
else
{
participantHandler.pendingVotes.Add(new Vote()
{
VoteFor = publisherAddress
,
VoteFrom = senderAddress
,
Confirmed = true
});
}
//Count list of valid votes for publisher => Valid votes must be more than half of currently confirmed publishers
//If publisher is confirmed: Transfer to confirmed publishers, remove all votes from list
var votesForPublisher = from v in participantHandler.pendingVotes
where v.VoteFor == publisherAddress && v.Confirmed
select v;
if (votesForPublisher.Count() > Math.Floor(participantHandler.pendingVotes.Count() / 2.0))
{
var tranfer = participantHandler.proposedPublishers.Where(p => p.Address == publisherAddress);
participantHandler.confirmedPublishers.AddRange(tranfer);
participantHandler.proposedPublishers.RemoveAll(p => p.Address == publisherAddress);
participantHandler.pendingVotes.RemoveAll(v => v.VoteFor == publisherAddress);
}
return(true);
}
public override bool ValidateContextual(ParticipantHandler participantHandler, List <Chain> chains)
{
var valid = false;
valid &= participantHandler.HasSender(SenderAddress) &&
ValidateTransactionIntegrity(participantHandler.GetSenderKey(SenderAddress));
foreach (var c in chains)
{
valid |= c.HasTransaction(TreatmentTransactionAddress);
}
return(valid);
}
public bool ValidateContextual(ParticipantHandler participantHandler, List <Chain> context) //context = Hauptchain, falls gerade eine neu Empfangen Teilchain verarbeitet wird
{
context = (context == null) ? new List <Chain>() : context;
context.Add(this);
var ret = true;
var blockList = GetBlocks();
foreach (var b in blockList)
{
ret &= b.ValidateContextual(participantHandler, context);
}
return(ret);
}
protected void ButtonCreateAccount_Click(object sender, EventArgs e)
{
if (!AuthenticationHandler.getInstance().ExistsEmail(TextBoxUser.Text) && checkNumber(TextBoxAddressNumber.Text))
{
int key = ParticipantHandler.getInstance().InsertParticipant(TextBoxName.Text, TextBoxUser.Text, TextBoxPassword.Text, 'P',
TextBoxAddress.Text, Int32.Parse(TextBoxAddressNumber.Text), TextBoxZipCode.Text, TextBoxCity.Text, DropDownListProvince.Text, "Canada");
if (key == -1)
{
Response.Redirect("CreateAccountError.aspx");
}
else
{
Response.Redirect("CreateAccountSuccess.aspx");
}
}
}
public override bool ProcessContract(ParticipantHandler participantHandler, List <Chain> chains)
{
if (!ValidateContextual(participantHandler, chains))
{
return(false);
}
if (participantHandler.IsEmpty() && participantHandler.IsVotablePublisher(TransactionAddress)) //For the first publisher in the chain
{
if (Vote)
{
return(participantHandler.CastVoteForPublisher(TransactionAddress, SenderAddress));
}
else
{
participantHandler.CastVoteAgainstPublisher(TransactionAddress, SenderAddress);
}
}
else if (participantHandler.IsVotablePublisher(TransactionAddress) && participantHandler.HasPublisher(SenderAddress))
{
if (Vote)
{
return(participantHandler.CastVoteForPublisher(TransactionAddress, SenderAddress));
}
else
{
participantHandler.CastVoteAgainstPublisher(TransactionAddress, SenderAddress);
}
}
else if (participantHandler.IsVotablePhysician(TransactionAddress) && participantHandler.HasSender(SenderAddress))
{
if (Vote)
{
participantHandler.CastVoteForPhysician(TransactionAddress, SenderAddress);
}
else
{
participantHandler.CastVoteAgainstPhysician(TransactionAddress, SenderAddress);
}
}
else
{
return(false);
}
return(true);
}
public override bool ProcessContract(ParticipantHandler participantHandler, List <Chain> chains)
{
if (ValidateContextual(participantHandler, chains))
{
var l = 5; //Count of distinct Symtpoms for the corresponding patient over all chains
if (l < 5)
{
participantHandler.ParkSymptom(this);
throw new TransactionParkedException();
}
return(true);
}
return(false);
}
public bool CastVoteAgainstPublisher(ParticipantHandler participantHandler, Guid publisherAddress, Guid senderAddress)
{
//If the publisher is not confirmed, do nothing
if (!participantHandler.HasPublisher(publisherAddress))
{
return(false);
}
//Add Vote to list of votes (if not already present from the current sender)
var votesFromSender = from v in participantHandler.pendingVotes
where v.VoteFor == publisherAddress && v.VoteFrom == senderAddress
select v;
if (votesFromSender.Count() > 0)
{
var hit = votesFromSender.FirstOrDefault();
hit.Confirmed = false;
}
else
{
participantHandler.pendingVotes.Add(new Vote()
{
VoteFor = publisherAddress
,
VoteFrom = senderAddress
,
Confirmed = false
});
}
//Count list of valid votes against publisher => Valid votes must be more than half of currently confirmed publishers
//If publisher is dismissed: Delete from List
var votesAgainstPublisher = from v in participantHandler.pendingVotes
where v.VoteFor == publisherAddress && !v.Confirmed
select v;
if (votesAgainstPublisher.Count() > Math.Floor(participantHandler.confirmedPublishers.Count() / 2.0))
{
participantHandler.confirmedPublishers.RemoveAll(p => p.Address == publisherAddress);
participantHandler.pendingVotes.RemoveAll(v => v.VoteFor == publisherAddress);
}
return(true);
}
public override bool ProcessContract(ParticipantHandler participantHandler, List <Chain> chains)
{
if (ValidateContextual(participantHandler, chains))
{
participantHandler.ProposePublisher(new Publisher()
{
Address = TransactionId
,
PublicKey = PublicKey
,
Country = Country
,
Region = Region
,
EntityName = EntityName
});
return(true);
}
return(false);
}
public ParticipantCreatorViewModel()
{
NewParticipant = new Participant();
CreateParticipantCommand = new RelayCommand(() => ParticipantHandler.CreateParticipant(NewParticipant), () => NewParticipant != null);
}
public override bool ValidateContextual(ParticipantHandler participantHandler, List <Chain> chains)
{
return(SenderAddress == TransactionId &&
ValidateTransactionIntegrity(PublicKey) &&
!participantHandler.HasPublisher(TransactionId));
}
public override bool ProcessContract(ParticipantHandler participantHandler, List <Chain> chains)
{
return(ValidateContextual(participantHandler, chains));
}
public void PublishOpenBlocks(object state)
{
//TODO Überprüfen, ob Node überhaupt publishen darf (Registrierung eines neuen Publishers muss durchgehen)
manipulateBufferedTransactions.WaitOne();
manipulateChain.WaitOne();
Chain appendix = null;
if (transactionBuffer.HasBlocks())
{
appendix = new Chain();
while (transactionBuffer.HasBlocks())
{
var nextBlock = transactionBuffer.GetNextBlock();
nextBlock.Publisher = User.UserAddress;
if (chain.IsEmpty())
{
nextBlock.Index = 0;
nextBlock.PreviousBlock = null;
nextBlock.PreviousHash = null;
}
else if (appendix.IsEmpty())
{
nextBlock.Index = chain.Blockhead.Index + 1;
nextBlock.PreviousHash = chain.Blockhead.Hash;
}
else
{
nextBlock.Index = appendix.Blockhead.Index + 1;
nextBlock.PreviousBlock = appendix.Blockhead;
nextBlock.PreviousHash = appendix.Blockhead.Hash;
}
nextBlock.Sign(User.Keys.PrivateKey);
appendix.Add(nextBlock);
}
var success = appendix.ProcessContracts(participantHandler, new List <Chain>()
{
chain
});
participantHandler_Buffered = participantHandler.Clone();
foreach (var n in knownNodes)
{
try
{
new PublisherClient(n, selfAddress).SendChain(appendix);
}
catch (RpcException)
{ //TODO Nodes flaggen, von denen keine Antwort kommt
}
}
CLI.DisplayLine("Published " + appendix.GetTransactions().Count + " transactions " + (success ? "successfully" : "unsuccessfully"));
chain.Add(appendix);
}
manipulateChain.Release();
manipulateBufferedTransactions.Release();
}
//Returns whether or not the chain has been added to the blockchain
public bool OnReceiveChain(Chain chain)
{
var success = false;
var transactions = chain.GetTransactions();
manipulateBufferedTransactions.WaitOne();
manipulateChain.WaitOne();
var participantHandler_Clone = participantHandler.Clone();
success = chain.ValidateContextual(participantHandler_Clone, new List <Chain>()
{
this.chain
});
if (success)
{
var deletedBlocks = this.chain.Add(chain);
var bufferedTransactions = transactionBuffer.Peek().GetTransactions();
var receivedTransaction = chain.GetTransactions();
foreach (var b in deletedBlocks)
{
foreach (var t in b.TransactionList)
{
if (!bufferedTransactions.Where(bt => bt.TransactionId == t.TransactionId).Any() ||
!receivedTransaction.Where(rt => rt.TransactionId == t.TransactionId).Any())
{
transactionBuffer.RecordTransaction(t);
}
}
}
var transactionsToUnbuffer = bufferedTransactions.Where(t => receivedTransaction.Where(rt => rt.TransactionId == t.TransactionId).Any());
foreach (var t in transactionsToUnbuffer)
{
transactionBuffer.UnrecordTransaction(t);
}
participantHandler = new ParticipantHandler();
this.chain.ProcessContracts(participantHandler, new List <Chain>()
{
});
participantHandler_Buffered = participantHandler.Clone();
transactionBuffer.Peek().ProcessContracts(participantHandler_Buffered, new List <Chain>()
{
this.chain
});
}
manipulateChain.Release();
manipulateBufferedTransactions.Release();
CLI.DisplayLine("Added " + transactions.Count + " transactions " + (success ? "successfully" : "unsuccessfully"));
foreach (var t in transactions)
{
CLI.DisplayLine("\t" + t.AsString());
}
return(success);
}
public abstract bool ProcessContract(ParticipantHandler participantHandler, List <Chain> context);
public abstract bool ValidateContextual(ParticipantHandler participantHandler, List <Chain> context);
public bool ValidateContextual(ParticipantHandler participantHandler, List <Chain> context)
{
var blockIsValid = true;
//Handle initializing block
if (Index == 0)
{
blockIsValid &= TransactionList.Count() == 2;
var registration = (from t in TransactionList
where t.GetType() == typeof(PublisherRegistrationTransaction)
select(PublisherRegistrationTransaction) t).FirstOrDefault();
var vote = (from t in TransactionList
where t.GetType() == typeof(VotingTransaction)
select(VotingTransaction) t).FirstOrDefault();
blockIsValid &= registration != null && vote != null;
blockIsValid &= ValidateBlockIntegrity(registration.PublicKey);
blockIsValid &= participantHandler.ProcessTransaction(registration, context);
blockIsValid &= participantHandler.ProcessTransaction(vote, context);
}
//Handle new Publisher registration
else if (TransactionList.Count() == 1 && TransactionList[0].GetType() == typeof(PublisherRegistrationTransaction))
{
var registration = (PublisherRegistrationTransaction)TransactionList[0];
blockIsValid &= ValidateBlockIntegrity(registration.PublicKey);
blockIsValid &= participantHandler.ProcessTransaction(registration, context);
}
//Handle regular block
else if (participantHandler.HasPublisher(Publisher))
{
blockIsValid &= ValidateBlockIntegrity(participantHandler.GetPublisherKey(Publisher));
foreach (var t in TransactionList)
{
if (t.GetType() == typeof(PhysicianRegistrationTransaction))
{
PhysicianRegistrationTransaction temp = (PhysicianRegistrationTransaction)t;
blockIsValid &= temp.ValidateTransactionIntegrity(temp.PublicKey);
blockIsValid &= participantHandler.ProcessTransaction(temp, context);
}
else if (participantHandler.HasSender(t.SenderAddress))
{
blockIsValid &= t.ValidateTransactionIntegrity(participantHandler.GetSenderKey(t.SenderAddress));
blockIsValid &= participantHandler.ProcessTransaction(t, context);
}
else
{
blockIsValid = false;
}
}
}
//Fallback - Block definitely invalid
else
{
blockIsValid = false;
}
return(blockIsValid);
}
