public async Task CreateLessonAsync(LessonCreateDTO lessonCreateDTO)
{
var lesson = _mapper.Map <Lesson>(lessonCreateDTO);
var coachLesson = await _coachLessonRepository.GetByIdAsync(lessonCreateDTO.CoachLessonId);
lesson.Date = coachLesson.DateStart;
lesson.NumberOfHours = (float)(coachLesson.DateEnd - coachLesson.DateStart).TotalHours;
lesson.LessonStatusId = (int)LessonStatuses.Reserved;
await _lessonRepository.AddAsync(lesson);
coachLesson.LessonStatusId = (int)LessonStatuses.Reserved;
await _coachLessonRepository.UpdateAsync(coachLesson);
// Symulacja powiadomienia 'Wiadomosc od uzytkownika system'
var student = await _userRepository.GetByIdAsync(lesson.StudentId);
var studentFirstName = student.FirstName;
var studentLastNamePrefix = student.LastName.Trim();
studentLastNamePrefix = studentLastNamePrefix.Length > 1 ? studentLastNamePrefix.First().ToString().ToUpper() + "." : "";
var content = $"Użytkownik {studentFirstName} {studentLastNamePrefix} zapisał się na Twoją lekcję ({coachLesson.Subject.Name} - {coachLesson.DateStart.ToString("yyyy-MM-dd HH:mm")}).";
var message = new Message
{
Content = content,
OwnerId = 0,
RecipientId = coachLesson.CoachId,
DateOfSending = DateTime.Now
};
await _messageService.AddMessageAsync(message);
}
public async Task <IActionResult> Post([FromBody] MessageDto messageDto)
{
//Get header token
if (Request.Headers.TryGetValue("Authorization", out StringValues headerValues))
{
var token = _customEncoder.DecodeBearerAuth(headerValues.First());
if (token != null)
{
//Verify if the token exist and is not expire
if (await _authenticationService.CheckIfTokenIsValidAsync(token, messageDto.UserId))
{
//Verify if messages for this userId exist
var messageApiDto = await _messageService.AddMessageAsync(messageDto);
if (messageApiDto == null)
{
return(StatusCode(404, "Unable to create message."));
}
return(Ok(messageApiDto));
}
return(StatusCode(401, "Invalid token."));
}
return(StatusCode(401, "Invalid authorization."));
}
return(StatusCode(401, "Invalid authorization."));
}
public async Task <IActionResult> CreateMessage(int userId, [FromBody] SaveMessageResource msgResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var profile = await serviceProfile.GetProfile(userId);
if (profile == null)
{
return(BadRequest("Can't find user"));
}
msgResource.SenderMessId = userId;
var msg = mapper.Map <SaveMessageResource, Message>(msgResource);
msg.CreatedAt = DateTime.Now;
msg.CreatedBy = profile.Id.ToString();
await service.AddMessageAsync(msg);
await uow.CompleteAsync();
msg = await service.GetMessage(msg.Id);
return(Ok(mapper.Map <Message, MessageResource>(msg)));
}
public async Task <IActionResult> Index(ChatViewModel model)
{
if (!ModelState.IsValid)
{
return(PartialView("_ChatBox", model));
}
var currentUser = await _applicationUser.GetUser(User.Identity.Name);
var message = new MessageItem
{
MessageBody = model.ChatMessage,
StatusTypeId = (int)EnumMessageStatusType.Sent,
CreatedBy = currentUser.Id
};
await _hubContext.Clients.All.SendAsync("BroadcastMessage", User.Identity.Name, model.ChatMessage, DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss"));
await _messageService.AddMessageAsync(message);
ModelState.Clear();
model.ChatMessage = "";
model.UserName = User.Identity.Name;
return(PartialView("_ChatBox", model));
}
public async Task <ActionResult <ApiResponse> > AddMessage([FromBody] AddMessageRequest request)
{
Debug.Assert(request != null, "Asp.net core failed us and request was null");
var user = await userService.GetUserFromUsernameAsync(User.Identity.Name).ConfigureAwait(false);
if (user == null)
{
logger.LogError($"Failed to find user '{User.Identity.Name}' when trying to add message '{request.Message}'");
return(this.FailureResponse(t["An error occurred trying to send your message"]));
}
var newMessage = await messageService.AddMessageAsync(user.Id, request.Message).ConfigureAwait(false);
if (newMessage == null)
{
logger.LogError($"Failed add message '{request.Message}'");
return(this.FailureResponse(t["An error occurred trying to send your message"]));
}
newMessage.Sender = user;
var apiMessage = newMessage.ToApiLobbyMessage();
await subscriber.PublishAsync(RedisChannels.LobbyMessage, JsonConvert.SerializeObject(apiMessage)).ConfigureAwait(false);
return(new AddMessageResponse {
Success = true, NewMessage = apiMessage
});
}
public async Task SendMessageToUser(string toWhoId, string message, DateTime when)
{
try
{
var fromWhoUser = GetLoggedUser().Id;
if (!string.IsNullOrWhiteSpace(toWhoId) && Guid.TryParse(toWhoId, out Guid gToWhoId))
{
if (_onlineUsersService.IsUserOnline(toWhoId))
{
string toWhoConnectionId = _onlineUsersService.GetOnlineUser(toWhoId).ConnectionId;
await Clients.Client(toWhoConnectionId).SendAsync("ReceiveMessage", fromWhoUser, message, when);
}
await _messageService.AddMessageAsync(gToWhoId, new MessageToAddDto
{
FromWho = Guid.Parse(fromWhoUser),
Text = message,
When = when
});
}
else
{
throw new ArgumentNullException(nameof(toWhoId));
}
}
catch (Exception ex)
{
_logger.LogError("Something went wrong during sending message to the user: {userId}", toWhoId);
_logger.LogError("{0}", ex);
}
return;
}
public async Task <ActionResult <MessageDto> > AddMessage(string userId, MessageToAddDto messageToAdd)
{
try
{
if (Guid.TryParse(userId, out Guid gUserId))
{
if (await _userService.CheckIfUserExists(gUserId))
{
MessageDto addedMessage = await _messageService.AddMessageAsync(gUserId, messageToAdd);
return(CreatedAtRoute("GetMessage",
new
{
userId,
messageId = addedMessage.Id
},
addedMessage));
}
else
{
return(NotFound($"User: {userId} not found."));
}
}
else
{
return(BadRequest($"{userId} is not valid guid."));
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Error occured during adding the user message. User id: {user}", userId);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task <ActionResult> SaveMessage([FromBody] MessageEntity param)
{
// 获取IP地址
if (param.location != null)
{
if (Request.HttpContext.Connection.RemoteIpAddress != null)
{
var ip = Request.HttpContext.Connection.RemoteIpAddress.MapToIPv4().ToString();
param.location = ip;
param.ip = ip;
}
}
param.createDate = DateTime.Now;
param.targetId ??= 0;
var flag = await _messageService.AddMessageAsync(param);
// 发送邮件
if (param.targetId == 0 || param.targetUserId == null)
{
return(Ok(flag));
}
var toMessage = await _messageService.GetMessageByIdAsync(param.targetId.Value);
var fromMessage = await _messageService.GetMessageByIdAsync(param.id);
var isSendReplyEmail = _emailHelper.ReplySendEmail(toMessage, fromMessage, SendEmailType.回复留言);
flag = isSendReplyEmail;
return(Ok(flag));
}
public async Task <IActionResult> Post(AddMessageResquest request)
{
var result = await _messageService.AddMessageAsync(request);
await _messagesHubContext.Clients.Group($"Chat-{request.EventId}-{request.VendorId}")
.SendAsync("ReceiveMessage", result);
return(Ok(result));
}
public async Task SendToConsultants(string text, string username)
{
var email = _httpContextAccessor.HttpContext.User.FindFirst(ClaimsIdentity.DefaultNameClaimType)?.Value;
await Clients.Group("consultants").SendAsync("SendToConsultants", text, username, Context.ConnectionId);
var user = await _userService.GetUserByEmailAsync(email);
await _messageService.AddMessageAsync(new Message { UserFrom = user, Text = text, UsernameTo = "consult" });
}
public async Task SendMessageAsync(string body, string userName, DateTime when)
{
// joined user message use an empty user name and should not be processed
if (!string.IsNullOrWhiteSpace(userName))
{
await _messageService.AddMessageAsync(body, userName, when);
}
await Clients.All.SendAsync("SendMessageAsync", body, userName, when);
}
public async Task SendMessage(ChatMessage chatMessage)
{
if (!_connectionId.TryGetValue(chatMessage.FirstUserId, out var connectionId))
{
return;
}
await _messageService.AddMessageAsync(chatMessage);
await Clients.All.SendAsync("ReceiveMessage", chatMessage.Message, chatMessage.Name, chatMessage.SecondUserId);
}
public async Task <ActionResult <InMessage> > PostMessage(InMessage message)
{
if (message == null || string.IsNullOrEmpty(message.MessageText))
{
return(BadRequest());
}
message.RecivedAt = DateTime.Now;
message.IpAdress = ControllerContext.HttpContext.Connection.RemoteIpAddress.ToString();
_logger.Info($"Сообщение '{message.MessageText}' получено от {message.IpAdress} в {message.RecivedAt}");
await _messageService.AddMessageAsync(message);
return(CreatedAtAction("PostMessage", new { id = message.Id }, message));
}
public async Task <IActionResult> AddMessage(AddMessageViewModel input)
{
if (!this.ModelState.IsValid)
{
return(View(input));
}
if (input.RecepientId == input.PhotographyAddictedUserId)
{
return(this.RedirectToAction("Index", "Home"));
}
var conversationId = await messageService.AddMessageAsync(input);
return(this.RedirectToAction("PreviewConversation", "Conversations", new { conversationId }));
}
public async Task <IActionResult> AddMessage(string eventId, [FromBody] AddMessage addMessage)
{
if (addMessage == null)
{
return(BadRequest());
}
Message message = await _messageService.AddMessageAsync(User.Identity.Name, eventId, addMessage);
if (message == null)
{
return(BadRequest());
}
return(CreatedAtRoute("GetMessage", new { id = message.Id }, message));
}
public async Task <IActionResult> SendMessage([FromBody] MessageDTO message)
{
try
{
var now = DateTime.Now;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (message.RecipientId == 0) // Użytkownik System
{
return(BadRequest());
}
if (!await _userService.IsUserExistsAsync(message.RecipientId))
{
ModelState.AddModelError("RecipientId", "Użytkownik z takim Id nie istnieje.");
return(BadRequest(ModelState));
}
var currentUserId = User.GetUserId().Value;
await _messageService.AddMessageAsync(new Message
{
DateOfSending = now,
OwnerId = currentUserId,
RecipientId = message.RecipientId,
Content = message.Content,
IsRead = false
});
return(StatusCode((int)HttpStatusCode.Created));
}
catch (Exception ex)
{
_logger.Error(ex, "Error during Message creation");
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
}
public async Task <IActionResult> Contact(CreateMessageCommand command)
{
if (!ModelState.IsValid)
{
ViewBag.ShowMessage = true;
ViewBag.Message = "Something went wrong";
return(View());
}
if (string.IsNullOrEmpty(command.Answer) || command.Answer.ToLowerInvariant() != "martha")
{
ViewBag.ShowMessage = true;
ViewBag.Message = "Answer isn't correct. Try again!";
return(View());
}
try
{
CreateMessageValidator.CommandValidation(command);
await _messageService.AddMessageAsync(command);
ViewBag.Added = true;
return(View());
}
catch (InternalSystemException ex)
{
ViewBag.ShowMessage = true;
ViewBag.Message = ex.Message;
return(View());
}
catch (Exception)
{
ViewBag.ShowMessage = true;
ViewBag.Message = "Something went wrong!";
return(View());
}
}
public async Task SendToAll(AddMessageDto message)
{
message.userId = Convert.ToInt32(Context.User.FindFirst(ClaimTypes.NameIdentifier).Value);
var isblocked = _cache.Get($"{message.userId}:{message.chatId}");
if (isblocked == null)
{
isblocked = await this._userService.CheckStatusAsync(message);
_cache.Set($"{message.userId}:{message.chatId}", isblocked, new MemoryCacheEntryOptions
{
AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10)
});
}
if (!(bool)isblocked)
{
var newmessage = await _messageService.AddMessageAsync(message);
await Clients.Group(message.chatId.ToString()).SendAsync("update", newmessage, message.chatId);
}
}
public async Task HandlerAsync(CreateMessage command)
{
await _messageService.AddMessageAsync(command.Content, command.UserId, command.ConversationId);
}
//Store message to db
public async Task SendMessage(Guid conversationId, string message, Guid currentId)
{
var result = await _messageService.AddMessageAsync(message, conversationId, currentId);
await Clients.All.SendAsync("sendToAll", result);
}
