private void Work()
{
//generate message
Data.Message message = Test.GenerateMessage();
Debug.WriteLine("Bot generated new message");
//setting new DateTime
message.DateTime = DateTime.Now;
//generate user to speak with
Data.User newUser = Test.GenerateUser();
//check if generated user == current
if (newUser == user)
{
Debug.WriteLine("Generated user already exists");
}
else
{
Debug.WriteLine("Bot generated new message from " + newUser.Name);
//generate event
MessageGenerated(message, newUser);
}
}
public async Task Send(string messageText)
{
if (string.IsNullOrEmpty(messageText))
{
return;
}
var chatId = int.Parse(this.Context.GetHttpContext().Request.RouteValues["id"].ToString());
var chat = this.chatService.GetChatById(chatId);
var message = new Data.Message
{
ChatId = chatId,
SenderUsername = this.Context.User.Identity.Name,
Text = messageText,
};
await this.chatService.SaveMessageToChat(message);
await this.Clients.Client(this.Context.ConnectionId).SendAsync(
"MyMessage",
new Models.Message
{
User = message.SenderUsername,
Text = message.Text,
});
await this.Clients.OthersInGroup(chat.ChatGroupName).SendAsync(
"NewMessage",
new Models.Message
{
User = message.SenderUsername,
Text = message.Text,
});
}
public static Data.Message SaveMessage(IDBSession dbs, Data.Message message)
{
using (NHibernate.ITransaction transaction = dbs.Session.BeginTransaction())
{
DB.Message dbMessage = null;
if (message.ID != Guid.Empty)
{
dbMessage = dbs.Session.Get <DB.Message>(message.ID);
}
if (dbMessage == null)
{
dbMessage = new DB.Message(message);
dbMessage.Created = DateTime.UtcNow;
}
else
{
dbMessage.Author = message.Author;
dbMessage.Title = message.Title;
dbMessage.Content = message.Content;
}
dbs.Session.SaveOrUpdate(dbMessage);
transaction.Commit();
message = dbMessage.ToData(false, true);
}
return(message);
}
public override IAnswer HandleDELETE()
{
Guid id = Data.Get.GetGuid("id");
Data.Message message = DB.Controller.DeleteMessage(Server.DBSession, id);
return(new CJE.Http.RequestAnswer.Json(message));
}
public Message(Data.Message source)
{
this.ID = source.ID;
this.Created = source.Created;
this.Author = source.Author;
this.Title = source.Title;
this.Content = source.Content;
}
public override IAnswer HandlePOST()
{
Form.Message inputData = new Form.Message(Data.Post.Input);
Data.Message inputMessage = inputData.ToData();
Data.Message message = DB.Controller.SaveMessage(Server.DBSession, inputMessage);
return(new CJE.Http.RequestAnswer.Json(message));
}
public override void DoWork()
{
try
{
Guid _schedulerInstance = Guid.NewGuid();
ScheduleHistoryItem.AddLogNote("MessagingScheduler DoWork Starting " + _schedulerInstance);
if ((string.IsNullOrEmpty(Host.SMTPServer)))
{
ScheduleHistoryItem.AddLogNote("No SMTP Servers have been configured for this host. Terminating task.");
ScheduleHistoryItem.Succeeded = true;
//'Return
}
else
{
Hashtable settings = ScheduleHistoryItem.GetSettings();
bool _messageLeft = true;
int _messagesSent = 0;
while (_messageLeft)
{
Data.Message currentMessage = _mController.GetNextMessageForDispatch(_schedulerInstance);
if ((currentMessage != null))
{
try
{
SendMessage(currentMessage);
_messagesSent = _messagesSent + 1;
}
catch (Exception e)
{
Errored(ref e);
}
}
else
{
_messageLeft = false;
}
}
ScheduleHistoryItem.AddLogNote(string.Format("Message Scheduler '{0}' sent a total of {1} message(s)", _schedulerInstance, _messagesSent));
ScheduleHistoryItem.Succeeded = true;
}
}
catch (Exception ex)
{
ScheduleHistoryItem.Succeeded = false;
ScheduleHistoryItem.AddLogNote("MessagingScheduler Failed: " + ex);
Errored(ref ex);
}
}
private void SendMessage(Data.Message objMessage)
{
string senderAddress = UserController.GetUserById(objMessage.PortalID, objMessage.FromUserID).Email;
string fromAddress = _pController.GetPortal(objMessage.PortalID).Email;
string toAddress = _uController.GetUser(objMessage.PortalID, objMessage.ToUserID).Email;
Mail.Mail.SendEmail(fromAddress, senderAddress, toAddress, objMessage.Subject, objMessage.Body);
_mController.MarkMessageAsDispatched(objMessage.MessageID);
}
// forwarder system for to RogueGame::AddMessage
public override void AddMessage(Data.Message msg)
{
if (RogueGame.IsPlayer(m_Actor))
{
RogueGame.AddMessage(msg);
}
else
{
DeferMessage(msg);
}
}
public override void AddMessageForceRead(Data.Message msg)
{
if (RogueGame.IsPlayer(m_Actor))
{
RogueGame.ClearMessages();
RogueGame.AddMessage(msg);
RogueGame.Game.AddMessagePressEnter();
}
else
{
DeferMessage(msg);
}
}
public async Task <IActionResult> OnGetAsync(Guid?id)
{
if (id == null)
{
return(NotFound());
}
Message = await _context.Messages.SingleOrDefaultAsync(m => m.Id == id);
if (Message == null)
{
return(NotFound());
}
return(Page());
}
public override IAnswer HandleGET()
{
Guid id = Data.Get.GetGuid("id");
if (id == Guid.Empty)
{
List <Data.Message> messages = DB.Controller.LoadMessageList(Server.DBSession);
return(new CJE.Http.RequestAnswer.Json(messages));
}
else
{
Data.Message message = DB.Controller.LoadMessage(Server.DBSession, id);
return(new CJE.Http.RequestAnswer.Data(message));
}
}
private bool ExecuteValidationRegister(string code)
{
UserBase user;
Data.Message message = Rp3.Security.User.ValidationRegister(code, out user);
this.AddMessage(message);
bool success = message.MessageType == Data.MessageType.Success;
if (success)
{
SessionStart(user.LogonName, this.OrganizationId);
}
return(success);
}
private bool ExecutePasswordRecovery(string code)
{
UserBase user;
Data.Message message = Rp3.Security.User.ResetPassword(code, out user);
this.AddMessage(message);
bool success = message.MessageType == Data.MessageType.Success;
if (success)
{
SessionStart(user.LogonName, this.OrganizationId);
}
return(success);
}
public async Task <IActionResult> OnPostAsync(Guid?id)
{
if (id == null)
{
return(NotFound());
}
Message = await _context.Messages.FindAsync(id);
if (Message != null)
{
_context.Messages.Remove(Message);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
Message = await _context.Messages
.FirstOrDefaultAsync(m => m.Id == id &&
m.Author.UserName == User.Identity.Name);
if (Message != null)
{
_context.Messages.Remove(Message);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public static Data.Message LoadMessage(IDBSession dbs, Guid id)
{
DB.Message dbMessage = dbs.Session.QueryOver <DB.Message>().Fetch(x => x.Comments).Eager.Where(x => x.ID == id).SingleOrDefault <DB.Message>();
Data.Message message = dbMessage?.ToData(true, true);
return(message);
}
public Message()
{
messageData = new Data.Message();
}
public virtual void AddMessage(Data.Message msg)
{
RogueGame.AddMessage(msg);
}
public virtual void AddMessageForceRead(Data.Message msg)
{
RogueForm.Game.AddMessage(msg);
}
public virtual void AddMessageForceReadClear(Data.Message msg)
{
RogueGame.AddMessage(msg);
}
public void DeferMessage(Data.Message x)
{
m_MsgCache.Add(x);
}
