public async Task LeaveQueue(Root request, QueueDto databaseResponseGet, QueueDto databaseResponseUpdate, ResponseCount responseCount) { //arrange Mock.Get(Get <IQueueDatabase>()).Setup(database => database.GetQueue(It.IsAny <string>(), It.IsAny <string>())) .Returns(Task.FromResult(databaseResponseGet == null ? null : new QueueDto { Queue = databaseResponseGet.Queue, ChannelId = databaseResponseGet.ChannelId })); Mock.Get(Get <IWebHookService>()).Setup(web => web.TriggerWebHook(It.IsAny <string>(), It.IsAny <object>())) .Returns(Task.FromResult(true)); //act await ClassUnderTest.PerformAction(request); //assert Mock.Get(Get <IQueueDatabase>()).Verify(mock => mock.GetQueue(It.IsAny <string>(), It.IsAny <string>()), Times.Exactly(responseCount.QueueGet)); Mock.Get(Get <IWebHookService>()) .Verify(mock => mock.TriggerWebHook(It.IsAny <string>(), It.IsAny <object>()), Times.Exactly(responseCount.WebService)); }
private void ApplySnapshot(Snapshot snapshot) { if (snapshot.State is Collection <SampleDto> ss) { QueueDto = ss; Logger.LogInformation("Restore Snapshot : {0}", string.Join(",", QueueDto.Select(x => x.Number))); } }
private void ApplyEvent(Event @event) { switch (@event.Data) { case SampleDto msg: QueueDto.Add(msg); Logger.LogInformation("Restore Queue : {0}", string.Join(",", QueueDto.Select(x => x.Number))); break; } }
public async Task <QueueDto> UpdateQueue(QueueDto queue) { await _context.SaveAsync(new QueueEntity { Queue = string.Join(",", queue.Queue.ToArray()), Name = queue.Name, ChannelId = queue.ChannelId }); return(await GetQueue(queue.ChannelId, null)); }
public async Task <SlackResponseDto> CreateQueueForChannel(SlashRequest request) { // check to see if queue already exists var currentQueue = await _queueDatabase.GetQueue(request.Channel_Id, request.Enterprise_Id); string message; //output queue to channel QueueBlockDto blocks; if (currentQueue == null) { currentQueue = new QueueDto { ChannelId = request.Channel_Id, Name = request.Text, Queue = new Queue <string>() }; await _queueDatabase.UpdateQueue(currentQueue); message = $"Queue has been added to {request.Channel_Name}"; } else { blocks = await _blockCreationService.CurrentQueue(currentQueue); message = $"Queue Already exists: {currentQueue.Name}"; return(new SlackResponseDto { Text = message, ResponseType = BasicResponseTypes.in_channel, Blocks = blocks.Blocks }); } blocks = await _blockCreationService.CurrentQueue(currentQueue); var responseNudge = new SlackResponseDto() { ResponseType = BasicResponseTypes.ephemeral, DeleteOriginal = true, Blocks = blocks.Blocks }; await _hookService.TriggerWebHook(request.Response_Url, responseNudge); return(new SlackResponseDto { Text = "Here's the queue", ResponseType = BasicResponseTypes.ephemeral }); }
public IActionResult Put(int id, [FromBody] QueueDto queueDto) { try { _queueService.Update(queueDto); return(Ok()); } catch (AppException ex) { // return error message if there was an exception return(BadRequest(new { message = ex.Message })); } }
public IActionResult Post([FromBody] QueueDto value) { try { _queueService.Create(value); return(Ok()); } catch (AppException ex) { // return error message if there was an exception return(BadRequest(new { message = ex.Message })); } }
public QueueDto Create(QueueDto queueDto) { var queue = AutoMapperConvert.Convert(queueDto); queue.User = _context.Users.Find(queueDto.UserId); // validation if (DateTime.MinValue == queue.Date) { throw new AppException("Date & Time is required"); } if (_context.Queues.Any(x => x.Date == queue.Date && x.TimeInDay == queue.TimeInDay)) { throw new AppException("Have queue in this date & Time: " + queue.Date.ToShortDateString() + " " + queue.TimeInDay); } queue.CreatedDate = DateTime.Now; _context.Queues.Add(queue); _context.SaveChanges(); return(queueDto); }
public void Update(QueueDto queueDto) { var queue = _context.Queues.Find(queueDto.Id); if (queue == null) { throw new AppException("Queue not found"); } // update if it has changed if (queue.Date != queueDto.Date || queue.TimeInDay != queueDto.TimeInDay) { if (_context.Queues.Any(x => x.Date == queueDto.Date && x.TimeInDay == queueDto.TimeInDay)) { throw new AppException("Have queue in this" + queue.Date + " " + queue.TimeInDay); } queue.Date = queueDto.Date; queue.TimeInDay = queueDto.TimeInDay; } queue.CreatedDate = DateTime.Now; _context.Queues.Update(queue); _context.SaveChanges(); }
public static Queue Convert(QueueDto dto) { return(_mapper.Map <Queue>(dto)); }
private void ConfigureStatePayment() => machine.Configure(State.Payment) .OnEntryFromAsync(paymentTrgger, async(Guid sessionId) => { UpdateMessagePump("Busy committing payment agreement ..."); var session = GetSession(sessionId); var que = new QueueDto { DateTime = DateTime.Now, TransactionId = session.SessionId }; var storeKey = StoreKey.TransactionIdKey; var txnId = session.SessionId.ToString(); try { var send = await unitOfWork.GetSenderRepository().Get(session, storeKey, txnId); var sendResult = await PostArticle(send.Result.FormatCoinToBase64(), RestApiMethod.PostCoin); if (sendResult.Result == null) { throw new NullReferenceException("Sender failed to post the request!"); } var rece = await unitOfWork.GetReceiverRepository().Get(session, storeKey, txnId); var receResult = await PostArticle(rece.Result.FormatCoinToBase64(), RestApiMethod.PostCoin); if (receResult.Result == null) { que.ReceiverFailed = true; } if (session.ForwardMessage) { var publ = await unitOfWork.GetPublicKeyAgreementRepository().Get(session, storeKey, txnId); var publResult = await PostArticle(publ.Result, RestApiMethod.PostMessage); if (publResult.Result == null) { que.PublicAgreementFailed = true; } var rede = await unitOfWork.GetRedemptionRepository().Get(session, storeKey, txnId); var redeResult = await PostArticle(rede.Result.Message, RestApiMethod.PostMessage); if (redeResult.Result == null) { que.PaymentFailed = true; } } var checkList = new List <bool> { que.PaymentFailed, que.PublicAgreementFailed, que.ReceiverFailed }; if (checkList.Any(l => l.Equals(true))) { var addQueue = await unitOfWork.GetQueueRepository().Put(session, que); if (addQueue.Success.Equals(false)) { throw new Exception("Queue failed to save.."); } logger.LogInformation("Added queue.. you might have to do some manual work ;(.. WIP"); } machine.Fire(Trigger.Complete); } catch (Exception ex) { session = GetSession(sessionId); session.LastError = JObject.FromObject(new { success = false, message = ex.Message }); SessionAddOrUpdate(session); logger.LogError($"Message: {ex.Message}\n Stack: {ex.StackTrace}"); await machine.FireAsync(reversedTrgger, session.SessionId); } }) .PermitReentry(Trigger.PaymentAgreement) .Permit(Trigger.Complete, State.Completed) .Permit(Trigger.Verify, State.Audited) .Permit(Trigger.Failed, State.Failure) .Permit(Trigger.RollBack, State.Reversed);
public async Task AddMessage(object message, QueueDto queue, TimeSpan?initialVisibilityDelay = null) { var str = Jil.JSON.Serialize(message); await _cloudQueues[queue].AddMessageAsync(new CloudQueueMessage(str)); }
public Task <QueueBlockDto> CurrentQueue(QueueDto queue) { var block = new QueueBlockDto { Blocks = new[] { new Block { Type = BlockTypes.section, Text = new BlockText { Type = TextTypes.mrkdwn, Text = queue.Name + " Queue" } }, new Block { Type = BlockTypes.divider }, new Block { Type = BlockTypes.section, Text = new BlockText { Type = TextTypes.mrkdwn, Text = "The queue is empty" } }, new Block { Type = BlockTypes.divider }, new Block { Type = BlockTypes.actions, Elements = new BlockElement[] { new BlockElement { Type = ElementTypes.button, Text = new BlockText { Type = TextTypes.plain_text, Text = "Join" }, Value = "JoinAction" }, new BlockElement { Type = ElementTypes.button, Text = new BlockText { Type = TextTypes.plain_text, Text = "Leave" }, Value = "LeaveAction" }, new BlockElement { Type = ElementTypes.overflow, Options = new BlockElement[] { new BlockElement { Type = null, Text = new BlockText { Type = TextTypes.plain_text, Text = "Nudge the Leader" }, Value = "NudgeAction" } } } } } } }; var queueAsText = ""; foreach (var person in queue.Queue) { queueAsText += $"@{person}"; if (!queue.Queue.LastOrDefault().Equals(person)) { queueAsText += " \n"; } } if (!string.IsNullOrEmpty(queueAsText)) { block.Blocks[2].Text.Text = queueAsText; } return(Task.FromResult(block)); }
public async Task <TaskDto> AddTaskToAnyQueue(TaskDto task, DateTime now) { await Locker.WaitAsync(); try { var queues = getActualQueues(); foreach (var queue in queues) { queue.RemoveOldTasks(now); } var availableDate = DateTime.MaxValue; QueueDto availableQueue = null; foreach (var queue in queues) { try { var queueAvailableDate = queue.GetAvailableDateForNewTask(now); if (queueAvailableDate < availableDate) { availableDate = queueAvailableDate; availableQueue = queue; } } catch (AvailableTimeException) { } catch (OfficeHoursException) { } catch (Exception ex) { throw ex; } } if (availableDate == DateTime.MaxValue) { throw new Exception("Номерок выдать невозможно"); } var availableTaskId = queues.Max(x => x.Tasks != null && x.Tasks.Count > 0 ? x.Tasks.Max(y => y.Id) : 0) + 1; task.Id = availableTaskId; task.Date = availableDate; task.FactDuration = task.FactDuration > 0 ? task.FactDuration : task.TaskType.Duration; task.QueueId = availableQueue.Id; availableQueue.AddTask(task); _cache.SetQueueList(queues); return(task); } catch (Exception ex) { throw ex; } finally { Locker.Release(); } }
public void Handler(string key, QueueDto dto) { Console.WriteLine($"---- {nameof(TestConsumer)} : {key} : {Thread.CurrentThread.ManagedThreadId} ----"); Console.WriteLine($"---- {JsonConvert.SerializeObject(dto)} ----"); }