public IHttpActionResult Get([FromUri] ProposalRequest proposalRequest)
{
var isLogin = Login(proposalRequest.Token);
if (!isLogin)
{
return(Content(System.Net.HttpStatusCode.Unauthorized, "Unauthorized"));
}
if (ModelState.IsValid)
{
var hash = proposalRequest.GetHashCode().ToString();
var obj = memoryCache.Get(hash);
if (obj != null)
{
return(Json((ProposalResponse)obj));
}
var filter = Filter(proposalRequest);
return(Json(_proposalManager.Read(filter).Skip(proposalRequest.Skip).Take(proposalRequest.Take).ToList()));
}
else
{
return(BadRequest(ModelState));
}
}
private void storeProposal(ProposalRequest request, LeaderState state)
{
if (!leadersOrReplicasAskedVoteForThisSlot(request.SlotNumber, state))
{
state.ProposalsBySlotId.Add(request.SlotNumber, request.Command);
}
}
public static Proposal Convert(this ProposalRequest request)
{
return(new Proposal
{
Id = request.Id,
Name = request.Name
});
}
private Expression <Func <Proposal, bool> > Filter(ProposalRequest model)
{
var filter = PredicateBuilder.True <Proposal>();
if (!string.IsNullOrEmpty(model.Name))
{
filter = filter.AndAlso(x => x.Name.Contains(model.Name));
}
return(filter);
}
public void Execute(MessageStrategyExecuteArg <IMessage> obj)
{
if (!(obj.Message is ProposalRequest))
{
throw new MessageStrategyException("This strategy shouldn't be invoked with this message type");
}
ProposalRequest request = obj.Message as ProposalRequest;
LeaderState state = obj.RoleState as LeaderState;;
storeProposal(request, state);
OnProposalReceived?.Invoke(this, EventArgs.Empty);
}
public async Task Handle(ProposalRequest message)
{
if (!IsNew)
{
return;
}
Data.CustomerName = message.Name;
Data.CustomerEmail = message.Email;
await _bus.Send(new CreateProposal()
{
Name = message.Name, Email = message.Email
});
}
public override Task <Empty> Proposal(ProposalRequest request, ServerCallContext context)
{
_bus.Publish(new ElectionMessage.Proposal(
Uuid.FromDto(request.ServerId).ToGuid(),
new IPEndPoint(IPAddress.Parse(request.ServerInternalHttp.Address), (int)request.ServerInternalHttp.Port),
Uuid.FromDto(request.LeaderId).ToGuid(),
new IPEndPoint(IPAddress.Parse(request.LeaderInternalHttp.Address), (int)request.LeaderInternalHttp.Port),
request.View,
request.EpochNumber,
request.EpochPosition,
Uuid.FromDto(request.EpochId).ToGuid(),
request.LastCommitPosition,
request.WriterCheckpoint,
request.ChaserCheckpoint,
request.NodePriority));
return(EmptyResult);
}
private void sendProposalsToLeaders(ClientRequest request, ReplicaState state)
{
state.ProposalsRequestsBySlotId.Add(state.FirstUnusedSlot, request);
state.ClientsPendingResponseBySlotId.Add(state.FirstUnusedSlot, request);
ProposalRequest proposal = new ProposalRequest();
proposal.SlotNumber = state.FirstUnusedSlot;
proposal.Command = request.Command;
proposal.MessageSender = state.MessageSender;
foreach (MessageSender leader in state.Leaders)
{
this.broker.SendMessage(leader.UniqueId, proposal);
}
state.FirstUnusedSlot++;
}
public IHttpActionResult Delete([FromBody] ProposalRequest proposalRequest)
{
var isLogin = Login(proposalRequest.Token);
if (!isLogin)
{
return(Content(System.Net.HttpStatusCode.Unauthorized, "Unauthorized"));
}
if (ModelState.IsValid)
{
_proposalManager.Delete(proposalRequest.Convert());
return(Ok());
}
else
{
return(BadRequest(ModelState));
}
}
private async Task SendProposalAsync(Guid serverId, IPEndPoint serverInternalHttp, Guid leaderId,
IPEndPoint leaderInternalHttp, int view, int epochNumber, long epochPosition, Guid epochId,
long lastCommitPosition, long writerCheckpoint, long chaserCheckpoint, int nodePriority,
DateTime deadline)
{
var request = new ProposalRequest {
ServerId = Uuid.FromGuid(serverId).ToDto(),
ServerInternalHttp = new EndPoint(serverInternalHttp.Address.ToString(), (uint)serverInternalHttp.Port),
LeaderId = Uuid.FromGuid(leaderId).ToDto(),
LeaderInternalHttp = new EndPoint(leaderInternalHttp.Address.ToString(), (uint)leaderInternalHttp.Port),
View = view,
EpochNumber = epochNumber,
EpochPosition = epochPosition,
EpochId = Uuid.FromGuid(epochId).ToDto(),
LastCommitPosition = lastCommitPosition,
WriterCheckpoint = writerCheckpoint,
ChaserCheckpoint = chaserCheckpoint,
NodePriority = nodePriority
};
await _electionsClient.ProposalAsync(request, deadline : deadline.ToUniversalTime());
}
public override async Task <Empty> Proposal(ProposalRequest request, ServerCallContext context)
{
var user = context.GetHttpContext().User;
if (!await _authorizationProvider.CheckAccessAsync(user, ProposalOperation, context.CancellationToken).ConfigureAwait(false))
{
throw AccessDenied();
}
_bus.Publish(new ElectionMessage.Proposal(
Uuid.FromDto(request.ServerId).ToGuid(),
new IPEndPoint(IPAddress.Parse(request.ServerInternalHttp.Address), (int)request.ServerInternalHttp.Port),
Uuid.FromDto(request.LeaderId).ToGuid(),
new IPEndPoint(IPAddress.Parse(request.LeaderInternalHttp.Address), (int)request.LeaderInternalHttp.Port),
request.View,
request.EpochNumber,
request.EpochPosition,
Uuid.FromDto(request.EpochId).ToGuid(),
request.LastCommitPosition,
request.WriterCheckpoint,
request.ChaserCheckpoint,
request.NodePriority));
return(EmptyResult);
}
public void AddProposalRequestTest()
{
// Create a new ProposalRequest
Project project = ProjectService.GetAllProjects()[0];
ProposalRequest pr = new ProposalRequest(project.Key, 2);
pr.From = EmployeeService.GetEmployees()[0];
pr.Contractor = CompanyService.GetAllCompanies()[0];
pr.To = project.Contacts[0];
this.repository.SetUnitOfWork(this.unitOfWork);
// Add the ProposalRequest to the Repository
this.repository.Add(pr);
// Commit the transaction
this.unitOfWork.Commit();
// Reload the ProposalRequest and verify it's number
ProposalRequest savedPr =
this.repository.FindBy(pr.Key);
Assert.AreEqual(2, savedPr.Number);
}
public void FindProposalRequestByKeyTest()
{
ProposalRequest pr = this.repository.FindBy("d41f41e1-47c6-43fc-ae82-e1eed25efa44");
Assert.AreEqual(1, pr.Number);
}
