public async Task <ActionResult> PostPoll(PollRequest request)
{
if (request.Answers.Count == 0 || string.IsNullOrEmpty(request.Name))
{
return(BadRequest("Some fields are left empty!"));
}
Member member = GetAuthenticatedMember();
Poll poll = new Poll
{
Creator = member,
Answers = request.Answers
.Select(a => new PollAnswer {
Answer = a.Answer
})
.ToList(),
Name = request.Name,
Participants = request.Participants.Select(p => new PollParticipant()
{
MemberID = p.MemberID
}).ToList()
};
_context.Polls.Add(poll);
await _context.SaveChangesAsync();
return(Ok(poll));
}
public async Task Strawpoll(string title, params string[] options)
{
try
{
var poll = new Strawpoll();
var obj = new PollRequest()
{
Title = title,
Options = new List <string>()
{
options[0], options[1]
},
Multi = false,
Dupcheck = DupCheck.Normal,
Captcha = false
};
var p = await poll.CreatePollAsync(obj);
//var pp = await poll.GetPollAsync(p.Id);
await ReplyAsync(p.Id.ToString());
}
catch (Exception ex)
{
await ReplyAsync("error: " + ex.Message.ToString());
}
}
public void CreatePollRequest_ResultsInWaitStillRunning_Test()
{
var request = new PollRequest <string>();
var task = request.WaitAsync();
Assert.False(task.IsCompleted);
}
//syncSubscriptions
internal NetNotification GetSyncMessage(string queueName, NetMessage message)
{
NetNotification receivedMessage = null;
HandoverSyncObject <NetNotification> synObj = null;
lock (syncSubscriptions)
{
if (syncSubscriptions.ContainsKey(queueName))
{
throw new ArgumentException("Queue " + queueName + " has already a poll runnig.");
}
PollRequest pr = new PollRequest();
pr.Subscription = message;
pr.Handover = synObj = new HandoverSyncObject <NetNotification>();
syncSubscriptions.Add(queueName, pr);
}
receivedMessage = synObj.Get();
lock (syncSubscriptions)
{
syncSubscriptions.Remove(queueName);
}
return(receivedMessage);
}
public ActionResult CreatePoll([FromBody] PollRequest request)
{
var poll = pollDac.Get(it => it.IsClose == false);
if (poll == null)
{
var newPoll = new Poll
{
Id = Guid.NewGuid().ToString(),
ShopName = request.ShopName,
CreateBy = request.CreateBy,
CreateAt = DateTime.Now,
IsClose = false,
Menus = new List <Menu>
{
new Menu
{
Id = Guid.NewGuid().ToString(),
IsDefault = true,
MenuName = request.MenuName,
Voter = new List <string>()
}
}
};
pollDac.Create(newPoll);
}
return(Ok());
}
private void HandleNotification(NetMessage message)
{
string subscription = message.Action.NotificationMessage.Subscription;
NetAction.DestinationType destType = message.Action.NotificationMessage.DestinationType;
if (destType != NetAction.DestinationType.TOPIC)
{
lock (this.syncSubscriptions)
{
string subs = message.Action.NotificationMessage.Subscription;
if (syncSubscriptions.ContainsKey(subscription))
{
PollRequest request = syncSubscriptions[subs];
request.Handover.Offer(message.Action.NotificationMessage);
return;
}
}
}
lock (subscriptions)
{
IDictionary <string, Subscription> destSubscriptions = subscriptions[destType == NetAction.DestinationType.TOPIC ? NetAction.DestinationType.TOPIC : NetAction.DestinationType.QUEUE];
if (destSubscriptions.ContainsKey(subscription))
{
destSubscriptions[subscription].FireOnMessage(message.Action.NotificationMessage);
}
else
{
DealWithException(new UnexpectedMessageException("No registered subscribers for received message.", message));
}
}
}
public void CreatePollRequestAndNotifyIt_ResultsInWaitTaskBeingCompleted_Test()
{
var expectedValue = "this is a message";
var request = new PollRequest <string>();
var task = request.WaitAsync();
request.Notify(expectedValue);
Assert.True(task.IsCompletedSuccessfully);
}
public override void Given()
{
ExpectedResponse = new PollResponse();
Mediator = new Mock <IMediator>();
Request = new PollRequest();
CancellationToken = new CancellationTokenSource().Token;
Controller = new EpcisSoapQueryController(Mediator.Object);
Mediator.Setup(x => x.Send(Request, CancellationToken)).Returns(() => Task.FromResult(ExpectedResponse));
}
public override void Given()
{
CancellationToken = new CancellationTokenSource().Token;
Query = new Mock <IEpcisQuery>();
Request = new PollRequest {
QueryName = "UnknownQuery", Parameters = null
};
Handler = new PollHandler(new[] { Query.Object });
Query.SetupGet(x => x.Name).Returns("ExampleQuery");
}
/// <summary>
/// Send consumer, reading messages one by one from stream and writes
/// to websocket stream.
/// </summary>
/// <returns></returns>
protected virtual async Task SendConsumerAsync(ICodecStream <S> codec)
{
if (_lastMessage == null)
{
_lastMessage = Message.Create(StreamId, _remoteId,
PollRequest.Create((ulong)_timeout.TotalMilliseconds));
}
while (!_open.IsCancellationRequested)
{
try {
if (_lastMessage == null)
{
if (_send.Completion.IsCompleted)
{
// Pipeline closed, close the connection
_receive.Complete();
_open.Cancel();
break;
}
try {
_lastMessage = await _send.ReceiveAsync(_timeout,
_open.Token).ConfigureAwait(false);
if (_lastMessage.Content is DataMessage data)
{
data.SequenceNumber = _nextSendSequenceNumber++;
}
}
catch (TimeoutException) {
_lastMessage = Message.Create(StreamId, _remoteId,
PollRequest.Create((ulong)_timeout.TotalMilliseconds));
}
catch (OperationCanceledException) when(!_open.IsCancellationRequested)
{
_lastMessage = Message.Create(StreamId, _remoteId,
PollRequest.Create((ulong)_timeout.TotalMilliseconds));
}
}
await codec.WriteAsync(_lastMessage, _open.Token).ConfigureAwait(false);
await codec.Stream.FlushAsync(_open.Token).ConfigureAwait(false);
_lastMessage.Dispose();
_lastMessage = null;
}
catch (OperationCanceledException) {
break;
}
catch (Exception e) {
ProxyEventSource.Log.StreamException(this, codec.Stream, e);
break;
}
}
}
public override void Given()
{
CancellationToken = new CancellationTokenSource().Token;
Query = new Mock <IEpcisQuery>();
Request = new PollRequest {
QueryName = "ExampleQuery", Parameters = null
};
Handler = new PollHandler(new [] { Query.Object });
Query.SetupGet(x => x.Name).Returns("ExampleQuery");
Query.Setup(x => x.Handle(It.IsAny <QueryParameter[]>(), CancellationToken)).Returns(Task.FromResult(new PollResponse()));
}
public Message Poll(Message request)
{
try
{
var pollRequest = PollRequest.Parse(XElement.Parse(request.GetReaderAtBodyContents().ReadOuterXml()));
var results = _eventQuery.Execute(pollRequest.Name, pollRequest.Parameters);
return(MessageResponse.CreatePollResponse(results.Root));
}
catch (Exception ex)
{
throw EpcisFault.Create(ex);
}
}
public async Task <IActionResult> PutPoll(long id, PollRequest request)
{
if (id != request.PollID)
{
return(BadRequest());
}
Member member = GetAuthenticatedMember();
Poll poll = _context.Polls
.Where(p => p.Creator.MemberID == member.MemberID)
.Include(p => p.Answers)
.Include(p => p.Participants)
.FirstOrDefault(p => p.PollID == request.PollID);
// poll doesn't exist or member has no permission to edit
if (poll == null)
{
return(PollNotFound());
}
// TODO: check if creating new object is actually securer
poll.Answers = request.Answers.Select(a => new PollAnswer {
Answer = a.Answer
}).ToList();
poll.Name = request.Name;
poll.Participants = request.Participants.Select(p => new PollParticipant {
MemberID = p.MemberID
}).ToList();
_context.Entry(poll).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PollExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok(poll));
}
/// <summary>
/// Open stream
/// </summary>
/// <param name="ct"></param>
/// <returns></returns>
public Task <IMessageStream> OpenAsync(CancellationToken ct)
{
CreateReceiveBlock();
CreateSendBlock();
// Start producer receiving from poll
_receiveTask = Task.Factory.StartNew(async() => {
var sendTimeout = TimeSpan.FromMilliseconds(_pollTimeout * 2);
var receiver = new IoTHubInvoker(_hubConnectionString);
try {
ulong nextSequenceNumber = 0;
while (true)
{
using (var request = Message.Create(_streamId, _remoteId,
PollRequest.Create(_pollTimeout, nextSequenceNumber))) {
var response = await receiver.TryCallAsync(
_link, request, sendTimeout, _open.Token).ConfigureAwait(false);
//
// Poll receives back a timeout error in case no data was available
// within the requested timeout. This is decoupled from the consumers
// that time out on their cancellation tokens.
//
if (response != null && response.Error != (int)SocketError.Timeout)
{
if (!await _receive.SendAsync(response).ConfigureAwait(false))
{
break;
}
nextSequenceNumber++;
}
}
// Continue polling until closed in which case we complete receive
_open.Token.ThrowIfCancellationRequested();
}
}
catch (OperationCanceledException) {
}
catch (Exception e) {
ProxyEventSource.Log.HandledExceptionAsError(this, e);
throw;
}
finally {
receiver.Dispose();
}
}, _open.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default).Unwrap();
return(Task.FromResult((IMessageStream)this));
}
public IActionResult ProcessPrinterStatus([FromBody] PollRequest pollRequest)
{
if (pollRequest == null)
{
return(BadRequest("sadfasfasasdsdafasdf"));
}
// todo: if job is in progress, skip checking db to save time and return
var pollResponse = new PollResponse {
mediaTypes = new List <string>()
};
pollResponse.mediaTypes.AddRange(Document.GetOutputTypesFromType("text/vnd.star.markup"));
pollResponse.jobReady = true;
return(Ok(pollResponse.ToJson()));
}
public PollRequestResult Create(PollRequest request)
{
var poll = new Model.Poll()
{
Description = request.PollDescription,
Views = 0
};
_repository.Insert(poll);
_pollOptionBusiness.Create(poll.Id, request.Options);
return(new PollRequestResult()
{
PollId = poll.Id
});
}
private async Task PollAsync(CancellationToken cancellationToken)
{
var closeCode = int.MinValue;
try
{
using var call = this.adaptorImpl.Poll();
while (!cancellationToken.IsCancellationRequested)
{
var request = new PollRequest()
{
Token = $"{this.adaptorImpl.Token}"
};
await call.RequestStream.WriteAsync(request);
await call.ResponseStream.MoveNext();
var reply = call.ResponseStream.Current;
if (reply.Code != int.MinValue)
{
closeCode = reply.Code;
break;
}
this.InvokeCallback(reply.Items);
reply.Items.Clear();
await Task.Delay(1);
}
await call.RequestStream.CompleteAsync();
await call.ResponseStream.MoveNext();
}
catch (Exception e)
{
closeCode = -1;
GrpcEnvironment.Logger.Error(e, e.Message);
}
if (closeCode != int.MinValue)
{
this.task = null;
await this.adaptorImpl.AbortAsync();
this.adaptorImpl = null;
this.OnDisconnected(new CloseEventArgs(closeCode));
}
}
public async Task <ActionResult> Post([FromBody] PollRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try {
Poll poll = await _pollRepository.CreatePollAsync(request.Name, request.PollDefinitionId, request.Handle, request.Description, request.IsOpen);
_logger.LogInformation(LoggingEvents.InsertPoll, "Poll {Id} Created", poll.Id);
return(CreatedAtRoute("GetPoll", new { controller = "Polls", id = poll.Id }, poll));
}
catch (Exception e) {
_logger.LogError(LoggingEvents.InsertPoll, $"Error creating new poll: Exception {e.Message}");
return(StatusCode(500, e.Message));
}
}
public async Task <IActionResult> GetMyPolling([FromBody] PollRequest request)
{
var requestToken = request.Token ?? default;
if (requestToken != default)
{
requestToken = requestToken.Minus(Duration.FromSeconds(10));
}
#pragma warning disable MA0040 // Flow the cancellation token
if (request.Delivered?.Length > 0)
{
var tokens = request.Delivered.Select(x => TrackingToken.Parse(x));
await userNotificationStore.TrackSeenAsync(tokens);
}
if (request.Seen?.Length > 0)
{
var tokens = request.Seen.Select(x => TrackingToken.Parse(x));
await userNotificationStore.TrackSeenAsync(tokens);
}
foreach (var id in request.Confirmed.OrEmpty())
{
var token = TrackingToken.Parse(id);
await userNotificationStore.TrackConfirmedAsync(token);
}
#pragma warning restore MA0040 // Flow the cancellation token
foreach (var id in request.Deleted.OrEmpty())
{
await userNotificationStore.DeleteAsync(id, HttpContext.RequestAborted);
}
var notifications = await userNotificationStore.QueryAsync(App.Id, UserId, DefaultQuery with {
After = requestToken
}, HttpContext.RequestAborted);
private void HandleFault(NetMessage message)
{
string msgDest = message.Action.FaultMessage.Detail;
if (message.Action.FaultMessage.Code.Equals(NetFault.PollTimeoutErrorMessage.Action.FaultMessage.Code) ||
message.Action.FaultMessage.Code.Equals(NetFault.NoMessageInQueueErrorMessage.Action.FaultMessage.Code))
{
lock (this.syncSubscriptions)
{
if (syncSubscriptions.ContainsKey(msgDest))
{
PollRequest request = syncSubscriptions[msgDest];
if (message.Action.FaultMessage.Code.Equals(NetFault.PollTimeoutErrorMessage.Action.FaultMessage.Code))
{
request.Handover.Offer(UnblockNotification);
}
else
{
request.Handover.Offer(NoMessageNotification);
}
}
return;
}
}
message.Action.FaultMessage.Headers = message.Headers;
if (!PendingAcceptRequestsManager.MessageFailed(message.Action.FaultMessage))
{
FaultHandler handler = OnFault;
if (handler != null)
{
OnFault(message.Action.FaultMessage);
}
}
}
//syncSubscriptions
internal NetNotification GetSyncMessage(string queueName, NetMessage message)
{
NetNotification receivedMessage = null;
HandoverSyncObject<NetNotification> synObj = null;
lock (syncSubscriptions)
{
if (syncSubscriptions.ContainsKey(queueName))
throw new ArgumentException("Queue " + queueName + " has already a poll runnig.");
PollRequest pr = new PollRequest();
pr.Subscription = message;
pr.Handover = synObj = new HandoverSyncObject<NetNotification>();
syncSubscriptions.Add(queueName, pr);
}
receivedMessage = synObj.Get();
lock (syncSubscriptions)
{
syncSubscriptions.Remove(queueName);
}
return receivedMessage;
}
public Poll(PollRequest body)
: base(body)
{
}
protected override async Task SendConsumerAsync(
ICodecStream <HybridConnectionStream> codec)
{
while (!_open.IsCancellationRequested)
{
try {
if (_lastMessage == null)
{
if (_send.Completion.IsCompleted)
{
// Pipeline closed, close the connection
_receive.Complete();
_open.Cancel();
break;
}
try {
_lastMessage = await _send.ReceiveAsync(_timeout,
_open.Token).ConfigureAwait(false);
var data = _lastMessage.Content as DataMessage;
if (data != null)
{
data.SequenceNumber = _nextSendSequenceNumber++;
}
}
catch (TimeoutException) {
_lastMessage = Message.Create(StreamId, _remoteId,
PollRequest.Create((ulong)_timeout.TotalMilliseconds));
}
catch (OperationCanceledException) when(!_open.IsCancellationRequested)
{
_lastMessage = Message.Create(StreamId, _remoteId,
PollRequest.Create((ulong)_timeout.TotalMilliseconds));
}
}
//
// Every write on the hybrid connection stream right now results in a binary
// message not an individual fragment.
// when using the codec directly on the stream then the first write confuses the
// proxy decoder, which assumes a websocket message contains an entire message.
// Override here to buffer the entire message in a memory stream before writing.
//
using (var mem = new MemoryStream()) {
_lastMessage.Encode(mem, CodecId.Mpack);
var buffered = mem.ToArray();
await codec.Stream.WriteAsync(
buffered, 0, buffered.Length, _open.Token).ConfigureAwait(false);
}
await codec.Stream.FlushAsync(_open.Token).ConfigureAwait(false);
_lastMessage.Dispose();
_lastMessage = null;
}
catch (OperationCanceledException) {
break;
}
catch (Exception e) {
ProxyEventSource.Log.StreamException(this, codec.Stream, e);
break;
}
}
}