public async Task SendMessage_ExistConversation()
{
//Arrange
var input = new SendMessageInput()
{
Message = "message",
ReceiverUserName = "******"
};
var existsConversation = new ConversationModel()
{
Id = new ObjectId()
};
_mockRepository.Get(Arg.Any <Expression <Func <ConversationModel, bool> > >())
.ReturnsForAnyArgs(existsConversation);
//Act
await _messageService.SendMessage(input);
//Assert
await _mockRepository.Received().Update(Arg.Is(existsConversation.Id.ToString()),
Arg.Is <ConversationModel>(x =>
x.Messages.Any(m => m.MessageText == input.Message &&
m.ReceiverUserName == input.ReceiverUserName &&
m.SenderUserName == _loggedUser.UserName)));
}
public async Task <ActionResult <MessageDto> > SendMessage([FromBody] SendMessageInput parameters)
{
var validationTasks = new List <Task <bool> >
{
IsContactValid(parameters.SenderId),
IsContactValid(parameters.RecipientId),
};
await Task.WhenAll(validationTasks);
if (validationTasks.Any(t => !t.Result))
{
return(BadRequest());
}
try
{
var message =
await _messageService.SendMessage(parameters.SenderId, parameters.RecipientId, parameters.Text);
await _context.SaveChangesAsync();
var messageDto = _mapper.Map <Message, MessageDto>(message);
return(CreatedAtAction("GetMessage", new { id = messageDto.Id }, messageDto));
}
catch (DbUpdateException)
{
return(BadRequest());
}
}
public async Task SendMessage(SendMessageInput input)
{
if (!input.From.HasValue || !input.To.HasValue)
{
throw new UserFriendlyException(L("NoUserDetected"));
}
var from = await UserManager.GetUserByIdAsync(input.From.Value);
var to = await UserManager.GetUserByIdAsync(input.To.Value);
var id = await _chatManager.CreateConversation(from, to, AbpSession.TenantId);
var conversation = _chatManager.Conversations.FirstOrDefault(a => a.Id == id);
var msId = await _chatManager.AddMessage(conversation, from, input.Message);
if (msId != 0)
{
await _chatMessageSender.PublishMessage(
new ChatData(from.MapTo <UserOutput>(),
to.MapTo <UserOutput>(),
id,
input.Message));
}
}
public IRestResponse <SendMessageResponse> SendMessage(SendMessageInput input)
{
try
{
LogInput(input);
var req = new RestRequest("sendMessage", Method.POST);
req.AddParameter("chat_id", input.ChatId);
req.AddParameter("type", input.MessageType);
req.AddParameter("data", input.Data);
req.AddParameter("reply_keyboard", input.ReplyKeyboard);
req.AddParameter("inline_keyboard", input.InlineKeyboard);
req.AddParameter("form", input.Form);
var response = RestApi.Execute <SendMessageResponse>(req);
LogOutput(response, new
{
hasData = response.Data != null,
method = "SendMessage",
input.ChatId
});
return(response);
}
catch (Exception ex)
{
Logger.Log("SendMessage", LogErrorLevel.Error, ex);
return(null);
}
}
private async Task <(SendMessageInput model, bool toast)> InvalidCommand(SendMessageInput model, long stateId, string text = null)
{
var info = await _userInfoService.GetUserInfo(model.ChatId);
model.Keypad = await _keypadService.GenerateButtonsAsync(stateId, info);
model.Text = text ?? Messages.InvalidCommand;
return(model, true);
}
public ApiResult SendRaw([FromBody] SendMessageInput messageInput)
{
if (!this.IsFormValid())
{
return(ApiResult.Failure(this.FormInvalidReason()));
}
var result = Resolve <ISmsService>().SendRaw(messageInput.Mobile, messageInput.Content, AutoModel.UserId);
return(ToResult(result));
}
public async Task <IResponseOutput> SendMessageAsync(SendMessageInput input)
{
var content = new StringContent($"text={input.Text}&desp={input.Desc}");
content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/x-www-form-urlencoded");
using var client = _httpClient.CreateClient();
await client.PostAsync($"{_ftqqOptions.ApiUrl}/{_ftqqOptions.Token}.send", content);
return(ResponseOutput.Ok(content));
}
public void SendMessage_EmptyReceiverUserName_ThrowError()
{
//Arrange
var input = new SendMessageInput()
{
Message = "b",
ReceiverUserName = string.Empty
};
//Act && Assert
_messageService.SendMessage(input).ShouldThrow <ArgumentNullException>();
}
public async Task <SendMessagesOutput> SendMessage(SendMessageInput model)
{
try
{
return(await _apiService.PostAsync <SendMessagesOutput>(Variables.BotApi, new { method = "sendMessage", data = model }, _botHeader));
}
catch (Exception e)
{
await _exceptionLogService.LogException(e, model.ChatId, "SendMessage");
return(null);
}
}
public async Task SendMessage_Fail_WrongSender()
{
var message = new SendMessageInput()
{
SenderId = Guid.Empty,
RecipientId = DestinatairePredefinedIds.ContactIds.AndrejStajerId,
Text = "Lorem ipsum",
};
var response = await Client.PostAsync("/Messages",
new StringContent(JsonConvert.SerializeObject(message), Encoding.UTF8, "application/json"));
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
public async Task <BlogResponse> SendMessageAsync(SendMessageInput input)
{
var response = new BlogResponse();
var content = new StringContent($"text={input.Text}&desp={input.Desc}");
content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
using var client = _httpClient.CreateClient();
await client.PostAsync("https://sc.ftqq.com/SCU60393T5a94df1d5a9274125293f34a6acf928f5d78f551cf6d6.send", content);
return(response);
}
public async Task <BlogResponse> SendMessageAsync(SendMessageInput input)
{
var response = new BlogResponse();
var content = new StringContent($"text={input.Text}&desp={input.Desc}");
content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
using var client = _httpClient.CreateClient();
await client.PostAsync($"https://sc.ftqq.com/{_appOptions.ScKey}.send", content);
return(response);
}
public async Task <IActionResult> Post(SendMessageInput input)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
_logger.LogInformation("Mesaj gonderilecek");
await _messageService.SendMessage(input);
_logger.LogInformation("Mesaj Gonderdildi.");
return(Ok());
}
public async Task <int> CreateConversation(SendMessageInput input)
{
if (!input.From.HasValue || !input.To.HasValue)
{
throw new UserFriendlyException(L("NoUserDetected"));
}
var from = await UserManager.GetUserByIdAsync(input.From.Value);
var to = await UserManager.GetUserByIdAsync(input.To.Value);
var id = await _chatManager.CreateConversation(from, to, AbpSession.TenantId);
return(id);
}
public async Task SendMessage([FromForm] SendMessageInput input)
{
await _signalrHelper.PushNotifyAsync(new Dtos.Send()
{
GroupIds = input.SelectGroups,
UserIds = input.SelectUsers,
NotifyObj = new
{
TenantType = "chat",
MethodType = "message",
Message = $"{User.Identity.Name}:{input.Message}"
}
});
}
public void Add(SendMessageInput input)
{
var chatRecord = new ChatRecord
{
Id = input.Id,
Body = input.Body,
Sender = input.Sender,
Receiver = input.Receiver,
SendOn = input.SendOn,
Type = input.Type
};
_chatRecordRepository.Insert(chatRecord);
}
public async Task <BlogResponse> SendMessageAsync(SendMessageInput input)
{
var response = new BlogResponse();
var content = new StringContent($"text={input.Text}&desp={input.Desc}");
content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
using var client = _httpClient.CreateClient();
_logger.LogInformation($"FtqqUrl: {_notificationOptions.FtqqUrl}");
await client.PostAsync(_notificationOptions.FtqqUrl, content);
return(response);
}
public void SendMessage_blockedUser_ThrowError()
{
//Arrange
var input = new SendMessageInput()
{
Message = "abc",
ReceiverUserName = "******"
};
_mockUserService.IsUserBlocked(Arg.Any <string>()).ReturnsForAnyArgs(true);
//Act && Assert
_messageService.SendMessage(input).ShouldThrow <UserFriendlyException>();
}
public async Task <CommandResult <SendMessageResult> > Save([FromServices] SendMessageCommand sendMessageCommand,
[FromBody] SendMessageInput input)
{
var userInput = new UserInput <SendMessageInput>
{
UserId = User.Identity.IsAuthenticated ? User.GetUserId() : string.Empty,
Data = input
};
var result = await
Business.InvokeAsync <SendMessageCommand, UserInput <SendMessageInput>, CommandResult <SendMessageResult> >(
sendMessageCommand, userInput);
return(result);
}
public async Task SendMessage(SendMessageInput input)
{
if (input.Message.IsNullOrEmpty() || input.ReceiverUserName.IsNullOrEmpty())
{
var propertyNme = input.Message.IsNullOrEmpty()
? nameof(input.Message)
: nameof(input.ReceiverUserName);
throw new ArgumentNullException(propertyNme);
}
var user = _userService.GetCurrentUser();
var isUserBlocked = await _userService.IsUserBlocked(input.ReceiverUserName);
if (isUserBlocked)
{
var errorMessage = $"You can't send messaje to {input.ReceiverUserName}. You are blocked";
throw new UserFriendlyException(errorMessage);
}
var messageModel = new MessageModel
{
ReceiverUserName = input.ReceiverUserName,
MessageText = input.Message,
SenderUserName = user.UserName
};
var conversation = await GetConversation(user.UserName, input.ReceiverUserName);
if (conversation == null)
{
conversation = new ConversationModel();
conversation.Messages.Add(messageModel);
conversation.Users.Add(input.ReceiverUserName);
conversation.Users.Add(user.UserName);
conversation.LastMessageDateTime = messageModel.CreateAt;
await _conversationRepository.Create(conversation);
}
else
{
conversation.Messages.Add(messageModel);
conversation.LastMessageDateTime = messageModel.CreateAt;
await _conversationRepository.Update(conversation.Id.ToString(), conversation);
}
}
public async Task <IActionResult> SendMsg(SendMessageInput input)
{
try
{
var message = new CatMessage
{
Type = input.Type,
Chat = new IM.Google.Protobuf.Chat
{
Info = new Base
{
Id = input.Id.ToString(),
Sender = input.Sender.ToString(),
Receiver = input.Receiver.ToString(),
SendOn = input.SendOn.ToString(),
},
Body = input.Body
}
};
var routeKey = await _cacheManager.GetStringAsync($"{CacheKeys.ROUTER}{input.Receiver}");
if (string.IsNullOrWhiteSpace(routeKey))
{
_rabbitManager.SendMsg("Cat.IM.OfflineMessage", message, "Cat.IM.OfflineMessage");
}
else
{
_rabbitManager.SendMsg(routeKey, message);
}
_chatRecordService.Add(input);
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
return(Ok());
}
public async Task SendMessage_NewConversation()
{
//Arrange
var input = new SendMessageInput()
{
Message = "message",
ReceiverUserName = "******"
};
_mockRepository.Get(Arg.Any <Expression <Func <ConversationModel, bool> > >())
.ReturnsForAnyArgs((ConversationModel)null);
//Act
await _messageService.SendMessage(input);
//Assert
await _mockRepository.Received().Create(Arg.Is <ConversationModel>(x =>
x.Messages.Any(m => m.MessageText == input.Message &&
m.ReceiverUserName == input.ReceiverUserName &&
m.SenderUserName == _loggedUser.UserName)));
}
public async Task <SendMessagePayload> SendMessage(
SendMessageInput input,
[Service] IMessageDb messageDb,
[Service] ITopicEventSender eventSender
)
{
var(authorId, groupId, authorName, content) = input;
var message = new ChatMessage(
MessageId: Guid.NewGuid(),
Timestamp: DateTimeOffset.UtcNow,
GroupId: groupId,
AuthorId: authorId,
AuthorUsername: authorName,
Content: content
);
await eventSender.SendAsync(new Topic.NewMessage(groupId), message);
await messageDb.AddMessage(message);
return(new SendMessagePayload(message));
}
public async Task SendMessage(SendMessageInput input)
{
var message = await _chatMessageRepository.InsertAsync(new ChatMessage
{
SessionId = input.SessionId,
UserId = input.UserId,
SenderName = input.SenderName,
Message = input.Message,
CreationTime = DateTimeOffset.Now.ToUnixTimeMilliseconds(),
ReadState = ChatMessageReadState.Unread
});
await CurrentUnitOfWork.SaveChangesAsync();
// 推送消息给接收人
var receivers = await GetSessionMembersUserId(input.SessionId);
foreach (var item in receivers)
{
await _chatCommunicator.SendMessageToUser(new UserIdentifier(AbpSession.TenantId, item), message);
}
}
public async Task SendMessage()
{
var message = new SendMessageInput()
{
SenderId = DestinatairePredefinedIds.ContactIds.AndrejStajerId,
RecipientId = DestinatairePredefinedIds.ContactIds.CaptainId,
Text = "Lorem ipsum",
};
var json = JsonConvert.SerializeObject(message);
var response =
await Client.PostAsync("/Messages", new StringContent(json, Encoding.UTF8, "application/json"));
response.EnsureSuccessStatusCode();
var stringResponse = await response.Content.ReadAsStringAsync();
var model = JsonConvert.DeserializeObject <MessageDto>(stringResponse);
Assert.Equal(message.RecipientId, model.ReceiverId);
Assert.Equal(message.SenderId, model.SenderId);
Assert.Equal(message.Text, model.Text);
}
private async Task <(SendMessageInput model, bool toast)> Command(MessageModel myMessage)
{
var buttonId = myMessage.AuxData == null ? "" : myMessage.AuxData.ButtonId;
var chatId = myMessage.ChatId;
var messageText = myMessage.Text;
var userDataEntity = await _userDataService.GetUserData(chatId);
var model = new SendMessageInput
{
Keypad = new KeypadModel
{
Rows = new List <KeypadRowModel>()
},
ReplyTimeout = Variables.ReplyTimeout,
ChatId = chatId
};
//start
if (userDataEntity == null)
{
await _userDataService.Update(chatId, 1);
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 1, new GroupEntity());
model.Text = Messages.WelcomeMessage;
return(model, false);
}
if (string.IsNullOrEmpty(buttonId))
{
var info = await _groupService.GetGroupInfo(chatId);
if (info.IsFinished)
{
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 6, info);
model.Text = null;
return(model, true);
}
return(await InvalidCommand(model, userDataEntity.StateId));
}
if (buttonId == "centerName")
{
var info = await _groupService.SetCenterName(chatId, messageText);
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 1, info);
model.Text = null;
return(model, true);
}
if (buttonId == "centerType")
{
var centerType = messageText.GetCenterTypeEnumByValue();
var info = await _groupService.SetCenterType(chatId, centerType.Value);
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 1, info);
model.Text = null;
return(model, true);
}
if (buttonId == "gender")
{
var gender = messageText.GetGenderEnumByValue();
var info = await _groupService.SetGenderType(chatId, gender.Value);
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 1, info);
model.Text = null;
return(model, true);
}
if (buttonId == "province")
{
var province = await _provinceService.GetProvinceAsync(messageText);
var info = await _groupService.SetProvince(chatId, province);
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 1, info);
model.Text = null;
return(model, true);
}
if (buttonId == "address")
{
var info = await _groupService.SetAddress(chatId, messageText);
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 1, info);
model.Text = null;
return(model, true);
}
if (buttonId == "postalCode")
{
GroupEntity info;
if (messageText.IsValidPostalCode())
{
info = await _groupService.SetPostalCode(chatId, messageText.PersianToEnglish());
}
else
{
info = await _groupService.GetGroupInfo(model.ChatId);
model.Text = Messages.InvalidPostalCode;
}
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 1, info);
return(model, true);
}
if (buttonId == "phone")
{
var info = await _groupService.SetPhone(chatId, messageText.PersianToEnglish());
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 1, info);
model.Text = null;
return(model, true);
}
if (buttonId == "managerName")
{
var info = await _groupService.SetManagerName(chatId, messageText);
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 1, info);
model.Text = null;
return(model, true);
}
if (buttonId == "1-continue")
{
var info = await _groupService.GetGroupInfo(chatId);
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 2, info);
model.Text = "اطلاعات مرکز آموزشی ثبت شد.";
return(model, true);
}
if (buttonId == "supervisorName")
{
var info = await _groupService.SetSupervisorName(chatId, messageText);
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 2, info);
model.Text = null;
return(model, true);
}
if (buttonId == "supervisorEmail")
{
GroupEntity info;
if (messageText.IsValidEmail())
{
info = await _groupService.SetSupervisorEmail(chatId, messageText);
model.Text = null;
}
else
{
info = await _groupService.GetGroupInfo(chatId);
model.Text = Messages.InvalidEmail;
}
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 2, info);
return(model, true);
}
if (buttonId == "supervisorMobile")
{
GroupEntity info;
if (messageText.IsValidMobile())
{
info = await _groupService.SetSupervisorMobile(chatId, messageText);
model.Text = null;
}
else
{
info = await _groupService.GetGroupInfo(chatId);
model.Text = Messages.InvalidMobileNumber;
}
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 2, info);
return(model, true);
}
if (buttonId == "2-continue")
{
var info = await _groupService.GetGroupInfo(chatId);
model.Text = "اطلاعات دبیر راهنما ثبت شد.";
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 3, info);
return(model, true);
}
if (buttonId == "2-return")
{
var info = await _groupService.GetGroupInfo(chatId);
model.Text = null;
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 1, info);
return(model, true);
}
if (buttonId == "subject")
{
var info = await _groupService.SetProjectSubject(chatId, messageText);
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 3, info);
model.Text = null;
return(model, true);
}
if (buttonId == "ax")
{
var ax = await _festivalService.GetFestivalAxes(messageText);
var info = await _groupService.SetFestivalAxes(chatId, ax);
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 3, info);
model.Text = null;
return(model, true);
}
if (buttonId == "major")
{
var major = await _festivalService.GetFestivalMajor(messageText);
var info = await _groupService.SetFestivalMajor(chatId, major);
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 3, info);
model.Text = null;
return(model, true);
}
if (buttonId == "field")
{
var field = await _festivalService.GetFestivalField(messageText);
var info = await _groupService.SetFestivalField(chatId, field);
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 3, info);
model.Text = null;
return(model, true);
}
if (buttonId == "membersCount")
{
var info = await _groupService.SetMembersCount(chatId, Int32.Parse(messageText));
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 3, info);
model.Text = null;
return(model, true);
}
if (buttonId == "3-continue")
{
var info = await _groupService.GetGroupInfo(chatId);
model.Text = "اطلاعات پروژه ثبت شد.";
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 4, info);
return(model, true);
}
if (buttonId == "3-return")
{
var info = await _groupService.GetGroupInfo(chatId);
model.Text = null;
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 2, info);
return(model, true);
}
if (buttonId == "grade")
{
var grade = EnumValue.GetGradeEnumByValue(messageText);
var info = await _groupService.SetMembersGrade(chatId, grade.Value);
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 4, info);
model.Text = null;
return(model, true);
}
if (buttonId.StartsWith("memberName"))
{
var info = await _groupService.GetGroupInfo(chatId);
var number = int.Parse(buttonId.Replace("memberName", ""));
await _groupService.SetMemberName(chatId, info.Id, number, messageText);
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 4, info);
return(model, true);
}
if (buttonId.StartsWith("memberNationalCode"))
{
var info = await _groupService.GetGroupInfo(chatId);
var number = int.Parse(buttonId.Replace("memberNationalCode", ""));
if (messageText.IsValidNationalCode())
{
await _groupService.SetMemberNationalCode(chatId, info.Id, number, messageText);
}
else
{
model.Text = Messages.InvalidNationalCode;
}
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 4, info);
return(model, true);
}
if (buttonId == "4-continue")
{
var info = await _groupService.SetPrice(chatId);
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 5, info);
model.Text = GetGroupInfo(info);
await _messengerService.SendMessage(model);
model.Text = await GetMembersInfo(info);
return(model, true);
}
if (buttonId == "4-return")
{
var info = await _groupService.GetGroupInfo(chatId);
model.Text = null;
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 3, info);
return(model, true);
}
//Payment
if (buttonId == "payment")
{
var groupInfo = await _groupService.GetGroupInfo(model.ChatId);
if (myMessage.AuxData == null || string.IsNullOrEmpty(myMessage.AuxData.OrderId))
{
model.Text = Messages.ErrorPay;
model.Keypad = await _keypadService.GenerateButtonsAsync(model.ChatId, 4, groupInfo);
return(model, true);
}
var orderId = int.Parse(myMessage.AuxData.OrderId);
var order = await _orderService.UpdateOrderStatus(orderId, myMessage.AuxData.OrderStatus);
if (order == null || myMessage.AuxData.OrderStatus == OrderStatusEnum.Error)
{
model.Text = Messages.ErrorPay;
model.Keypad = await _keypadService.GenerateButtonsAsync(model.ChatId, 4, groupInfo);
return(model, true);
}
else
{
var settle = await _messengerService.SettlePayment(model.ChatId, order.Id.ToString(), order.PaymentToken);
await _orderService.UpdateSettleStatus(orderId, settle.Data.SettleStatus);
if (settle.Data.SettleStatus == SettleStatusEnum.Reject)
{
model.Text = Messages.ErrorPay;
model.Keypad = await _keypadService.GenerateButtonsAsync(model.ChatId, 4, groupInfo);
return(model, true);
}
else //(settle.Data.SettleStatus == SettleStatusEnum.Done)
{
await _groupService.SetFinished(model.ChatId, orderId);
model.Text = Messages.SuccessRegister;
model.Keypad = await _keypadService.GenerateButtonsAsync(model.ChatId, 6, groupInfo);
return(model, false);
}
}
}
if (buttonId == "5-return")
{
var info = await _groupService.GetGroupInfo(chatId);
model.Text = null;
model.Keypad = await _keypadService.GenerateButtonsAsync(chatId, 4, info);
return(model, true);
}
return(await InvalidCommand(model, userDataEntity.StateId));
}
public async Task <ServiceResult> SendMessageAsync(SendMessageInput input)
{
await _chatAppService.SendMessageAsync(input);
return(await ServiceResult.IsSuccess());
}
private async Task <(SendMessageInput model, bool toast)> Command(MessageModel myMessage)
{
var buttonId = myMessage.AuxData == null ? "" : myMessage.AuxData.ButtonId;
var chatId = myMessage.ChatId;
var messageText = myMessage.Text;
var userDataEntity = await _userDataService.GetUserData(chatId);
var model = new SendMessageInput
{
Keypad = new KeypadModel
{
Rows = new List <KeypadRowModel>()
},
ReplyTimeout = Variables.ReplyTimeout,
ChatId = chatId
};
if (string.IsNullOrEmpty(buttonId) && userDataEntity != null)
{
return(await InvalidCommand(model, userDataEntity.StateId));
}
if (!string.IsNullOrEmpty(buttonId) && userDataEntity != null)
{
var button = await _buttonService.GetButton(buttonId);
if (button == null || button.StateId != userDataEntity.StateId)
{
return(await InvalidCommand(model, userDataEntity.StateId));
}
}
//start
if (userDataEntity == null)
{
await _userDataService.Update(chatId, 1);
model.Keypad = await _keypadService.GenerateButtonsAsync(1, new UserInfoEntity());
model.Text = Messages.WelcomeMessage;
return(model, false);
}
else if (buttonId == "1-1") // firsname
{
await _userDataService.Update(chatId, 1);
var info = await _userInfoService.UpdateFirsName(chatId, messageText);
model.Keypad = await _keypadService.GenerateButtonsAsync(1, info);
model.Text = null;
return(model, false);
}
else if (buttonId == "1-2") // lastname
{
await _userDataService.Update(chatId, 1);
var info = await _userInfoService.UpdateLastName(chatId, messageText);
model.Keypad = await _keypadService.GenerateButtonsAsync(1, info);
model.Text = null;
return(model, false);
}
else if (buttonId == "1-3") // povince
{
await _userDataService.Update(chatId, 1);
var province = await _provinceService.GetProvinceAsync(messageText);
var info = new UserInfoEntity();
if (province != null)
{
info = await _userInfoService.UpdateProvince(chatId, province.Id, province.Name);
}
else
{
info = await _userInfoService.GetUserInfo(chatId);
}
model.Keypad = await _keypadService.GenerateButtonsAsync(1, info);
model.Text = null;
return(model, false);
}
else if (buttonId == "1-4") // city
{
await _userDataService.Update(chatId, 1);
var info = await _userInfoService.GetUserInfo(chatId);
var city = await _provinceService.GetCityAsync(info.ProvinceId.Value, messageText);
if (city != null)
{
info = await _userInfoService.UpdateCity(chatId, city.Id, city.Name);
}
model.Keypad = await _keypadService.GenerateButtonsAsync(1, info);
model.Text = null;
return(model, false);
}
else if (buttonId == "1-5") // population status
{
await _userDataService.Update(chatId, 1);
var populationStatus = Utility.EnumValue.GetPopulationEnumByValue(messageText);
var info = new UserInfoEntity();
if (populationStatus.HasValue)
{
info = await _userInfoService.UpdatePopulationStatus(chatId, populationStatus.Value, messageText);
}
else
{
info = await _userInfoService.GetUserInfo(chatId);
}
model.Keypad = await _keypadService.GenerateButtonsAsync(1, info);
model.Text = null;
return(model, false);
}
else if (buttonId == "1-6") // mobile
{
await _userDataService.Update(chatId, 1);
var info = new UserInfoEntity();
if (messageText.Length == 11 && messageText.StartsWith("09"))
{
info = await _userInfoService.UpdateMobile(chatId, messageText);
model.Text = null;
}
else
{
info = await _userInfoService.GetUserInfo(chatId);
model.Text = Messages.InvalidMobileNumber;
}
model.Keypad = await _keypadService.GenerateButtonsAsync(1, info);
return(model, false);
}
else if (buttonId == "1-submit")
{
var info = await _userInfoService.GetUserInfo(chatId);
model.Keypad = await _keypadService.GenerateButtonsAsync(2, info);
await _userDataService.Update(chatId, 2);
model.Text = null;
return(model, false);
}
else if (buttonId == "2-1") // address
{
await _userDataService.Update(chatId, 2);
var info = await _userInfoService.UpdateAddress(chatId, messageText);
model.Keypad = await _keypadService.GenerateButtonsAsync(2, info);
model.Text = null;
return(model, false);
}
else if (buttonId == "2-2") // postalcode
{
await _userDataService.Update(chatId, 2);
UserInfoEntity info;
if (messageText.Length == 10)
{
info = await _userInfoService.UpdatePostalCode(chatId, messageText);
model.Text = null;
}
else
{
info = await _userInfoService.GetUserInfo(chatId);
model.Text = Messages.InvalidPostalCode;
}
model.Keypad = await _keypadService.GenerateButtonsAsync(2, info);
return(model, false);
}
else if (buttonId == "2-3") // birthdate
{
await _userDataService.Update(chatId, 2);
var info = await _userInfoService.UpdateBirthDate(chatId, messageText);
model.Keypad = await _keypadService.GenerateButtonsAsync(2, info);
model.Text = null;
return(model, false);
}
else if (buttonId == "2-4") // national code
{
await _userDataService.Update(chatId, 2);
var userInfo = new UserInfoEntity();
if (messageText.Length != 10 || !messageText.IsValidNationalCode())
{
userInfo = await _userInfoService.GetUserInfo(model.ChatId);
model.Text = Messages.InvalidNationalCode;
}
else
{
userInfo = await _userInfoService.UpdateNationalCode(chatId, messageText);
model.Text = null;
}
model.Keypad = await _keypadService.GenerateButtonsAsync(2, userInfo);
return(model, false);
}
else if (buttonId == "2-5") // position
{
await _userDataService.Update(chatId, 2);
var position = EnumValue.GetPositionEnumByValue(messageText);
UserInfoEntity info;
if (position.HasValue)
{
info = await _userInfoService.UpdatePosition(chatId, position.Value, messageText);
}
else
{
info = await _userInfoService.GetUserInfo(chatId);
}
model.Keypad = await _keypadService.GenerateButtonsAsync(2, info);
model.Text = null;
return(model, false);
}
else if (buttonId == "2-submit")
{
await _userDataService.Update(chatId, 3);
var info = await _userInfoService.GetUserInfo(chatId);
model.Keypad = await _keypadService.GenerateButtonsAsync(3, info);
if (string.IsNullOrEmpty(info.VideoSrc))//First time for upload
{
model.Text = Messages.UploadGreeting;
await _messengerService.SendMessage(model);
}
model.Text = null;
return(model, false);
}
else if (buttonId == "2-return")
{
await _userDataService.Update(chatId, 1);
var info = await _userInfoService.GetUserInfo(chatId);
model.Keypad = await _keypadService.GenerateButtonsAsync(1, info);
model.Text = null;
return(model, false);
}
else if (buttonId == "3-1") // video
{
await _userDataService.Update(chatId, 3);
var upload = await UploadVideo(chatId, myMessage);
if (!string.IsNullOrEmpty(upload.fileSrc))
{
var info = await _userInfoService.UpdateVideo(chatId, upload.fileSrc);
model.Keypad = await _keypadService.GenerateButtonsAsync(3, info);
return(model, false);
}
else
{
var info = await _userInfoService.GetUserInfo(chatId);
model.Keypad = await _keypadService.GenerateButtonsAsync(3, info);
if (upload.error == UploadErrorEnum.OverSize)
{
model.Text = Messages.OverSizeVideo;
}
else if (upload.error == UploadErrorEnum.InvalidExtension)
{
model.Text = Messages.InvalidFileExtension;
}
else if (upload.error == UploadErrorEnum.UploadIssue)
{
model.Text = Messages.FileNotUploaded;
}
return(model, true);
}
}
//else if (buttonId == "3-submit")
//{
// await _userDataService.Update(chatId, 3);
// var info = await _userInfoService.GetUserInfo(chatId);
// model.Keypad = await _keypadService.GenerateButtonsAsync(4, info);
// model.Text = null;
// return (model, false);
//}
else if (buttonId == "3-return")
{
await _userDataService.Update(chatId, 2);
var info = await _userInfoService.GetUserInfo(chatId);
model.Keypad = await _keypadService.GenerateButtonsAsync(2, info);
model.Text = null;
return(model, false);
}
return(await InvalidCommand(model, userDataEntity.StateId));
}
public async Task SendMessageAsync(SendMessageInput input)
{
Guid targetId = new Guid(input.TargetUserName);
await _distributedEventBus.PublishAsync(new ReceivedMessageEto(targetId, CurrentUser.UserName, input.Message));
}
public async Task SendMessageAsync(SendMessageInput input)
{
await _chatAppService.SendMessageAsync(input);
}
