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)} ----");
}
