public async Task <ActionResult <IEnumerable <MessageDto> > > GetMessagesForCurrentUser([FromQuery] MessageParams messageParams)
{
// add value to parameter property
messageParams.CurrentUsername = User.GetUsername();
// get messages from Message Repo, based on constructed Params
var paged_messages = await _unitOfWork.MessageRepository.GetMessagesForCurrentUser(messageParams);
// add pagination info to http response header, based on PagedList<MessageDto> from Repo
Response.AddPaginationHeader(paged_messages.CurrentPage, paged_messages.PageSize, paged_messages.TotalCount, paged_messages.TotalPages);
return(paged_messages);
}
public async Task <ActionResult <IEnumerable <MessageToReturnDTO> > > GetMessagesForUser(int userId, [FromQuery] MessageParams messageParams)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
messageParams.UserId = userId;
var messagesFromRepo = await _repo.GetMessagesForUser(messageParams);
var messages = _mapper.Map <IEnumerable <MessageToReturnDTO> >(messagesFromRepo);
Response.AddPagination(messagesFromRepo.CurrentPage,
messagesFromRepo.PageSize,
messagesFromRepo.TotalCount,
messagesFromRepo.TotalPages);
return(Ok(messages));
}
public Task <PagedList <Message> > GetMessagsForUser(MessageParams messageParam)
{
throw new System.NotImplementedException();
}
public static async Task <(bool, string, Message)> FindReferenceDataByQuestion(Message source, long serviceId, User user,
UsersRepository users, MessageParams messageParams, DBPIParams dbPIParams)
{
// TODO must be 1
var startTime = DateTime.Now;
var question = source.Body;
var lastMessageID = users.GetLastMessageID(user.GUID);
var(success, error, apsolutionsAnswer) = await SearchText(user.GUID, user.Fio, user.Position, user.EmploymentDate, serviceId, question).ConfigureAwait(false);
if (users.IsOlderThenLast(user.GUID, lastMessageID))
{
return(false, error, null);
}
// TODO if(service != null && apsolutionsAnswer.QuestionCategory == "information")
if (!success || apsolutionsAnswer is null || apsolutionsAnswer.Records is null || apsolutionsAnswer.Records.Length == 0)
{
users.SetLastMessageID(user.GUID);
return(false, null, Message.Answer(source, success ? messageParams.NotFound : messageParams.AIError, DateTime.Now.Ticks - startTime.Ticks));
}
var userMessages = new Queue <Message>();
foreach (var record in apsolutionsAnswer.Records)
{
var body = record.Text;
string description = null, title = null;
ulong iid = 0;
if (ulong.TryParse(body, out var pid))
{
var initiativeRepository = new InitiativeRepository(new ConnectionService(dbPIParams));
var(notFound, _, info) = await initiativeRepository.GetAsync(pid).ConfigureAwait(false);
if (notFound)
{
title = info.Problem.Length < 65 ? info.Problem : $"{info.Problem.Substring(0, 62)}...";
body = $"<div class=\"gpn-source\">Портал инициатив > {info.Iid}</div><div class=\"gpn-title\">{title}</div><div class=\"gpn-shortDescription\">{info.Organization} {info.Status}</div>";
description =
$"<div class=\"gpn-key\">Инициатива:</div><div class=\"gpn-value\">{info.Iid}</div>" +
$"<div class=\"gpn-key\">Создана:</div><div class=\"gpn-value\">{info.Created:dd.MM.yyyy}</div>" +
$"<div class=\"gpn-key\">Автор:</div><div class=\"gpn-value\">{info.Author}</div>" +
$"<div class=\"gpn-key\">Организация/подразделение:</div><div class=\"gpn-value\">{info.Organization}</div>" +
$"<div class=\"gpn-key\">Проблема:</div><div class=\"gpn-value\">{info.Problem}</div>" +
$"<div class=\"gpn-key\">Решение:</div><div class=\"gpn-value\">{info.Solution}</div>" +
$"<div class=\"gpn-key\">Статус:</div><div class=\"gpn-value\">{info.Status}</div>" +
$"<div class=\"gpn-key\">Количество комментариев:</div><div class=\"gpn-value\">{info.CommentsCount}</div>" +
$"<div class=\"gpn-key\">Дата последнего комментария:</div><div class=\"gpn-value\">{info.LastCommentDate ?? "-"}</div>" +
$"<div class=\"gpn-key\">Комментарий:</div><div class=\"gpn-value\">{info.LastCommentText ?? "-"}</div>";
iid = pid;
}
}
var answer = Message.Answer(source, body);
answer.Description = description;
answer.Title = title;
answer.Iid = iid;
answer.CanClick = true;
answer.Created = startTime;
userMessages.Enqueue(answer);
}
users.SetMessages(user.GUID, QueueType.information, userMessages);
users.SetLastMessageID(user.GUID);
return(true, null, null);
}
public static async Task <(bool, string, Message)> FindAggregateByQuestion(Message source, long serviceId, User user,
UsersRepository users, MessageParams messageParams)
{
// TODO must be 1
var startTime = DateTime.Now;
var question = source.Body;
var lastMessageID = users.GetLastMessageID(user.GUID);
var(success, error, apsolutionsAggregate) = await SearchAggregate(user.GUID, user.Fio, user.Position, user.EmploymentDate, serviceId, question).ConfigureAwait(false);
if (users.IsOlderThenLast(user.GUID, lastMessageID))
{
return(false, error, null);
}
var resultCount = apsolutionsAggregate?.Res?.Count;
string body = resultCount.HasValue ? $"найдено {resultCount}" : null;
var tiks = DateTime.Now.Ticks - startTime.Ticks;
var answer = !success || apsolutionsAggregate is null || apsolutionsAggregate.Res is null || body is null?
Message.Answer(source, success?messageParams.NotFound : messageParams.AIError, tiks) :
Message.Answer(source, body, tiks);
users.SetLastMessageID(user.GUID);
return(true, null, answer);
}
private static void ExecuteAndCompleteQuery(string ownerUri, Query query,
IEventSender eventSender,
Query.QueryAsyncEventHandler querySuccessCallback,
Query.QueryAsyncErrorEventHandler queryFailureCallback)
{
// Setup the callback to send the complete event
Query.QueryAsyncEventHandler completeCallback = async q =>
{
// Send back the results
QueryCompleteParams eventParams = new QueryCompleteParams
{
OwnerUri = ownerUri,
BatchSummaries = q.BatchSummaries
};
Logger.Write(TraceEventType.Information, $"Query:'{ownerUri}' completed");
await eventSender.SendEvent(QueryCompleteEvent.Type, eventParams);
};
// Setup the callback to send the failure event
Query.QueryAsyncErrorEventHandler failureCallback = async(q, e) =>
{
// Send back the results
QueryCompleteParams eventParams = new QueryCompleteParams
{
OwnerUri = ownerUri,
BatchSummaries = q.BatchSummaries
};
Logger.Write(TraceEventType.Error, $"Query:'{ownerUri}' failed");
await eventSender.SendEvent(QueryCompleteEvent.Type, eventParams);
};
query.QueryCompleted += completeCallback;
query.QueryFailed += failureCallback;
// Add the callbacks that were provided by the caller
// If they're null, that's no problem
query.QueryCompleted += querySuccessCallback;
query.QueryFailed += queryFailureCallback;
// Setup the batch callbacks
Batch.BatchAsyncEventHandler batchStartCallback = async b =>
{
BatchEventParams eventParams = new BatchEventParams
{
BatchSummary = b.Summary,
OwnerUri = ownerUri
};
Logger.Write(TraceEventType.Information, $"Batch:'{b.Summary}' on Query:'{ownerUri}' started");
await eventSender.SendEvent(BatchStartEvent.Type, eventParams);
};
query.BatchStarted += batchStartCallback;
Batch.BatchAsyncEventHandler batchCompleteCallback = async b =>
{
BatchEventParams eventParams = new BatchEventParams
{
BatchSummary = b.Summary,
OwnerUri = ownerUri
};
Logger.Write(TraceEventType.Information, $"Batch:'{b.Summary}' on Query:'{ownerUri}' completed");
await eventSender.SendEvent(BatchCompleteEvent.Type, eventParams);
};
query.BatchCompleted += batchCompleteCallback;
Batch.BatchAsyncMessageHandler batchMessageCallback = async m =>
{
MessageParams eventParams = new MessageParams
{
Message = m,
OwnerUri = ownerUri
};
Logger.Write(TraceEventType.Information, $"Message generated on Query:'{ownerUri}' :'{m}'");
await eventSender.SendEvent(MessageEvent.Type, eventParams);
};
query.BatchMessageSent += batchMessageCallback;
// Setup the ResultSet available callback
ResultSet.ResultSetAsyncEventHandler resultAvailableCallback = async r =>
{
ResultSetAvailableEventParams eventParams = new ResultSetAvailableEventParams
{
ResultSetSummary = r.Summary,
OwnerUri = ownerUri
};
Logger.Write(TraceEventType.Information, $"Result:'{r.Summary} on Query:'{ownerUri}' is available");
await eventSender.SendEvent(ResultSetAvailableEvent.Type, eventParams);
};
query.ResultSetAvailable += resultAvailableCallback;
// Setup the ResultSet updated callback
ResultSet.ResultSetAsyncEventHandler resultUpdatedCallback = async r =>
{
ResultSetUpdatedEventParams eventParams = new ResultSetUpdatedEventParams
{
ResultSetSummary = r.Summary,
OwnerUri = ownerUri
};
Logger.Write(TraceEventType.Information, $"Result:'{r.Summary} on Query:'{ownerUri}' is updated with additional rows");
await eventSender.SendEvent(ResultSetUpdatedEvent.Type, eventParams);
};
query.ResultSetUpdated += resultUpdatedCallback;
// Setup the ResultSet completion callback
ResultSet.ResultSetAsyncEventHandler resultCompleteCallback = async r =>
{
ResultSetCompleteEventParams eventParams = new ResultSetCompleteEventParams
{
ResultSetSummary = r.Summary,
OwnerUri = ownerUri
};
Logger.Write(TraceEventType.Information, $"Result:'{r.Summary} on Query:'{ownerUri}' is complete");
await eventSender.SendEvent(ResultSetCompleteEvent.Type, eventParams);
};
query.ResultSetCompleted += resultCompleteCallback;
// Launch this as an asynchronous task
query.Execute();
}
private async Task SendPlacesPage(User user, MessageParams param, DataContext db, int?messageId = null)
{
var places = await db.Places.Where(p => p.Active).ToListAsync();
var distances = places
.Select(p => new Tuple <Place, double>(p, Helper.GetDistance(param.Longitude, param.Latitude, p.Longitude, p.Latitude)))
.OrderBy(i => i.Item2).ToList();
var inRadius = distances.Where(p => p.Item2 < param.Distance).ToList();
var sb = new StringBuilder();
var infoInlineKeyboard = new List <InlineKeyboardButton>();
if (param.Page != 0)
{
infoInlineKeyboard.Add(InlineKeyboardButton.WithCallbackData("⬅️", $"page {param.Page - 1};{param.Longitude};{param.Latitude};{param.Distance}"));
}
if (!inRadius.Any())
{
sb.AppendLine(await Helper.GetLocalizationAsync(LocalizationKeys.NOTHING_FOUND_NEARBY, _lang, db));
sb.AppendLine(await Helper.GetLocalizationAsync(LocalizationKeys.TRY_INCREASE_RADIUS, _lang, db));
sb.AppendLine();
sb.AppendLine(await Helper.GetLocalizationAsync(LocalizationKeys.THE_CLOSEST_PLACE, _lang, db));
var item = distances.First();
var dist = item.Item2 < 1000
? Math.Round((item.Item2), 1) + $" {await Helper.GetLocalizationAsync(LocalizationKeys.M, _lang, db)}"
: Math.Round((item.Item2 / 1000), 1) + $" {await Helper.GetLocalizationAsync(LocalizationKeys.KM, _lang, db)}";
var open = Helper.GetOpenStatus(item.Item1);
sb.AppendLine($"{open}*{item.Item1.Name}* ({char.ConvertFromUtf32(0x1F9B6)}{dist})");
sb.AppendLine($"{Helper.GetAddressLink(item.Item1, _lang)}");
}
else
{
sb.AppendLine("🔍 " + await Helper.GetLocalizationAsync(LocalizationKeys.LIST_HEADER, _lang, db));
var lastItemToShow = param.Page * DefaultCount + DefaultCount;
for (var i = param.Page * DefaultCount; i < lastItemToShow; i++)
{
if (i == inRadius.Count)
{
break;
}
var item = inRadius[i];
var dist = item.Item2 < 1000
? Math.Round((item.Item2), 1) + $" {await Helper.GetLocalizationAsync(LocalizationKeys.M, _lang, db)}"
: Math.Round((item.Item2 / 1000), 1) + $" {await Helper.GetLocalizationAsync(LocalizationKeys.KM, _lang, db)}";
var open = Helper.GetOpenStatus(item.Item1);
sb.AppendLine();
sb.AppendLine($"{i + 1}. {open}*{item.Item1.Name}* ({char.ConvertFromUtf32(0x1F9B6)}{dist})");
sb.AppendLine($"{Helper.GetAddressLink(item.Item1, _lang)}");
infoInlineKeyboard.Add(InlineKeyboardButton.WithCallbackData((i + 1).ToString(), $"info {item.Item1.Id.ToString()}"));
}
if (lastItemToShow < inRadius.Count)
{
infoInlineKeyboard.Add(InlineKeyboardButton.WithCallbackData("➡️", $"page {param.Page + 1};{param.Longitude};{param.Latitude};{param.Distance}"));
}
sb.AppendLine();
sb.AppendLine(await Helper.GetLocalizationAsync(LocalizationKeys.DESC_AND_REVIEWS, _lang, db));
}
var distanceInlineKeyboard = new List <InlineKeyboardButton> {
InlineKeyboardButton.WithCallbackData(
param.Distance == 500 ? $"✅ 0.5 {await Helper.GetLocalizationAsync(LocalizationKeys.KM, _lang, db)}" : $"0.5 {await Helper.GetLocalizationAsync(LocalizationKeys.KM, _lang, db)}",
$"distance {param.Page};{param.Longitude};{param.Latitude};500"),
InlineKeyboardButton.WithCallbackData(
param.Distance == 1000 ? $"✅ 1 {await Helper.GetLocalizationAsync(LocalizationKeys.KM, _lang, db)}" : $"1 {await Helper.GetLocalizationAsync(LocalizationKeys.KM, _lang, db)}",
$"distance {param.Page};{param.Longitude};{param.Latitude};1000"),
InlineKeyboardButton.WithCallbackData(
param.Distance == 2000 ? $"✅ 2 {await Helper.GetLocalizationAsync(LocalizationKeys.KM, _lang, db)}" : $"2 {await Helper.GetLocalizationAsync(LocalizationKeys.KM, _lang, db)}",
$"distance {param.Page};{param.Longitude};{param.Latitude};2000")
};
var markup = new InlineKeyboardMarkup(
new List <IEnumerable <InlineKeyboardButton> > {
infoInlineKeyboard,
distanceInlineKeyboard
});
if (messageId.HasValue)
{
await _bot.EditMessageTextAsync(user.ChatId, messageId.Value, sb.ToString(), ParseMode.Markdown, replyMarkup : markup, disableWebPagePreview : true);
}
else
{
await _bot.SendTextMessageAsync(
user.ChatId,
sb.ToString(),
ParseMode.Markdown,
replyMarkup : markup,
disableWebPagePreview : true);
}
}
public Task <PagedList <Message> > GetMessageForUser(MessageParams messageParams)
{
return(_messageDal.GetMessageForUser(messageParams));
}
public async Task <ActionResult <IEnumerable <MessageDto> > > GetMessagesForUser([FromQuery] MessageParams messageParams)
{
messageParams.Username = User.FindFirst(ClaimTypes.Name)?.Value;
var messages = await _messageRepository.GetMessagesForUser(messageParams);
Response.AddPaginationHeader(messages.CurrentPage, messages.PageSize, messages.TotalCount, messages.TotalPages);
return(messages);
}
public async Task <ActionResult <IEnumerable <AppUserMessagesResponse> > > GetMessagesForUser([FromQuery] MessageParams messageParams)
{
messageParams.UserName = User.GetUserName();
var messages = await _messagesRepository.GetMessagesForUser(messageParams).ConfigureAwait(false);
Response.AddPaginationHeader(messages.CurrentPage, messages.PageSize, messages.TotalCount, messages.TotalPages);
return(messages);
}
public async Task <ActionResult <IEnumerable <MessageDto> > > GetMessageForUser([FromQuery] MessageParams messageParams)
{
messageParams.Username = User.GetUsername();
var messages = await _unitOfWork.MessageRepository.GetMessagesForUser(messageParams);
// if (!await _unitOfWork.Complete()) return BadRequest("Failed to saved the Date Read data.");
Response.AddPaginationHeader(messages.CurrentPage, messages.PageSize,
messages.TotalCount, messages.TotalPages);
return(messages);
}
public Task<PagedList<Message>> GetMessagesForUser(MessageParams messageParams)
{
return _userData.GetMessagesForUser(messageParams);
}
public async Task <ActionResult <IEnumerable <MessageDto> > > GetMessagesForUser([FromQuery]
MessageParams messageParams) //como MessageParams es un PaginationParams podes enviar esa info para paginado, sino usa default
{
messageParams.Username = User.GetUsername();
var messages = await _unitOfWork.MessageRepository.GetMessagesForUser(messageParams);
Response.AddPaginationHeader(messages.CurrentPage, messages.PageSize,
messages.TotalCount, messages.TotalPages);
return(messages);
}
Task <PagedList <MessageDto> > GetMessagesForUser(MessageParams messageParams);
public async Task <ActionResult <IEnumerable <MessageDto> > > GetMessageForUser([FromQuery] MessageParams messageParams)
{
messageParams.UserId = User.GetUserId();
var message = await _messageService.GetMessagesForUser(messageParams);
Response.AddPaginationHeader(message.CurrentPage, message.PageSize,
message.TotalCount, message.TotalPages);
return(message);
}
public async Task <IActionResult> GetMessageThread(int userId, int recipientId, [FromQuery] MessageParams messageParams, int maximumId)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var currentLoggedInUser = await _repo.GetUser(userId);
if (currentLoggedInUser == null)
{
return(Unauthorized());
}
var messages = await _repo.GetMessagesThread(userId, recipientId, messageParams, maximumId);
var messagesToReturn = _mapper.Map <IEnumerable <MessageToReturnDto> >(messages);
Response.AddPagination(messages.CurrentPage, messages.PageSize, messages.TotalCount, messages.TotalPages);
return(Ok(messagesToReturn));
}
public async Task <IEnumerable <MessageToReturnDto> > GetMessages(int userId, MessageParams messageParams)
{
string messageParamsAsJson = messageParams.ToQueryString();
var result = await _httpClient.GetAsync($"api/users/{userId}/messages/?{messageParamsAsJson}");
var messages = JsonSerializer.Deserialize <IEnumerable <MessageToReturnDto> >(await result.Content.ReadAsStringAsync(), new JsonSerializerOptions {
PropertyNameCaseInsensitive = true
});
if (result.IsSuccessStatusCode)
{
return(messages);
}
return(null);
}
private static void ExecuteAndCompleteQuery(string ownerUri, IEventSender eventSender, Query query)
{
// Skip processing if the query is null
if (query == null)
{
return;
}
// Setup the query completion/failure callbacks
Query.QueryAsyncEventHandler callback = async q =>
{
// Send back the results
QueryCompleteParams eventParams = new QueryCompleteParams
{
OwnerUri = ownerUri,
BatchSummaries = q.BatchSummaries
};
await eventSender.SendEvent(QueryCompleteEvent.Type, eventParams);
};
query.QueryCompleted += callback;
query.QueryFailed += callback;
// Setup the batch callbacks
Batch.BatchAsyncEventHandler batchStartCallback = async b =>
{
BatchEventParams eventParams = new BatchEventParams
{
BatchSummary = b.Summary,
OwnerUri = ownerUri
};
await eventSender.SendEvent(BatchStartEvent.Type, eventParams);
};
query.BatchStarted += batchStartCallback;
Batch.BatchAsyncEventHandler batchCompleteCallback = async b =>
{
BatchEventParams eventParams = new BatchEventParams
{
BatchSummary = b.Summary,
OwnerUri = ownerUri
};
await eventSender.SendEvent(BatchCompleteEvent.Type, eventParams);
};
query.BatchCompleted += batchCompleteCallback;
Batch.BatchAsyncMessageHandler batchMessageCallback = async m =>
{
MessageParams eventParams = new MessageParams
{
Message = m,
OwnerUri = ownerUri
};
await eventSender.SendEvent(MessageEvent.Type, eventParams);
};
query.BatchMessageSent += batchMessageCallback;
// Setup the ResultSet completion callback
ResultSet.ResultSetAsyncEventHandler resultCallback = async r =>
{
ResultSetEventParams eventParams = new ResultSetEventParams
{
ResultSetSummary = r.Summary,
OwnerUri = ownerUri
};
await eventSender.SendEvent(ResultSetCompleteEvent.Type, eventParams);
};
query.ResultSetCompleted += resultCallback;
// Launch this as an asynchronous task
query.Execute();
}
public async Task <ActionResult <IEnumerable <MessageDTO> > > GetMessagesForUser([FromQuery]
MessageParams messageParams)
{
messageParams.Username = User.FindFirst(ClaimTypes.Name)?.Value;
messageParams.PageSize = 15;
var messages = await unitOfWork.messageRepository.GetMessagesForUser(messageParams);
Response.AddPaginationHeader(messages.CurrentPage, messages.PageSize,
messages.TotalNumItems, messages.TotalPages);
return(Ok(messages));
}
public async Task <ActionResult <IEnumerable <MessageDTO> > > GetMessageForUser([FromQuery] MessageParams msgParams)
{
msgParams.UserName = User.GetUserName();
var msg = await _mainRespositories.MessageRepository.GetMessageByUserName(msgParams);
Response.addPaginationHeader(msg.CurrentPage, msg.PageSize, msg.TotalCount, msg.TotalPages);
return(Ok(msg));
}
private async Task ProcessUpdate(Update update, DataContext db)
{
var user = await SetStats(update, db);
if (user == null)
{
return;
}
if (update.Type == UpdateType.CallbackQuery)
{
var data = update.CallbackQuery.Data.Split(' ');
await WriteLogs("Callback data", user.ChatId, update.CallbackQuery.Data);
switch (data[0])
{
case "info":
var id = int.Parse(data[1]);
await Info(id, user, db);
break;
case "infoback":
id = int.Parse(data[1]);
await Info(id, user, db, update.CallbackQuery.Message.MessageId);
break;
case "setrate":
id = int.Parse(data[1]);
var markup = new InlineKeyboardMarkup(
new List <IEnumerable <InlineKeyboardButton> > {
new List <InlineKeyboardButton> {
InlineKeyboardButton.WithCallbackData(await Helper.GetLocalizationAsync(LocalizationKeys.STARS_1, _lang, db), $"rate {id} 1"),
InlineKeyboardButton.WithCallbackData(await Helper.GetLocalizationAsync(LocalizationKeys.STARS_2, _lang, db), $"rate {id} 2"),
InlineKeyboardButton.WithCallbackData(await Helper.GetLocalizationAsync(LocalizationKeys.STARS_3, _lang, db), $"rate {id} 3"),
},
new List <InlineKeyboardButton> {
InlineKeyboardButton.WithCallbackData(await Helper.GetLocalizationAsync(LocalizationKeys.STARS_4, _lang, db), $"rate {id} 4"),
InlineKeyboardButton.WithCallbackData(await Helper.GetLocalizationAsync(LocalizationKeys.STARS_5, _lang, db), $"rate {id} 5")
},
new List <InlineKeyboardButton> {
InlineKeyboardButton.WithCallbackData(await Helper.GetLocalizationAsync(LocalizationKeys.COMMENT, _lang, db), $"comment {id}"),
InlineKeyboardButton.WithCallbackData(await Helper.GetLocalizationAsync(LocalizationKeys.BACK, _lang, db), $"infoback {id} "),
}
});
await _bot.EditMessageReplyMarkupAsync(user.ChatId, update.CallbackQuery.Message.MessageId, markup);
break;
case "comments": //read comments
id = int.Parse(data[1]);
await SendComments(user, db, id, 0, null);
break;
case "commentspage": //read comments
id = int.Parse(data[1]);
var page = int.Parse(data[2]);
await SendComments(user, db, id, page, update.CallbackQuery.Message.MessageId);
break;
case "comment": //leave comments
await SetUserMode(user, UserMode.WaitForComment, db, data[1]);
await _bot.SendTextMessageAsync(user.ChatId,
await Helper.GetLocalizationAsync(LocalizationKeys.WRITE_COMMENT, _lang, db),
replyMarkup : await LocationKeyboardMarkup(db));
break;
case "comment2": //leave comments
await SetUserMode(user, UserMode.WaitForComment, db, data[1]);
await _bot.EditMessageTextAsync(
user.ChatId,
update.CallbackQuery.Message.MessageId,
await Helper.GetLocalizationAsync(LocalizationKeys.WRITE_COMMENT, _lang, db),
ParseMode.Markdown);
break;
case "rate":
id = int.Parse(data[1]);
var rating = int.Parse(data[2]);
await SetRating(user, id, rating, db);
await Info(id, user, db, update.CallbackQuery.Message.MessageId);
break;
case "page":
await SendPlacesPage(user, new MessageParams(data[1].Split(';')), db, update.CallbackQuery.Message.MessageId);
break;
case "distance":
var param = new MessageParams(data[1].Split(';'))
{
Page = 0 //distance is changed, setting page to 0
};
await SendPlacesPage(user, param, db, update.CallbackQuery.Message.MessageId);
break;
}
await _bot.AnswerCallbackQueryAsync(update.CallbackQuery.Id);
return;
}
var text = update.Message.Text;
if (!string.IsNullOrEmpty(text))
{
await WriteLogs("Message text", user.ChatId, text);
if (user.IsNew || text.Equals("/language"))
{
await SetUserMode(user, UserMode.None, db);
await ChooseLangauge(db, user);
return;
}
if (text.Equals("/where"))
{
await SetUserMode(user, UserMode.None, db);
var sb = new StringBuilder();
sb.AppendLine(await Helper.GetLocalizationAsync(LocalizationKeys.INFO_ABOUT_CITIES, _lang, db));
var cities = await db.Places.Where(p => p.Active)
.Select(c => c.City)
.OrderBy(c => c.Country)
.ToListAsync();
var groups = cities.GroupBy(c => c.Country).ToList();
var ua = groups.First(g => g.Key == "UA")
.Select(c => $"{Helper.IsoCountryCodeToFlagEmoji(c.Country)} {c.GetName(_lang)}")
.Distinct()
.OrderBy(n => n)
.ToList();
foreach (var city in ua)
{
sb.AppendLine($"• {city}");
}
sb.AppendLine();
foreach (var group in groups.Where(g => g.Key != "UA"))
{
var names = group
.Select(c => $"{Helper.IsoCountryCodeToFlagEmoji(c.Country)} {c.GetName(_lang)}")
.Distinct()
.OrderBy(n => n)
.ToList();
foreach (var name in names)
{
sb.AppendLine($"• {name}");
}
}
await _bot.SendTextMessageAsync(user.ChatId, sb.ToString(), replyMarkup : await LocationKeyboardMarkup(db));
return;
}
if (text.Equals("/suggest"))
{
await SetUserMode(user, UserMode.None, db);
await _bot.SendTextMessageAsync(user.ChatId, await Helper.GetLocalizationAsync(LocalizationKeys.SUGGEST, _lang, db), replyMarkup : await LocationKeyboardMarkup(db));
await SetUserMode(user, UserMode.Suggest, db);
return;
}
if (text.Equals("/help"))
{
await SetUserMode(user, UserMode.None, db);
await SendHelp(user, db);
return;
}
if (user.ChatId.ToString() == ConfigurationManager.AppSettings["MyTelegramChatId"])
{
if (text.Equals("/stat"))
{
var lastUsers = await db.Users.OrderByDescending(u => u.Id).
Take(10).
ToListAsync();
var usersCount = await db.Users.CountAsync();
await SendAdminStat(lastUsers, user, usersCount);
return;
}
if (text.Equals("/last"))
{
var lastUsers = await db.Users.OrderByDescending(u => u.LastMessageTime).
Take(10).
ToListAsync();
await SendAdminStat(lastUsers, user);
return;
}
if (text.Equals("/top"))
{
var topUsers = await db.Users.OrderByDescending(u => u.MessageCount).
Take(10).
ToListAsync();
await SendAdminStat(topUsers, user);
return;
}
}
switch (user.UserMode)
{
case UserMode.None:
//if nothing else
await SendHelp(user, db);
return;
case UserMode.WaitForComment:
var comment = text.Length > 300 ? text.Substring(0, 300) : text;
await SetComment(user, int.Parse(user.UserModeParams), comment, db);
await SetUserMode(user, UserMode.None, db, null);
await _bot.SendTextMessageAsync(
user.ChatId,
await Helper.GetLocalizationAsync(LocalizationKeys.THANKS_FOR_COMMENT, _lang, db),
replyMarkup : await LocationKeyboardMarkup(db));
return;
case UserMode.SetLang:
if (text.Equals("🇺🇦 Українська"))
{
user.Settings.Language = _lang = Language.UA;
}
else if (text.Equals("🇺🇸 English"))
{
user.Settings.Language = _lang = Language.EN;
}
else if (text.Equals("🇷🇺 Русский"))
{
user.Settings.Language = _lang = Language.RU;
}
else
{
await ChooseLangauge(db, user);
return;
}
await SetUserMode(user, UserMode.None, db);
var replyKeyboard = new ReplyKeyboardMarkup(
new List <KeyboardButton> {
new KeyboardButton {
RequestLocation = true,
Text = await Helper.GetLocalizationAsync(LocalizationKeys.SEND_LOCATION, _lang, db)
}
},
resizeKeyboard: true);
await _bot.SendTextMessageAsync(user.ChatId,
await Helper.GetLocalizationAsync(LocalizationKeys.HI_MESSAGE, _lang, db),
replyMarkup : replyKeyboard);
return;
case UserMode.Suggest:
await SetUserMode(user, UserMode.None, db);
await SaveSuggestion(user, text, db);
await _bot.SendTextMessageAsync(user.ChatId,
await Helper.GetLocalizationAsync(LocalizationKeys.THANKS_FOR_SUGGESTION, _lang, db),
replyMarkup : await LocationKeyboardMarkup(db));
return;
}
}
if (update.Message.Location != null)
{
await WriteLogs("Location", user.ChatId, $"{update.Message.Location.Longitude};{update.Message.Location.Latitude}");
await SendPlacesPage(
user,
new MessageParams {
Longitude = update.Message.Location.Longitude,
Latitude = update.Message.Location.Latitude,
Page = 0,
Distance = DefaultDistance
},
db);
}
}
public async Task <ActionResult <PagedList <MessageDTO> > > GetMessagesForUser([FromQuery] MessageParams messageParams)
{
if (!User.Identity.IsAuthenticated)
{
return(Unauthorized("You can't view messages unless you're authenticated"));
}
messageParams.UserName = User.GetUsername();
messageParams.Container = messageParams.Container.ToLower();
var messages = await _messageRepository.GetMessagesForUser(messageParams);
Response.AddPaginationHeaders(messages.PageNumber, messages.TotalPages,
messages.PageSize, messages.TotalCount);
return(Ok(messages));
}
public static async Task <(bool, string, Message)> FindServiceByQuestion(Message source, User user,
UsersRepository users, MessageParams messageParams)
{
var startTime = DateTime.Now;
var question = source.Body;
var lastMessageID = users.GetLastMessageID(user.GUID);
var(success, error, apsolutionsAnswer) = await GetCategorized(user.GUID, user.Fio, user.Position, user.EmploymentDate, question).ConfigureAwait(false);
if (users.IsOlderThenLast(user.GUID, lastMessageID))
{
return(false, null, null);
}
var answerHasError = !success || apsolutionsAnswer is null || apsolutionsAnswer.ServiceIDs is null || apsolutionsAnswer.QuestionCategories is null;
var validServises = apsolutionsAnswer?.ServiceIDs?
.Where(sa => sa.ServiceID != 0 && ServiceItemRepository.GetServiceItems().Exists(s => s.Id == sa.ServiceID));
answerHasError = validServises is null || validServises.Count() == 0;
if (answerHasError)
{
users.SetLastMessageID(user.GUID);
return(true, error, Message.Answer(source, success ? messageParams.NotFound : messageParams.AIError, DateTime.Now.Ticks - startTime.Ticks));
}
Message firstAnswer = null;
var userMessagesForService = new Queue <Message>();
foreach (var apsolutionService in validServises)
{
var serviceItem = ServiceItemRepository.GetServiceItems().FirstOrDefault(s => s.Id == apsolutionService.ServiceID);
var commands = CommandRepository.GetYesNo(source.ID);
commands[0].CommandText = serviceItem.GUID.ToString();
var answer = new Message
{
SourceId = source.ID ?? 0,
UserGuid = source.UserGuid,
Iid = source.Iid,
Date = source.Date,
ServiceGuid = source.ServiceGuid,
Body = $"Используем '{serviceItem.Title}'?",
GUID = Guid.NewGuid(),
Command = 0,
IsFile = false,
Commands = commands,
Style = 1
};
if (firstAnswer is null)
{
firstAnswer = answer;
firstAnswer.Date = firstAnswer.Date.AddTicks(DateTime.Now.Ticks - startTime.Ticks);
}
else
{
userMessagesForService.Enqueue(answer);
}
}
users.SetMessages(user.GUID, QueueType.service, userMessagesForService);
var validCategories = apsolutionsAnswer?.QuestionCategories?
.Where(qc => qc.QuestionCategory != 0 && QuestionCategoryRepository.GetQuestionCategories().Exists(s => s.Id == qc.QuestionCategory));
var userMessagesForQuestionCategory = new Queue <Message>();
foreach (var apsolutionsCategory in validCategories)
{
var answer = new Message
{
SourceId = source.ID ?? 0,
UserGuid = source.UserGuid,
Iid = source.Iid,
Date = source.Date,
ServiceGuid = source.ServiceGuid,
QuestionCategory = apsolutionsCategory.QuestionCategory,
Body = "",
GUID = Guid.NewGuid(),
};
userMessagesForQuestionCategory.Enqueue(answer);
}
users.SetMessages(user.GUID, QueueType.category, userMessagesForQuestionCategory);
users.SetLastMessageID(user.GUID);
return(true, null, firstAnswer);
}
public async Task <PagedList <MessageDto> > GetMessagesForUser(MessageParams messageParams)
{
return(await _messageRepo.GetMessagesForUser(messageParams));
}
private static void ExecuteAndCompleteQuery(string ownerUri, Query query,
IEventSender eventSender,
Query.QueryAsyncEventHandler querySuccessCallback,
Query.QueryAsyncErrorEventHandler queryFailureCallback)
{
// Setup the callback to send the complete event
Query.QueryAsyncEventHandler completeCallback = async q =>
{
// Send back the results
QueryCompleteParams eventParams = new QueryCompleteParams
{
OwnerUri = ownerUri,
BatchSummaries = q.BatchSummaries
};
await eventSender.SendEvent(QueryCompleteEvent.Type, eventParams);
};
// Setup the callback to send the complete event
Query.QueryAsyncErrorEventHandler failureCallback = async(q, e) =>
{
// Send back the results
QueryCompleteParams eventParams = new QueryCompleteParams
{
OwnerUri = ownerUri,
BatchSummaries = q.BatchSummaries
};
await eventSender.SendEvent(QueryCompleteEvent.Type, eventParams);
};
query.QueryCompleted += completeCallback;
query.QueryFailed += failureCallback;
// Add the callbacks that were provided by the caller
// If they're null, that's no problem
query.QueryCompleted += querySuccessCallback;
query.QueryFailed += queryFailureCallback;
// Setup the batch callbacks
Batch.BatchAsyncEventHandler batchStartCallback = async b =>
{
BatchEventParams eventParams = new BatchEventParams
{
BatchSummary = b.Summary,
OwnerUri = ownerUri
};
await eventSender.SendEvent(BatchStartEvent.Type, eventParams);
};
query.BatchStarted += batchStartCallback;
Batch.BatchAsyncEventHandler batchCompleteCallback = async b =>
{
BatchEventParams eventParams = new BatchEventParams
{
BatchSummary = b.Summary,
OwnerUri = ownerUri
};
await eventSender.SendEvent(BatchCompleteEvent.Type, eventParams);
};
query.BatchCompleted += batchCompleteCallback;
Batch.BatchAsyncMessageHandler batchMessageCallback = async m =>
{
MessageParams eventParams = new MessageParams
{
Message = m,
OwnerUri = ownerUri
};
await eventSender.SendEvent(MessageEvent.Type, eventParams);
};
query.BatchMessageSent += batchMessageCallback;
// Setup the ResultSet completion callback
ResultSet.ResultSetAsyncEventHandler resultCallback = async r =>
{
ResultSetEventParams eventParams = new ResultSetEventParams
{
ResultSetSummary = r.Summary,
OwnerUri = ownerUri
};
await eventSender.SendEvent(ResultSetCompleteEvent.Type, eventParams);
};
query.ResultSetCompleted += resultCallback;
// Launch this as an asynchronous task
query.Execute();
}
public async Task <IActionResult> GetMessageThread(int userId, int recipientId, [FromQuery] MessageParams messageParams)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var messages = await _repo.GetMessageThread(userId, recipientId);
var msgThread = _mapper.Map <IEnumerable <MessageToReturnDto> >(messages);
return(Ok(msgThread));
}
public async Task <PagedList <Message> > GetMessageThread(int userId, int recipientId, MessageParams messageParams)
{
var messages = _context.Messages.Include(u => u.Sender).Include(u => u.Recipient)
.Where(m => m.RecipientId == userId && m.RecipientDeleted == false && m.SenderId == recipientId || m.RecipientId == recipientId && m.SenderId == userId && m.SenderDeleted == false)
.OrderByDescending(m => m.MessageSent).AsQueryable();
var list = await PagedList <Message> .CreateAsync(messages, messageParams.PageNumber, messageParams.PageSize);
list.Reverse();
return(list);
}
public async Task <IActionResult> GetMessageThread(int userId, int recipientId, [FromQuery] MessageParams messageParams)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var messageFromRepo = await _repo.GetMessageThread(userId, recipientId, messageParams);
Response.AddPagination(messageFromRepo.CurrentPage, messageFromRepo.PageSize, messageFromRepo.TotalCount, messageFromRepo.TotalPages);
var messageThread = _mapper.Map <IEnumerable <MessageToReturnDto> >(messageFromRepo);
return(Ok(messageThread));
}
public async Task <ActionResult <IEnumerable <MessageDto> > > GetMessagesForUser([FromQuery]
MessageParams messageParams)
{
messageParams.Username = User.GetUsername();
var messages = await _unitOfWork.MessageRepository.GetMessagesForUser(messageParams);
Response.AddPaginationHeader(messages.CurrentPage, messages.PageSize,
messages.TotalCount, messages.TotalPages);
return(messages);
}
public async System.Threading.Tasks.Task <IActionResult> GetMessageForUser(int userId, [FromQuery] MessageParams message)
{
var currentUserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
if (userId != currentUserId)
{
return(Unauthorized());
}
var messageList = await this.idatingService.GetMessagesForUser(message);
Response.AddPagination(messageList.CurrentPage, messageList.PageSize, messageList.TotalCount, messageList.TotalPages);
return(Ok(messageList));
}
