public static void SendPublic(string msg)
{
PublicMessage pmsg = new PublicMessage(Nickname, msg);
string str = JsonConvert.SerializeObject(pmsg).ToString();
Common.doSend(clientSocket, str);
}
static void Main(string[] args)
{
PublicMessage mypubMsg = new PublicMessage();
mypubMsg.myPublicMessage();
mypubMsg.mySecretMessage();
}
public PublicMessage Add(PublicMessage message)
{
this.publicMessages.Add(message);
this.publicMessages.Save();
return(message);
}
public PublicMessage Add(PublicMessage message)
{
this.publicMessages.Add(message);
this.publicMessages.Save();
return message;
}
public void PublicMessageEquality()
{
var pm1 = new PublicMessage("bork");
var pm2 = new PublicMessage("bork");
Assert.IsTrue(pm1.Equals(pm2));
}
void HandlePublicMessage(PublicMessage m)
{
var channel = Channels.SingleOrDefault(ch => ch.Id == m.Channel);
if (channel == null || channel.Id == "#noPrivacy")
{
return;
}
if (Users.SingleOrDefault(u => u.Name == m.Sender) == null)
{
Users.Add(new User {
Name = m.Sender
});
}
if (m.Sender != Nickname)
{
channel?.Messages.Add(m);
}
else
{
channel?.Messages.Add(new MyMessage(m));
}
}
public Task <AuthenticationServiceResponse> AddPublicMessage(PublicMessageModel publicMessageModel)
{
try
{
int userid = GetLoginUserId();
PublicMessage publicMessage = new PublicMessage();
Mapper.Map(publicMessageModel, publicMessage);
publicMessage.CreatedBy = userid;
publicMessage.CreatedDate = DateTime.UtcNow;
publicMessage.UpdatedBy = userid;
publicMessage.UpdatedDate = DateTime.UtcNow;
publicMessage.IsDeleted = false;
_conversationService.publicMessageRepository.Insert(publicMessage);
_conversationService.Save();
publicMessage = _conversationService.publicMessageRepository.Get(x => x.MessageId == publicMessage.MessageId).FirstOrDefault();
Mapper.Map(publicMessage, publicMessageModel);
var User = (new AuthenticationService()).GetUserById(userid);
Mapper.Map(User, publicMessageModel.UserModel);
return(Task.FromResult(new AuthenticationServiceResponse {
Data = publicMessageModel, Success = true
}));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IActionResult> UpdatePublicMessage(long id, PublicMessage publicMessage)
{
if (publicMessage == null)
{
throw new ArgumentNullException("Public Message", "Public Message cannot be null");
}
if (id != publicMessage.MessageId)
{
return(BadRequest());
}
_context.Entry(publicMessage).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PublicMessageExists(id))
{
//throw new ArgumentNullException("Public Message", String.Format("Public Message with id {0} does not exist.", id));
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
/// <summary>
/// Method used by controller to convert public message to data transfer object
/// </summary>
/// <param name="publicMessage"></param>
/// <returns>PublicMessageDTO object</returns>
private static PublicMessageDTO PublicMessageToDTOForGetAll(PublicMessage publicMessage) =>
new PublicMessageDTO
{
Title = publicMessage.Title,
MessageContent = publicMessage.MessageContent,
ValidUntil = publicMessage.ValidUntil,
AddressedTo = publicMessage.AddressedTo,
MessageId = publicMessage.MessageId
};
static void Main(string[] args)
{
PublicMessage myPubMsg = new PublicMessage();
myPubMsg.myPublicMessage();
myPubMsg.myName();
myPubMsg.myPainter();
myPubMsg.myMedium();
myPubMsg.myYear();
}
public virtual void OnNext(StreamingMessage streamingMessage)
{
if (streamingMessage.Type == MessageType.Create)
{
var dynamicStreamingMessage = (dynamic)streamingMessage;
var tweet = (Status)dynamicStreamingMessage.Status;
var message = new PublicMessage($"twitter.com/OmniDestiny just tweeted: {Tools.TweetPrettier(tweet)}");
_processor.Sender.Post(message);
}
}
public async Task <CreatePublicMessageCommandResponse> Handle(CreatePublicMessageCommand command)
{
var publicMessage = new PublicMessage(Guid.NewGuid(), command.Title, command.Body, new UserInfo(command.UserInfo.UserId, command.UserInfo.FirstName, command.UserInfo.LastName), command.MessageType);
_repository.Add(publicMessage);
await _fcmNotification.SendToTopic(command.Title, command.Body, NotificationType.PublicMessage,
command.MessageType == PublicMessageType.ShopMessage?AppType.Shop : AppType.Customer, NotificationSound.Default);
return(new CreatePublicMessageCommandResponse());
}
public static ChatMessageViewModel ForPublic(PublicMessage message)
{
return(new ChatMessageViewModel
{
ConversationId = "Public",
SenderId = message.SenderId,
Sended = message.When,
Received = message.When,
Content = message.Text
});
}
/// <summary>
/// Method used by controller to convert public message to data transfer object
/// </summary>
/// <param name="publicMessage"></param>
/// <returns>PublicMessageDTO object</returns>
private static PublicMessageDTO PublicMessageToDTO(PublicMessage publicMessage) =>
new PublicMessageDTO
{
Title = publicMessage.Title,
MessageContent = publicMessage.MessageContent,
ValidUntil = publicMessage.ValidUntil,
AddressedTo = publicMessage.AddressedTo,
ClientName = publicMessage.Client.FullName,
ClientEmailId = publicMessage.Client.EmailId,
MessageId = publicMessage.MessageId
};
public void Append(PublicMessage msg, Channel channel, bool function)
{
bool ub = msg.Sender == ">" || msg.Sender == ">>" || msg.Sender == ":";
string row = KCode2HTML.ToHTML(msg.Message, channel, function, ub);
string nick = KCode2HTML.ToHTML("_°>_h" + msg.Sender + "|/m \"|/w \"<°:_ ", channel, false, false);
if (ub)
{
nick = string.Empty;
}
row = nick + row;
AppendHTML(row);
}
public override void Visit(PublicMessage publicMessage)
{
LatestPublicMessage = publicMessage;
if (_previousSend == publicMessage.OriginalText)
{
if (publicMessage.OriginalText.EndsWith("."))
{
publicMessage.OriginalText = publicMessage.OriginalText.TrimEnd('.');
}
else
{
publicMessage.OriginalText = $"{publicMessage.OriginalText}.";
}
}
var obj = new MessageSender(publicMessage.OriginalText);
_websocket.Send($"MSG {JsonConvert.SerializeObject(obj)}");
_previousSend = publicMessage.OriginalText;
}
private static void doPublicMessage(PublicMessage msg)
{
string str = JsonConvert.SerializeObject(msg).ToString();
foreach (DictionaryEntry de in userList)
{
if (de.Key.Equals(msg.FromNick))
{
continue;
}
try
{
Common.doSend(((ClientInfo)de.Value).Client, str);
}
catch (SocketException)
{
//ignore
}
}
}
public SendImageResponse SendImage(ISession session, SendImageRequest request)
{
var response = request.CreateResponse <SendImageResponse>();
response.ImageId = -1;
if (session.User.IsDevoiced)
{
session.Send(new YouAreDevoicedNotification());
return(response);
}
PublicMessage message = null;
using (var uow = UnitOfWorkFactory.Create())
{
int fileId;
try
{
fileId = _fileStorage.AppendFile(request.Image);
response.ImageId = fileId;
}
catch (System.Exception)
{
//Invalid image
return(response);
}
uow.Attach(session.User);
message = new PublicMessage(session.User, fileId, "Your client doesn't support IMAGE messages");
uow.PublicMessageRepository.Add(message);
uow.Commit();
}
var dto = message.ProjectedAs <PublicMessageDto>();
dto.Role = (UserRoleEnum)(int)session.User.Role;
_sessionManager.SendToEachChatSessions(dto);
return(response);
}
/// <summary>
/// NOTE: we don't need an app-level ack for this method :-)
/// </summary>
public void PublicMessage(ISession session, PublicMessageRequest msgRequest)
{
if (session.User.IsDevoiced)
{
session.Send(new YouAreDevoicedNotification());
return;
}
PublicMessage message = null;
using (var uow = UnitOfWorkFactory.Create())
{
uow.Attach(session.User);
message = new PublicMessage(session.User, msgRequest.Body);
uow.PublicMessageRepository.Add(message);
uow.Commit();
}
var dto = message.ProjectedAs <PublicMessageDto>();
dto.Role = (UserRoleEnum)(int)session.User.Role;
_sessionManager.SendToEachChatSessions(dto);
}
public async Task <ActionResult <PublicMessage> > CreateNewPublicMessage(PublicMessageDTO publicMessageDTO)
{
Stopwatch sw = new Stopwatch();
sw.Start();
try
{
if (publicMessageDTO == null)
{
//throw new ArgumentNullException("Public Message", "Public Message cannot be null");
return(BadRequest());
}
PublicMessage publicMessage = PublicMessageDTOToPublicMessage(publicMessageDTO);
_context.PublicMessages.Append(publicMessage);
_context.Clients.Append(publicMessage.Client);
await _context.SaveChangesAsync();
//return CreatedAtAction("GetPublicMessage", new { id = publicMessage.MessageId }, publicMessage);
return(CreatedAtAction(nameof(GetPublicMessage), new { id = publicMessage.MessageId }, PublicMessageToDTO(publicMessage)));
}
catch (ArgumentNullException ex)
{
_log.PublicMessageSingleLogError(ex.Message + " Stack trace: " + ex.StackTrace);
return(StatusCode(404, new MessageError(ex.Message, ex.StackTrace)));
}
catch (Exception ex)
{
_log.PublicMessageSingleLogError(ex.Message + " Stack trace: " + ex.StackTrace);
return(StatusCode(500, new MessageError(ex.Message, ex.StackTrace)));
}
finally
{
sw.Stop();
_log.PublicMessageSingleLogError($"PublicMessage Controller. Elapsed : { sw.Elapsed.TotalMilliseconds}");
}
}
public void Process(PublicMessage message)
{
message.Ordinal = _contextIndex;
_contextDictionary.TryAdd(_contextIndex, message);
_contextIndex++;
Message removed;
while (_dequeueDictionary.Count > Settings.MessageLogSize && _dequeueDictionary.TryRemove(_dequeueIndex, out removed))
{
var contextTest = _contextDictionary.TryRemove(_dequeueIndex, out removed);
Debug.Assert(contextTest);
#if DEBUG
Console.Write("d {0}.", _dequeueIndex);
#endif
_dequeueIndex++;
}
_logger.Post(message);
if (message.IsMod)
{
if (message.SanitizedText[0] == '!')
{
_commander.Post(message);
_modCommander.Post(message);
}
else
{
DoneWithContext(message);
}
}
else
{
Banner.Post(message);
}
}
private static void OnClientSentPublicMessage(object sender, PublicMessage message)
{
}
public string[] UpdateMasterPublicNews_MasterPublicNewsPage(string state, string SelectedMasterPublicNewsID, string MasterPublicNewsActive, string MasterPublicSubject, string MasterPublicNewsMessage, string MasterPublicNewsOrder)
{
this.InitializeCulture();
string[] retMessage = new string[4];
try
{
AttackDefender.CSRFDefender(this.Page);
decimal MasterPublicNewsID = 0;
int masterPublicNewsOrder = 0;
decimal selectedMasterPublicNewsID = decimal.Parse(this.StringBuilder.CreateString(SelectedMasterPublicNewsID), CultureInfo.InvariantCulture);
MasterPublicNewsActive = this.StringBuilder.CreateString(MasterPublicNewsActive);
MasterPublicSubject = this.StringBuilder.CreateString(MasterPublicSubject);
MasterPublicNewsMessage = this.StringBuilder.CreateString(MasterPublicNewsMessage);
if (!string.IsNullOrEmpty(MasterPublicNewsOrder))
{
masterPublicNewsOrder = int.Parse(this.StringBuilder.CreateString(MasterPublicNewsOrder));
}
UIActionType uam = (UIActionType)Enum.Parse(typeof(UIActionType), this.StringBuilder.CreateString(state).ToUpper());
PublicMessage publicMessage = new PublicMessage();
publicMessage.ID = selectedMasterPublicNewsID;
if (uam != UIActionType.DELETE)
{
publicMessage.Active = Convert.ToBoolean(MasterPublicNewsActive);
publicMessage.Subject = MasterPublicSubject;
publicMessage.Message = MasterPublicNewsMessage;
publicMessage.Date = DateTime.Now;
publicMessage.Order = masterPublicNewsOrder;
}
switch (uam)
{
case UIActionType.ADD:
MasterPublicNewsID = this.PublicMessageBusiness.InsertPublicNews(publicMessage, uam);
break;
case UIActionType.EDIT:
if (selectedMasterPublicNewsID == 0)
{
retMessage = this.exceptionHandler.HandleException(this.Page, ExceptionTypes.UIValidationExceptions, new Exception(GetLocalResourceObject("NoMasterPublicNewsSelectedforEdit").ToString()), retMessage);
return(retMessage);
}
MasterPublicNewsID = this.PublicMessageBusiness.UpdatePublicNews(publicMessage, uam);
break;
case UIActionType.DELETE:
if (selectedMasterPublicNewsID == 0)
{
retMessage = this.exceptionHandler.HandleException(this.Page, ExceptionTypes.UIValidationExceptions, new Exception(GetLocalResourceObject("NoMasterPublicNewsSelectedforDelete").ToString()), retMessage);
return(retMessage);
}
MasterPublicNewsID = this.PublicMessageBusiness.DeletePublicNews(publicMessage, uam);
break;
}
retMessage[0] = GetLocalResourceObject("RetSuccessType").ToString();
string SuccessMessageBody = string.Empty;
switch (uam)
{
case UIActionType.ADD:
SuccessMessageBody = GetLocalResourceObject("AddComplete").ToString();
break;
case UIActionType.EDIT:
SuccessMessageBody = GetLocalResourceObject("EditComplete").ToString();
break;
case UIActionType.DELETE:
SuccessMessageBody = GetLocalResourceObject("DeleteComplete").ToString();
break;
default:
break;
}
retMessage[1] = SuccessMessageBody;
retMessage[2] = "success";
retMessage[3] = MasterPublicNewsID.ToString();
return(retMessage);
}
catch (UIValidationExceptions ex)
{
retMessage = this.exceptionHandler.HandleException(this.Page, ExceptionTypes.UIValidationExceptions, ex, retMessage);
return(retMessage);
}
catch (UIBaseException ex)
{
retMessage = this.exceptionHandler.HandleException(this.Page, ExceptionTypes.UIBaseException, ex, retMessage);
return(retMessage);
}
catch (Exception ex)
{
retMessage = this.exceptionHandler.HandleException(this.Page, ExceptionTypes.Exception, ex, retMessage);
return(retMessage);
}
}
public override void Forward(PublicMessage message)
{
_processor.Process(message);
}
public void Add(PublicMessage msg)
{
_uow.PublicMessages.Add(msg);
}
public void Forward(PublicMessage message)
{
_processor.Process(message);
}
public void Visit(PublicMessage publicMessage)
{
Print(publicMessage);
}
public async Task SendMessage(PublicMessage message)
{
var from = message.Props["FromUser"] as string;
var to = message.Props["ToUser"] as string;
await hubContext.Clients.All.SendAsync(to, message);
}
public void Send(PublicMessage publicMessage)
{
LatestPublicMessage = publicMessage;
Logger.Write($"Messaged {publicMessage.OriginalText}");
}
public void AddLineToHistory(PublicMessage msg, bool function)
{
_htmlChatHistory.Append(msg, _channels[_activeChannel], function);
}
public override void Visit(PublicMessage publicMessage)
{
SendMsg(publicMessage.OriginalText);
}
private static void Worker(object clientObj)
{
ClientInfo client = (ClientInfo)clientObj;
bool online = false;
while (client.Nickname == null || client.Nickname.Length == 0)
{
try
{
string str = Common.doReceive(client.Client);
LoginMessage msg = JsonConvert.DeserializeObject <LoginMessage>(str);
if (!msg.MsgType.Equals("login") || msg.Nickname == null || msg.Nickname.Length == 0 || msg.Nickname.ToLower().Equals("system") || userList.ContainsKey(msg.Nickname))
{
throw new ChatException("no nickname");
}
client.Nickname = msg.Nickname;
userList.Add(client.Nickname, client);
PublicMessage emsg = new PublicMessage("System", "Welcome " + msg.Nickname);
doPublicMessage(emsg);
AnnounceOnline(client.Nickname);
online = true;
}
catch (SocketException)
{
online = false;
}
catch (ChatException e)
{
doErrorMessage(client, e.Message);
}
}
while (online && client.Client.Connected)
{
try
{
string t = Common.doReceive(client.Client);
if (t.Length == 0)
{
AnnounceOffline(client.Nickname);
userList.Remove(client.Nickname);
online = false;
break;
}
JObject json = (JObject)JsonConvert.DeserializeObject(t);
switch ((string)json.GetValue("MsgType"))
{
case "public": doPublicMessage(JsonConvert.DeserializeObject <PublicMessage>(t)); break;
case "private": doPrivateMessage(JsonConvert.DeserializeObject <PrivateMessage>(t)); break;
default: throw new ChatException("no such kind of message");
}
}
catch (SocketException)
{
AnnounceOffline(client.Nickname);
userList.Remove(client.Nickname);
online = false;
}
catch (ChatException e)
{
doErrorMessage(client, e.Message);
}
}
}
