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