public IActionResult writeComment(Comment newComment)
{
int?userId = HttpContext.Session.GetInt32("UserId");
ViewBag.User = (int)userId;
string Name = HttpContext.Session.GetString("Username");
ViewBag.Name = Name;
if (ModelState.IsValid)
{
dbContext.Add(newComment);
dbContext.SaveChanges();
return(RedirectToAction("wall"));
}
else
{
AllMessages messages = new AllMessages()
{
allMessages = dbContext.Messages.Include(msg => msg.Poster)
.Include(msg => msg.Comments)
.ThenInclude(c => c.User)
.ToList()
};
return(View("Wall"));
}
}
private async Task SendAsync(AllMessages message, CancellationToken cancellationToken = default(CancellationToken))
{
var q = new NetQuantum
{
message = message
};
int maxBytesNeeded = NetQuantum.Serializer.GetMaxSize(q);
byte[] buffer = new byte[maxBytesNeeded];
int bytesWritten = NetQuantum.Serializer.Write(buffer, q);
await WebsocketSendingSemaphore.WaitAsync();
try
{
var start = DateTime.Now;
await Socket.SendAsync(
buffer,
WebSocketMessageType.Binary,
endOfMessage : true,
cancellationToken : cancellationToken);
}
finally
{
WebsocketSendingSemaphore.Release();
}
}
public IDisposable RegisterPeerTableRepository(PeerTableRepository peerTableRepository)
{
var poll = new EventLoopMessageListener <object>(o =>
{
var message = o as IncomingMessage;
if (message != null)
{
if (message.Message.Payload is AddrPayload)
{
peerTableRepository.WritePeers(((AddrPayload)message.Message.Payload).Addresses
.Where(a => a.Endpoint.Address.IsRoutable(AllowLocalPeers))
.Select(a => new Peer(PeerOrigin.Addr, a)));
}
}
var peer = o as Peer;
if (peer != null)
{
if (peer.NetworkAddress.Endpoint.Address.IsRoutable(AllowLocalPeers))
{
peerTableRepository.WritePeer(peer);
}
}
});
if (peerTableRepository != _PeerTable)
{
_InternalMessageProducer.PushMessages(peerTableRepository.GetPeers());
}
return(new CompositeDisposable(AllMessages.AddMessageListener(poll), _InternalMessageProducer.AddMessageListener(poll), OwnResource(poll)));
}
public void Fire(BaseRtmResponse response)
{
AllMessages?.Invoke(this, new RtmMessageEventArgs <BaseRtmResponse>(response));
switch (response)
{
case HelloResponse helloResponse:
HelloMessage?.Invoke(this, new RtmMessageEventArgs <HelloResponse>(helloResponse));
break;
case PongResponse pongResponse:
PongMessage?.Invoke(this, new RtmMessageEventArgs <PongResponse>(pongResponse));
break;
case UserTypingResponse userTypingResponse:
UserTypingMessage?.Invoke(this, new RtmMessageEventArgs <UserTypingResponse>(userTypingResponse));
break;
case BaseMessageResponse messageResponse:
switch (messageResponse)
{
case BotMessageResponse botMessageResponse:
BotMessage?.Invoke(this, new RtmMessageEventArgs <BotMessageResponse>(botMessageResponse));
break;
default:
UserMessage?.Invoke(this, new RtmMessageEventArgs <UserMessageResponse>(messageResponse));
break;
}
break;
default:
throw new NotImplementedException();
}
}
public IActionResult Wall()
{
int?userId = HttpContext.Session.GetInt32("UserId");
if (userId == null)
{
ModelState.AddModelError("myUser.Email", "Login to continue");
return(View("Index"));
}
int id = (int)userId;
ViewBag.User = id;
string Name = HttpContext.Session.GetString("Username");
ViewBag.Name = Name;
AllMessages messages = new AllMessages()
{
allMessages = dbContext.Messages.Include(msg => msg.Poster)
.Include(msg => msg.Comments)
.ThenInclude(c => c.User).OrderByDescending(d => d.CreatedAt)
.ToList()
};
return(View(messages));
}
public Message AddMessage(Message message)
{
// TODO: validate, check that group exists
AllMessages.Push(message);
_messageStream.OnNext(message);
// TODO: also add to DynamoDB
return(message);
}
void ProcessMessage(IncomingMessage message)
{
AllMessages.PushMessage(message);
using (Logs.NodeServer.BeginScope("Processing inbound message {message}", message.Message))
{
ProcessMessageCore(message);
}
}
public void Dispose()
{
Client.Dispose();
Domains.Clear();
AllMessages.Clear();
IsDisposed = true;
}
public static Offset <NetQuantum> CreateNetQuantum(FlatBufferBuilder builder,
AllMessages message_type = AllMessages.NONE,
int messageOffset = 0)
{
builder.StartObject(2);
NetQuantum.AddMessage(builder, messageOffset);
NetQuantum.AddMessageType(builder, message_type);
return(NetQuantum.EndNetQuantum(builder));
}
public void Initialize(Message rootMessage)
{
RootMessage = _messageFactory.MakeMessageViewModel(rootMessage);
RootMessage.LoadSender();
AllMessages.Add(RootMessage);
SelfIsSender = _sessionService.LoggedInUser.Id == rootMessage.SenderId;
}
public void Message(MessageSeverity severity, int code, string message, params object[] args)
{
var msg = new Message(severity, code, Region, message, args);
string s = msg.ToString(); // Ensure this does not throw an exception
AllMessages.Add(msg);
if (_logToConsole)
{
Console.WriteLine(s);
}
}
public void GetMessages()
{
while (true)
{
if (ClientSocket.newMessage != null)
{
AllMessages.Add(ClientSocket.newMessage);
ClientSocket.newMessage = null;
Application.Current.Dispatcher.Invoke(new System.Action(() => UpdateView()));
}
}
}
public async Task <bool> Delete()
{
JToken Json = await Client.GetJson($"https://api4.temp-mail.org/request/delete/id/{Id}/format/json");
if ((string)Json["result"] == "success")
{
AllMessages.Remove(this);
return(true);
}
return(false);
}
void ProcessMessage(IncomingMessage message)
{
AllMessages.PushMessage(message);
TraceCorrelation trace = null;
if (message.Node != null)
{
trace = message.Node.TraceCorrelation;
}
else
{
trace = new TraceCorrelation(NodeServerTrace.Trace, "Processing inbound message " + message.Message);
}
using (trace.Open(false))
{
ProcessMessageCore(message);
}
}
private bool ActionExists()
{
if (!AllMessages.Any())
{
return(false);
}
var topicNames = AllMessages
.Select(x => x.Topic.Substring(x.Topic.LastIndexOf("/", StringComparison.InvariantCulture)))
.Distinct()
.ToList();
if (topicNames.Count > 5)
{
return(false);
}
return(topicNames.All(x => ActionTopicNames.Contains(x)));
}
public void Message(MessageSeverity severity, int code, string message, params object[] args)
{
var msg = new Message(severity, code, Region, message, args);
foreach (var a in args)
{
try {
new BinaryFormatter().Serialize(new MemoryStream(), a);
}
catch (Exception) {
throw new Exception("Error serializing argument " + a);
}
}
string s = msg.ToString(); // Ensure this does not throw an exception
AllMessages.Add(msg);
if (_logToConsole)
{
Console.WriteLine(s);
}
}
async Task GetMessageAsync()
{
while (true)
{
await Task.Delay(500);
string x = await Task.Run(() =>
{
while (true)
{
if (SocketFunctions.RecieveInt(socket) == 0)
{
break;
}
}
return(SocketFunctions.RecieveString(socket));
});
string[] msg = x.Split(new[] { "%&%" }, StringSplitOptions.None);
AllMessages.AppendText(msg[0] + " : " + msg[1] + " " + Environment.NewLine);
}
}
public IDisposable RegisterBlockRepository(BlockRepository repository)
{
var listener = new EventLoopMessageListener <IncomingMessage>((m) =>
{
if (m.Node != null)
{
if (m.Message.Payload is HeadersPayload)
{
foreach (var header in ((HeadersPayload)m.Message.Payload).Headers)
{
repository.WriteBlockHeader(header);
}
}
if (m.Message.Payload is BlockPayload)
{
repository.WriteBlock(((BlockPayload)m.Message.Payload).Object);
}
}
});
return(new CompositeDisposable(AllMessages.AddMessageListener(listener), OwnResource(listener)));
}
private void AddInfo(object sender, string messagetext)
{
AllMessages.AddInfo(messagetext);
}
public static void AddMessageType(FlatBufferBuilder builder, AllMessages messageType)
{
builder.AddByte(0, (byte)messageType, 0);
}
public IEnumerator <IRecordedMessage> GetEnumerator()
{
return(AllMessages.GetEnumerator());
}
public ValidationError[] ToValidationErrors()
{
return(AllMessages.SelectMany(x => x.ToValidationErrors()).ToArray());
}
public void Write(string message, Color color)
{
AllMessages.Add(new Message {
Text = message, Color = color
});
}
public void AddTrace(string format, params object[] args)
{
AllMessages.AddTrace(string.Format(format, args));
}
IEnumerator IEnumerable.GetEnumerator()
{
// Enumerate the current state of the messages
return(AllMessages.GetEnumerator());
}
private void AddError(object sender, string messagetext)
{
AllMessages.AddError(messagetext);
}
public void AddMessage(Message message)
{
AllMessages.Add(_messageFactory.MakeMessageViewModel(message));
}
private void AddDebug(object sender, string messagetext)
{
AllMessages.AddDebug(messagetext);
}
private IEnumerable <string> GetFilteredMessages(MessageLevelType type)
{
return(AllMessages.Where(x => x.Level == type).Select(x => x.Text));
}
private void AddTrace(object sender, string messagetext)
{
AllMessages.AddTrace(messagetext);
}
