static Task SendHandlerMessage(IMessageSession endpointInstance)
{
Console.WriteLine();
Console.WriteLine("HandlerMessage sent");
var message = new HandlerMessage();
return endpointInstance.SendLocal(message);
}
public async Task SubmitOrder(string customer, string cartId)
{
var msg = new SendSubmitOrder
{
Customer = customer,
CartId = cartId,
};
await session.SendLocal(msg);
}
public async Task <dynamic> Propose(dynamic proposedPrice)
{
await _messageSession.SendLocal <ProposePriceCommand>(cmd =>
{
cmd.StockItemId = proposedPrice.StockItemId;
cmd.ProposedPrice = proposedPrice.Price;
});
return(proposedPrice.StockItemId);
}
static Task SendSagaMessage(IMessageSession endpointInstance)
{
Console.WriteLine();
Console.WriteLine("StartSagaMessage sent");
var message = new StartSagaMessage
{
SentTime = DateTimeOffset.UtcNow,
TheId = Guid.NewGuid()
};
return endpointInstance.SendLocal(message);
}
protected override async Task OnStart(IMessageSession session, CancellationToken cancellationToken = default)
{
using (var tx = new TransactionScope(TransactionScopeOption.RequiresNew, new TransactionOptions {
IsolationLevel = IsolationLevel.ReadCommitted
}, TransactionScopeAsyncFlowOption.Enabled))
{
await session.SendLocal(new MyMessage(), cancellationToken);
tx.Complete();
}
}
public async Task <ActionResult <Group> > CreateNewGroup(CreateGroupRequest req)
{
await _messageSession.SendLocal(new CreateNewGroup
{
GroupName = req.GroupName,
TournamentId = req.TournamentId,
TeamNames = req.TeamNames
});
return(Accepted());
}
public async Task <dynamic> Post(dynamic model)
{
await _messageSession.SendLocal <HeyIKnowThisIsWrongButSagaTrustMeDraftIsDoneCommand>(cmd =>
{
cmd.ProductDraftId = model.Id;
cmd.StockItemId = model.StockItemId;
cmd.Title = model.Title;
cmd.Description = model.Description;
});
return(model.Id);
}
static Task SendSagaMessage(IMessageSession endpointInstance)
{
Console.WriteLine();
Console.WriteLine("StartSagaMessage sent");
var message = new StartSagaMessage
{
SentTime = DateTimeOffset.UtcNow,
TheId = Guid.NewGuid()
};
return(endpointInstance.SendLocal(message));
}
public async Task <IActionResult> StartAsync([FromBody] StartProjectScoringRequest request)
{
var command = new StartScoring
{
ProjectId = request.ProjectId,
TransactionHash = request.TransactionHash,
UserId = User.GetUserId()
};
await _messageSession.SendLocal(command);
return(NoContent());
}
public async Task <IActionResult> UpdateExpertAreasAsync([FromBody] AdminExpertUpdateAreasRequest request)
{
var message = new UpdateExpertAreas
{
ExpertAddress = request.Address,
TransactionHash = request.TransactionHash,
UserId = User.GetUserId()
};
await _messageSession.SendLocal(message);
return(NoContent());
}
public async Task <ActionResult <Guid> > CreateNewTournament(CreateTournamentRequest req)
{
var tournamentId = Guid.NewGuid();
await _messageSession.SendLocal(new CreateNewTournament
{
TournamentId = tournamentId,
Name = req.Name,
Starts = req.Starts,
Ends = req.Ends
});
return(AcceptedAtAction(nameof(GetTournament), new { id = tournamentId }));
}
static async Task SendMessageLargePayload(IMessageSession messageSession)
{
Console.WriteLine("Sending message...");
var message = new MessageWithLargePayload
{
Description = "This message contains a large payload that will be sent on the Azure data bus",
LargePayload = new DataBusProperty <byte[]>(new byte[1024 * 1024 * 5]) // 5MB
};
await messageSession.SendLocal(message)
.ConfigureAwait(false);
Console.WriteLine("Message sent.");
}
protected override async Task ExecuteAsync(CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
try
{
//--- Eternal work here
await messageSession.SendLocal(null).ConfigureAwait(false);
}
catch (OperationCanceledException oEx)
{
LOG.Info("Unexpected cancellation", oEx);
}
}
}
public async Task <IActionResult> UpdateAsync(long id, [FromBody] UpdateAllotmentEventRequest request)
{
var command = new UpdateAllotmentEvent(
id,
request.TransactionHash,
AllotmentEventOperation.Delete,
User.GetUserId());
await _messageSession.SendLocal(command);
return(NoContent());
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
try
{
var number = 0;
while (!stoppingToken.IsCancellationRequested)
{
await messageSession.SendLocal(new MyMessage { Number = number++ })
.ConfigureAwait(false);
await Task.Delay(1000, stoppingToken).ConfigureAwait(false);
}
}
catch (OperationCanceledException)
{
// graceful shutdown
}
}
public async Task <EventHandledResponse> Handle(EventMetaData eventMetadata, AppMentionEvent slackEvent)
{
var debugDetails = MetaService.DebugInfo();
var debugInfo = $"▪️ v{debugDetails.MajorMinorPatch}\n" +
$"▪️ {debugDetails.Informational}\n";
var releaseNotes = await GitHubReleaseService.GetReleaseNotes(debugDetails.MajorMinorPatch);
if (!string.IsNullOrEmpty(releaseNotes))
{
debugInfo += releaseNotes;
}
else if (debugDetails.Sha != "0")
{
debugInfo += $"️▪️ <https://github.com/fplbot/fplbot/tree/{debugDetails.Sha}|{debugDetails.Sha?.Substring(0, debugDetails.Sha.Length - 1)}>\n";
}
await _session.SendLocal(new PublishToSlack(eventMetadata.Team_Id, slackEvent.Channel, debugInfo));
return(new EventHandledResponse("OK"));
}
public async Task Handle(HttpRequest request)
{
var requestData = new Dictionary <string, string>()
{
{ "sales-product-id", (string)request.HttpContext.GetRouteValue("id") },
{ "sales-quantity", request.Form["quantity"][0] },
};
var vm = request.GetComposedResponseModel();
await vm.RaiseEvent(new AddItemToCartRequested()
{
CartId = request.Cookies["cart-id"],
RequestId = request.Headers.GetComposedRequestId(),
RequestData = requestData
});
await messageSession.SendLocal(new AddToCartRequest()
{
RequestId = request.Headers.GetComposedRequestId(),
CartId = new Guid(request.Cookies["cart-id"]),
RequestData = requestData
});
}
public async Task Handle(string requestId, dynamic vm, RouteData routeData, HttpRequest request)
{
var requestData = new Dictionary <string, string>()
{
{ "sales-product-id", (string)routeData.Values["id"] },
{ "sales-quantity", request.Form["quantity"][0] },
};
await vm.RaiseEvent(new AddItemToCartRequested()
{
CartId = request.Cookies["cart-id"],
RequestId = requestId,
RequestData = requestData
});
await messageSession.SendLocal(new AddToCartRequest()
{
RequestId = requestId,
CartId = new Guid(request.Cookies["cart-id"]),
RequestData = requestData
});
}
async Task Loop(IMessageSession session)
{
int min, max;
lock (random)
{
min = random.Next(100);
max = random.Next(min, 1000);
}
while (!stop)
{
await session.SendLocal(new Ping()).ConfigureAwait(false);
int delay;
lock (random)
{
delay = random.Next(min, max);
}
await Task.Delay(TimeSpan.FromMilliseconds(delay)).ConfigureAwait(false);
}
}
public static async Task StartLoop(IMessageSession messageSession)
{
Console.WriteLine("Press [c] to send a command. Press [Esc] to exit.");
while (true)
{
var input = Console.ReadKey();
Console.WriteLine();
switch (input.Key)
{
case ConsoleKey.C:
await messageSession.SendLocal(
new CreateOrder
{
OrderId = Guid.NewGuid()
});
break;
case ConsoleKey.Escape:
return;
}
}
}
public async Task SubscribeToCounter(string counterID)
{
await _messageSession.SendLocal(new SubscribeToCounter { CounterID = counterID, ConnectionID = this.Context.ConnectionId });
}
protected override async Task OnStart(IMessageSession session, CancellationToken cancellationToken = default)
{
await BreakConnectionBySendingInvalidMessage(cancellationToken);
await session.SendLocal(new MyRequest { MessageId = context.MessageId }, cancellationToken);
}
protected override async Task OnStart(IMessageSession session)
{
await session.SendLocal(new MyMessage());
await Task.Delay(TimeSpan.FromSeconds(5));
}
public async Task Start(IMessageSession session)
{
await session.SendLocal(new MyMessage());
}
public async Task Handle(BonusAdded notification, CancellationToken cancellationToken)
{
await _session.SendLocal(new PublishToSlack("T0A9QSU83", "#johntest", $"Bonus added for matchday {notification.MatchDayDate:yyyy-MM-dd} in gw {notification.Event}"));
}
public Task Start(IMessageSession session)
{
var myMessage = new MyMessage();
return(session.SendLocal(myMessage));
}
protected override async Task OnStart(IMessageSession session, CancellationToken cancellationToken = default)
{
await session.SendLocal(new MyCommand(), cancellationToken);
await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken);
}
protected override Task AfterDispatch(IMessageSession session, SystemMessageTestContext context)
{
return(session.SendLocal(new DoQueryAllowed()));
}
public async Task Start(IMessageSession session)
{
await session.SendLocal(new MyMessage());
}
public Task SendLocal <T>(T message) => messageSession.SendLocal(message);
public Task Start(IMessageSession session)
{
var myMessage = new MyMessage();
return session.SendLocal(myMessage);
}
public async Task Add([FromQuery] string counterID)
{
await _messageSession.SendLocal(new AddToCounter { CounterID = counterID });
}
private Task Work()
{
return(_messageSession.SendLocal(new SomeCommandOne()));
}
protected override async Task OnStart(IMessageSession session)
{
await BreakConnectionBySendingInvalidMessage();
await session.SendLocal(new MyRequest { MessageId = context.MessageId });
}
