public async Task Send(string groupid, MessageVM message)
{
if (Guid.TryParse(groupid, out Guid guidId))
{
var room = await _roomRep.GetRoom(guidId);
var email = Context.User.Identity.Name;
var user = await _userManager.FindByEmailAsync(email);
var msg = new Message
{
Id = Guid.NewGuid(),
MessageText = message.message,
sender = user,
Date = message.createAt,
ChatRoom = room
};
await _msgRep.Add(msg);
await Clients.Group(groupid).SendAsync("message", _mapper.Map <MessageVM>(msg));
}
}
public async Task Handle(AddMessageCommand message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var messageAggregate = new MessageAggregate
{
Id = Guid.NewGuid().ToString(),
Content = message.Content,
From = message.From,
To = message.To,
IsRead = false,
ProductId = message.ProductId,
ServiceId = message.ServiceId,
ParentId = message.ParentId,
Subject = message.Subject,
ClientServiceId = message.ClientServiceId,
CreateDateTime = DateTime.UtcNow
};
await _messageRepository.Add(messageAggregate);
_eventPublisher.Publish(new MessageAddedEvent
{
Id = messageAggregate.Id,
Content = messageAggregate.Content,
From = messageAggregate.From,
To = messageAggregate.To,
IsRead = messageAggregate.IsRead,
ProductId = messageAggregate.ProductId,
ServiceId = messageAggregate.ServiceId,
ClientServiceId = messageAggregate.ClientServiceId,
ParentId = messageAggregate.ParentId,
Subject = messageAggregate.Subject,
CreateDateTime = messageAggregate.CreateDateTime,
CommonId = message.CommonId
});
}
private void Consumer()
{
var channel = _rabbitConnection.GetModel();
var policy = RetryPolicy.Handle <BrokerUnreachableException>()
.Or <SocketException>()
.WaitAndRetry(_rabbitConnection.GetRetryCount(), retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) =>
{
Console.WriteLine(ex.ToString());
});
policy.Execute(() =>
{
channel.QueueDeclare(queue: _rabbitConnection.GetQueueName(),
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body.ToArray();
var message = Encoding.UTF8.GetString(body);
Console.WriteLine(" [x] Recebida [x] \n{0} ", message);
_repository.Add(JsonConvert.DeserializeObject <Message>(message));
//using (var scope = _scopeFactory.CreateScope())
//{
// var dbContext = scope.ServiceProvider.GetRequiredService<BariContext>();
// dbContext.Messages.Add(JsonConvert.DeserializeObject<Message>(message));
//}
};
channel.BasicConsume(queue: _rabbitConnection.GetQueueName(),
autoAck: true,
consumer: consumer);
});
}
public void Start()
{
var messageNumber = _repository.GetLastMessageNumber();
_connection = _connectionProvider.GetConnection();
_cancellationTokenSource = new CancellationTokenSource();
Task.Run(async() =>
{
while (!_cancellationTokenSource.IsCancellationRequested)
{
var message = GenerateMessage(++messageNumber);
byte[] payload = MessagePackSerializer.Serialize(message);
_connection.Publish("PostTechnology.EventBus", payload);
_monitor?.Information(message);
await _repository.Add(message);
await Task.Delay(1000, _cancellationTokenSource.Token);
}
}, _cancellationTokenSource.Token);
}
public ActionResult SendMessage(long id, FormCollection fc)
{
string strMessage = fc["Message"];
try
{
Guid userid = _repoUserProfile.GetSingle(x => x.Id == id).UserId;
EmailSender.SendMail(Membership.GetUser(userid).Email, "Leonni Private Message", strMessage);
MessageModel objMessage = new MessageModel();
objMessage.SentDate = DateTime.Now;
objMessage.SentBy = _repoUserProfile.GetSingle(x => x.UserId == CurrentUser.UserId).Id;
objMessage.MessageContent = strMessage;
objMessage.SentTo = id;
_repoMessage.Add(MessageMap.Map(objMessage));
_repoMessage.Save();
return(Json(new { status = "success", Message = "Message sent" }));
}
catch (Exception e)
{
return(Json(new { status = "error", Message = "Unable to send Message" }));
}
}
public override async Task <PublishReply> PublishMessage(PublishRequest request, ServerCallContext context)
{
try
{
var message = new Message(request.Bank, request.Content);
await _messageRepository.Add(message, context.CancellationToken);
Console.WriteLine($"Received: {request.Bank}, {request.Content}");
return(await Task.FromResult(new PublishReply
{
IsSuccess = true
}));
}
catch (Exception e)
{
Console.WriteLine($"Publishing gRPC message: {e.Message}");
return(await Task.FromResult(new PublishReply
{
IsSuccess = false
}));
}
}
public void ProcessMessage(string text, string userName)
{
var user = _userRepository.GetByName(userName);
if (user == null)
{
user = new User()
{
Name = userName,
};
_userRepository.Add(user);
}
var message = new Message()
{
Text = text,
User = user,
CreatedDate = DateTime.Now,
};
_messageRepository.Add(message);
_unitOfWork.Commit();
}
private void SendToSubscribers(TextMessage msg)
{
messageRepository.Add(
new Message
{
RoomId = msg.RoomId,
UserId = msg.UserId,
Text = msg.Text,
TimeStamp = msg.TimeStamp
});
mediator.Tell(new Publish("DisplayRoutine", new DisplayMessages(new TextMessage[]
{
new TextMessage
{
RoomId = msg.RoomId,
RoomName = roomState.RoomName,
UserId = msg.UserId,
UserName = msg.UserName,
Text = msg.Text,
TimeStamp = msg.TimeStamp
}
})));
}
public bool Add(Message entity)
{
return(repository.Add(entity));
}
public Message Add(Message item)
{
return(_messageRepository.Add(item));
}
public void Post([FromBody] Message value)
{
_messageRepository.Add(value);
}
public void AddMessage(MessageDto messageDto)
{
messageDto.CreateTime = DateTime.Now;
_messageRepository.Add(QsMapper.CreateMap <MessageDto, Core.Module.Message>(messageDto));
_messageRepository.UnitOfWork.Commit();
}
public async Task <OtpMasterViewModel> AddOtp(int UserId, string Email = null, string Mobile = null)
{
var checkotp = await GetOtpData(UserId);
string OtpValue = string.Empty;
if (checkotp != null)
{
UpdateOtp(checkotp.Id);
}
OtpValue = _userService.GenerateRandomOTPWithPassword().ToString();
string alpha = string.Empty; string numeric = string.Empty;
foreach (char str in OtpValue)
{
if (char.IsDigit(str))
{
if (numeric.Length < 6)
{
numeric += str.ToString();
}
else
{
alpha += str.ToString();
}
}
else
{
alpha += str.ToString();
}
}
int Regtypeid = 0;
if (!String.IsNullOrEmpty(Email))
{
Regtypeid = await _registerTypeService.GetRegisterId(Core.Enums.enRegisterType.Email);
}
else if (!String.IsNullOrEmpty(Mobile))
{
Regtypeid = await _registerTypeService.GetRegisterId(Core.Enums.enRegisterType.Mobile);
}
var currentotp = new OtpMaster
{
UserId = UserId,
RegTypeId = Regtypeid,
OTP = numeric,
CreatedTime = DateTime.UtcNow,
ExpirTime = DateTime.UtcNow.AddHours(2),
Status = 0,
CreatedDate = DateTime.Now,
CreatedBy = UserId
};
_customRepository.Add(currentotp);
if (!String.IsNullOrEmpty(Email))
{
SendEmailRequest request = new SendEmailRequest();
request.Recepient = Email;
// request.Subject = EnResponseMessage.LoginEmailSubject;
// request.Body = EnResponseMessage.SendMailBody + numeric;
IQueryable Result = await _messageConfiguration.GetTemplateConfigurationAsync(Convert.ToInt16(enCommunicationServiceType.Email), Convert.ToInt16(EnTemplateType.LoginWithOTP), 0);
foreach (TemplateMasterData Provider in Result)
{
Provider.Content = Provider.Content.Replace("###USERNAME###", string.Empty);
Provider.Content = Provider.Content.Replace("###Password###", numeric);
//string[] splitedarray = Provider.AdditionaInfo.Split(",");
//foreach (string s in splitedarray)
//{
//}
request.Body = Provider.Content;
request.Subject = Provider.AdditionalInfo;
}
await _mediator.Send(request);
}
if (!String.IsNullOrEmpty(Mobile))
{
SendSMSRequest request = new SendSMSRequest();
request.MobileNo = Convert.ToInt64(Mobile);
request.Message = EnResponseMessage.SendMailBody + numeric;
await _mediator.Send(request);
}
string _Pass1 = alpha.Substring(0, 20);
string _Pass11 = _Pass1 + numeric.Substring(0, 3);
string _Pass2 = alpha.Substring(20, 10);
string _Pass22 = _Pass2 + numeric.Substring(3, 3);
string _Pass3 = alpha.Substring(30, 28);
string password = _Pass11 + _Pass22 + _Pass3;
OtpMasterViewModel model = new OtpMasterViewModel();
if (currentotp != null)
{
model.UserId = currentotp.UserId;
model.RegTypeId = currentotp.RegTypeId;
model.OTP = currentotp.OTP;
model.CreatedTime = currentotp.CreatedTime;
model.ExpirTime = currentotp.ExpirTime;
model.Status = currentotp.Status;
model.Id = currentotp.Id;
model.Password = password;
model.appkey = alpha;
return(model);
}
else
{
return(null);
}
}
public Message Add(Message message)
{
return(_messageRepository.Add(message));
}
public async Task Add(MessageHistory messageHistory)
{
await _messageRepository.Add(messageHistory);
}
public IActionResult Post(Message message)
{
_messageRepo.Add(message);
return(CreatedAtAction("GetMessage", new { id = message.Id }, message));
}
public void Insert(Message entity)
{
_messageRepository.Add(entity);
}
//messages
private void AddNewMessage(Message message)
{
messageRepository.Add(message);
NotifyToAllClients();
}
public Message Post(Message message)
{
Repository.Add(message);
return(message);
}
public Message SendMessage(Message message)
{
return(messageRepository.Add(message));
}
public void UpdateUser(User user, bool updateNavigationProperties = false)
{
if (user == null)
{
throw new ArgumentNullException();
}
var userToUpdate = GetUserById(user.UserId);
if (userToUpdate == null)
{
throw new ArgumentException
($"User with Id = {user.UserId} does not exists");
}
userToUpdate.Image = user.Image ?? userToUpdate.Image;
userToUpdate.Reputation = user.Reputation ?? userToUpdate.Reputation;
userToUpdate.Username = user.Username ?? userToUpdate.Username;
userToUpdate.E_mail = user.E_mail ?? userToUpdate.E_mail;
if (updateNavigationProperties)
{
userToUpdate.RoleId = user.RoleId;
foreach (Topic topic in user.Topics)
{
Topic topicOrm = topicRepository.GetById(topic.TopicId);
if (topicOrm == null)
{
topicRepository.Add(topic);
}
else
{
topicRepository.Update(topic);
}
}
foreach (Message message in user.Messages)
{
Message messageOrm = messageRepository.GetById(message.MessageId);
if (messageOrm == null)
{
messageRepository.Add(message);
}
else
{
messageRepository.Update(message);
}
}
foreach (SectionModerator moderationInfoEntry in user.SectionModerators)
{
SectionModerator moderationInfoEntryCurrent = sectionModeratorsRepository
.GetByPrimaryKey(moderationInfoEntry.SectionId, moderationInfoEntry.UserId);
if (moderationInfoEntryCurrent == null)
{
sectionModeratorsRepository.Add(moderationInfoEntry);
}
else
{
sectionModeratorsRepository.Update(moderationInfoEntry);
}
}
}
ctx.Entry(userToUpdate).State = EntityState.Modified;
ctx.SaveChanges();
}
public async Task <bool> Add(MessageDetail message)
{
await Task.Run(() => Repository.Add(message));
return(true);
}
async Task StoreMessage(ChatMessage message)
{
_messageRepo.Add(message);
await _messageRepo.SaveChangesAsync();
}
public void CreateMessage(Message message)
{
_messageRepository.Add(message);
_unitOfWork.Commit();
}
public async Task SaveAsync(Message message)
{
message.Id = Guid.NewGuid().ToString();
_messageRepository.Add(message);
await _messageRepository.SaveChangesAsync();
}
public void MessageAddTest()
{
Assert.Empty(repo.ShowAllMessages());
Message m = new Message()
{
FromID = "3", ToID = "4", ID = 1, Status = Read.Unread, Text = "Test Message 2 Text"
};
repo.Add(m);
Assert.Single(repo.ShowAllMessages());
}
