/// <summary>
/// Upload Existing File to SFTP
/// </summary>
/// <param name="fileName">Local file Path to upload</param>
public void UploadExistingFile(string fileName)
{
EventLogMessage.WriteLogDebug("ConnectorSFTP: UploadExistingFile method");
System.IO.FileStream fileStream = File.Open(fileName, FileMode.Open);
client.UploadFile(fileStream, fileName);
fileStream.Close();
}
protected virtual void OnLogMessage(string condition, string stackTrace, LogType type)
{
STLogMessage msg = GetLogMessage(condition, stackTrace, type);
EventLogMessage?.Invoke(msg);
switch (type)
{
case LogType.Log:
EventLogNormal?.Invoke(msg);
break;
case LogType.Warning:
EventLogWarning?.Invoke(msg);
break;
case LogType.Error:
case LogType.Assert:
case LogType.Exception:
EventLogError?.Invoke(msg);
break;
default:
break;
}
}
private void button1_Click(object sender, EventArgs e)
{
ListViewItem itemview = listView1.SelectedItems[0];
ControllerInfo controllerinfo = (ControllerInfo)itemview.Tag;
Controller aController = ControllerFactory.CreateFrom(controllerinfo);
aController.Logon(UserInfo.DefaultUser);
EventLog log = aController.EventLog; //
EventLogCategory cat;
cat = log.GetCategory(0);
for (int i = 0; i < 50; i++)
{
try
{
EventLogMessage emsg = cat.Messages[i];
dataGridView2.Rows.Add(emsg.Title, emsg.Timestamp);
}
catch (IndexOutOfRangeException)
{
MessageBox.Show("EventLog okuması tamamlandı.");
break;
}
}
}
private void UpdateLog(EventLogMessage lastAdded)
{
List <string> entries = _logger.GetLastItemMessages(_lastMessagesToDisplay);
string entryMessage = string.Join("", entries);
SetLogText(entryMessage);
}
private void onEventLogMessage(EventLogMessage obj)
{
// IP of the AuditFailure log should be stored on offset 19
if (obj.ReplacementStrings.Length < 20)
{
return;
}
var ip = obj.ReplacementStrings[19];
if (!IPAddress.TryParse(ip, out var ipAddress))
{
return;
}
var eventArg = new RDPEventArgs(ip);
OnAuditFailure?.Invoke(this, new RDPEventArgs(ip));
if (!eventArg.IsCancel)
{
// add the IP to our limit counter
_auditFailureCounter.Count(ip);
}
}
public UpdateChannelEventArgs(string channelName, bool connected, EventLogMessage eventLog, bool isNewLogin = false)
{
ChannelName = channelName;
Connected = connected;
IsNewLogin = isNewLogin;
Type = ChannelType.Private;
EventLog = eventLog;
}
internal void HandleMessage(Guid clientId, Container container)
{
if (!_connections.TryGetValue(clientId, out WsConnection connection))
{
return;
}
_connections.RefreshLifeClient(clientId);
switch (container.Identifier)
{
case DispatchType.Login:
if (((JObject)container.Payload).ToObject(typeof(LoginRequestContainer)) is LoginRequestContainer loginRequest)
{
LoginResponseContainer loginResponse;
bool isEnter = true;
DispatchType stage;
if (UserOnlineList.Contains(loginRequest.Content))
{
loginResponse = new LoginResponseContainer(
new Response(ResponseType.Failure, $"Client with name '{loginRequest.Content}' yet connect."),
null,
null,
null,
null);
connection.Send(loginResponse.GetContainer());
connection.Login = $"pseudo-{loginRequest.Content}";
stage = DispatchType.Connection;
}
else
{
isEnter = UserOfflineList.Contains(loginRequest.Content);
loginResponse = new LoginResponseContainer(new Response(ResponseType.Ok, "Connected"), null, null, null, null);
connection.Login = loginRequest.Content;
stage = DispatchType.Login;
}
var eventLogMessage = new EventLogMessage
{
IsSuccessfully = loginResponse.Content.Result == ResponseType.Ok == isEnter,
SenderName = _name,
Text = loginResponse.Content.Reason,
Time = DateTime.Now,
Type = stage
};
ConnectionStateChanged?.Invoke(this, new ConnectionStateChangedEventArgs(connection.Login, true, eventLogMessage));
}
break;
case DispatchType.Message:
MessageReceivedEventArgs message = MessageSorter.GetSortedMessage((JObject)container.Payload);
MessageReceived?.Invoke(this, message);
Send(MessageSorter.GetSortedMessage(message.Author, message.Message, InterfaceType.WebSocket, message.Agenda), message.Agenda);
break;
}
}
private void OnMessage(object sender, MessageEventArgs eventArgs)
{
if (!eventArgs.IsText)
{
return;
}
var container = JsonConvert.DeserializeObject <Container>(eventArgs.Data);
switch (container.Identifier)
{
case DispatchType.Login:
if (((JObject)container.Payload).ToObject(typeof(LoginResponseContainer)) is LoginResponseContainer loginResponse)
{
var eventLog = new EventLogMessage()
{
IsSuccessfully = true,
SenderName = _login,
Text = "Login",
Time = DateTime.Now,
Type = DispatchType.Login
};
if (loginResponse.Content.Result == ResponseType.Failure)
{
eventLog.IsSuccessfully = false;
eventLog.Text = loginResponse.Content.Reason;
}
LoginEvent?.Invoke(
this,
new LoginEventArgs(
_login,
eventLog.IsSuccessfully,
eventLog,
loginResponse.General,
loginResponse.OnlineList,
loginResponse.OfflineList,
loginResponse.EventLogMessageList));
}
break;
case DispatchType.Message:
MessageReceived?.Invoke(this, MessageSorter.GetSortedMessage((JObject)container.Payload));
break;
case DispatchType.Channel:
UpdateChannel?.Invoke(this, MessageSorter.GetSortedChannel((JObject)container.Payload));
break;
case DispatchType.EventLog:
LogEvent?.Invoke(this, MessageSorter.GetSortedEventMessage((JObject)container.Payload));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Log a message to the Event Log window.
/// </summary>
/// <param name="type">Type of the log entry (what occurred).</param>
/// <param name="eventName">Name of the event.</param>
/// <param name="gameObject">GameObject sending the event.</param>
/// <param name="value">Value passed.</param>
/// <param name="message">Optional message.</param>
public static void Log(LogType type, string eventName, string caller, string value, string message, GameObject gameObject)
{
#if UNITY_EDITOR
EventLogMessage msg = new EventLogMessage(Time.realtimeSinceStartup, type, eventName, caller, value, message, gameObject);
Messages.Add(msg);
#else
Debug.Log($"{Time.realtimeSinceStartup:0.000} - Type: {type}, Event: {eventName}, Caller: {caller}, Value: {value}, Message: {message}, GameObject: {gameObject.name}");
#endif
}
/// <summary>
/// Get List of Source Folder Files
/// </summary>
public List <string> GetSourceFolderFiles()
{
EventLogMessage.WriteLogDebug("ConnectorFilesystem: GetSourceFolderFiles method");
// Read connection configuration
_connectData = ConfigData.ReadConfigFileSystem();
string folderPath = (_connectData.SourceFolder.Last() == "\\"[0]) ? _connectData.SourceFolder : _connectData.SourceFolder + "\\";
EventLogMessage.WriteLogDebug("ConnectorFilesystem: GetSourceFolderFiles method, Source Folder Path: " + folderPath);
return(new List <string>(Directory.EnumerateFiles(folderPath)));
}
private void DrawMessage(EventLogMessage message)
{
if (hideSubUnsub && (message.Type == LogType.Subscribed || message.Type == LogType.UnSubscribed))
{
return;
}
Rect pos = GUILayoutUtility.GetRect(40f, 40f, 16f, 16f, foldoutStyle);
string headerText;
switch (message.Type)
{
case LogType.Subscribed:
case LogType.UnSubscribed:
headerText = $"{message.TimeStamp:0.000} - Type: <b>{message.Type}</b>, GameObject: <b>{message.Caller}</b>, Listener type: <b>{message.EventName}</b>";
break;
case LogType.Broadcast:
case LogType.Received:
headerText = $"{message.TimeStamp:0.000} - Type: <b>{message.Type}</b>, GameObject: <b>{message.Caller}</b>, Event: <b>{message.EventName}</b>, Value: <b>{message.Value}</b>";
break;
case LogType.Information:
case LogType.Warning:
case LogType.Error:
case LogType.Exception:
headerText = $"{message.TimeStamp:0.000} - Type: <b>{message.Type}</b>, GameObject: <b>{message.Caller}</b>, Event: <b>{message.EventName}</b>, Message: <b>{message.Message}</b>";
break;
default:
headerText = $"Unknown message type: {message.Type}";
break;
}
message.IsUnfolded = EditorGUI.Foldout(pos, message.IsUnfolded, new GUIContent(headerText), true, foldoutStyle);
if (message.IsUnfolded)
{
EditorGUILayout.LabelField($" {message.Message}", normalStyle);
EditorGUILayout.BeginHorizontal( );
GUILayout.Space(30);
if (message.GameObject != null)
{
if (GUILayout.Button("Ping GameObject", GUILayout.Width(150)))
{
EditorGUIUtility.PingObject(message.GameObject);
}
}
EditorGUILayout.EndHorizontal( );
}
}
private void Close()
{
var eventLog = new EventLogMessage()
{
IsSuccessfully = true,
SenderName = _login,
Text = "",
Time = DateTime.Now,
Type = DispatchType.Connection
};
ConnectionStateChanged?.Invoke(this, new ConnectionStateChangedEventArgs(_login, false, eventLog));
}
private void ReceiveCompleted(object sender, SocketAsyncEventArgs eventArgs)
{
if (eventArgs.BytesTransferred == 0 || eventArgs.SocketError != SocketError.Success)
{
Disconnect();
var eventLogMessage = new EventLogMessage
{
IsSuccessfully = false,
SenderName = _login,
Text = "Receive don't completed",
Time = DateTime.Now,
Type = DispatchType.Message
};
ConnectionStateChanged?.Invoke(this, new ConnectionStateChangedEventArgs(_login, false, eventLogMessage));
return;
}
int available = eventArgs.Offset + eventArgs.BytesTransferred;
for (;;)
{
if (available < SIZE_LENGTH)
{
break;
}
int offset = 0;
ushort length = BufferPrimitives.GetUint16(eventArgs.Buffer, ref offset);
if (length + SIZE_LENGTH > available)
{
break;
}
HandlePacket(BufferPrimitives.GetBytes(eventArgs.Buffer, ref offset, length));
available = available - length - SIZE_LENGTH;
if (available > 0)
{
Array.Copy(eventArgs.Buffer, length + SIZE_LENGTH, eventArgs.Buffer, 0, available);
}
}
if (!_socket.Connected)
{
return;
}
eventArgs.SetBuffer(available, BUFFER_SIZE - available);
Receive();
}
private void OnOpen(object sender, EventArgs e)
{
var eventLog = new EventLogMessage()
{
IsSuccessfully = true,
SenderName = _login,
Text = "Open",
Time = DateTime.Now,
Type = DispatchType.Connection
};
ConnectionStateChanged?.Invoke(this, new ConnectionStateChangedEventArgs(_login, true, eventLog));
Login();
}
/// <summary>
/// Delete All Source Folder Files
/// </summary>
public void DeleteSourceFolderFiles()
{
EventLogMessage.WriteLogDebug("ConnectorFilesystem: DeleteSourceFolderFiles method");
// Read connection configuration
_connectData = ConfigData.ReadConfigFileSystem();
string folderPath = (_connectData.SourceFolder.Last() == "\\"[0]) ? _connectData.SourceFolder : _connectData.SourceFolder + "\\";
EventLogMessage.WriteLogDebug("ConnectorFilesystem: DeleteSourceFolderFiles method, Source Folder Path: " + folderPath);
foreach (string sourceFile in Directory.EnumerateFiles(folderPath))
{
EventLogMessage.WriteLog("Delete Source Folder File: " + sourceFile);
File.Delete(sourceFile);
}
}
private async Task OnLog(EventLogMessage message, CancellationToken cancellationToken)
{
var tasks = new List <Task>();
lock (_eventLogEvent)
{
tasks.AddRange(_eventLogEvent.Select(func =>
{
return(Task.Run(async() => await func(message), cancellationToken));
}));
}
await Task.WhenAll(tasks);
}
public static void AutomaticAlert(string login, ICurrentConnection connection)
{
const string ALERT = "Alert";
var eventLogMessage = new EventLogMessage
{
IsSuccessfully = true,
SenderName = login,
Text = ALERT,
Time = DateTime.Now,
Type = DispatchType.EventLog
};
connection.Send(new MessageEventLogContainer(eventLogMessage));
}
private void HandlePacket(byte[] packet)
{
string serializedMessages = GetStringPacket(packet);
var container = JsonConvert.DeserializeObject <Container>(serializedMessages);
switch (container.Identifier)
{
case DispatchType.Login:
if (((JObject)container.Payload).ToObject(typeof(LoginResponseContainer)) is LoginResponseContainer loginResponse)
{
var eventLog = new EventLogMessage
{
IsSuccessfully = loginResponse.Content.Result == ResponseType.Ok,
SenderName = _login,
Text = loginResponse.Content.Reason,
Time = DateTime.Now,
Type = DispatchType.Login
};
_isLogin = eventLog.IsSuccessfully;
LoginEvent?.Invoke(
this,
new LoginEventArgs(
_login,
eventLog.IsSuccessfully,
eventLog,
loginResponse.General,
loginResponse.OnlineList,
loginResponse.OfflineList,
loginResponse.EventLogMessageList));
}
break;
case DispatchType.Message:
MessageReceived?.Invoke(this, MessageSorter.GetSortedMessage((JObject)container.Payload));
break;
case DispatchType.Channel:
UpdateChannel?.Invoke(this, MessageSorter.GetSortedChannel((JObject)container.Payload));
break;
case DispatchType.EventLog:
LogEvent?.Invoke(this, MessageSorter.GetSortedEventMessage((JObject)container.Payload));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public LoginEventArgs(
string clientName,
bool connected,
EventLogMessage eventLog,
GeneralChannel general,
List <PrivateChannel> onlineList,
List <PrivateChannel> offlineList,
List <EventLogMessage> eventLogMessages)
: base(clientName, connected, eventLog)
{
General = general;
OnlineList = onlineList;
OfflineList = offlineList;
EventLogMessages = eventLogMessages;
}
internal void FreeConnection(IPEndPoint remoteEndpoint)
{
if (_connections.TryRemove(remoteEndpoint, out TcpConnection connection) && !string.IsNullOrEmpty(connection.Login))
{
var eventLogMessage = new EventLogMessage
{
IsSuccessfully = true,
SenderName = connection.Login,
Text = "Disconnect completed",
Time = DateTime.Now,
Type = DispatchType.EventLog
};
ConnectionStateChanged?.Invoke(this, new ConnectionStateChangedEventArgs(connection.Login, false, eventLogMessage));
}
}
private void LogEntry_OnMessage(object sender, EventLogMessage e)
{
string Indendation = "";
for (int i = 1; i < e.Entries.Count; i++)
{
Indendation += '\t';
}
LogEntry newLog = e.Entries[0];
//string line = log.Created.ToString("yyyy-MM-dd HH:mm:ss") + Indendation + log.ToString();
Console.WriteLine(Indendation + newLog.Message);
}
private void LogEntry_OnMessage(object sender, EventLogMessage e)
{
string indendation = "";
foreach (LogEntry logEntry in e.Entries)
{
indendation += '\t';
}
LogEntry newLog = e.Entries[0];
string line = Log.Created.ToString("yyyy-M-d H:mm:ss") + indendation + newLog.Message;
_textStreamWriter.WriteLine(line);
_textStreamWriter.Flush();
}
private void HandleMessageReceived(object sender, MessageReceivedEventArgs eventArgs)
{
string messageServer = $"{eventArgs.Agenda.Type}:{eventArgs.Author}:{eventArgs.Message}";
var eventLogMessage = new EventLogMessage
{
IsSuccessfully = true,
SenderName = eventArgs.Author,
Text = messageServer,
Time = DateTime.Now,
Type = DispatchType.Message
};
switch (eventArgs.Agenda.Type)
{
case ChannelType.General:
SendCurrentServer(eventArgs.Type, MessageSorter.GetSortedMessage(eventArgs), eventArgs.Agenda);
User user = _dataBaseManager.UserList.Find(u => u.Name == eventArgs.Author);
var generalMessage = new GeneralMessage
{
Message = eventArgs.Message,
Time = eventArgs.Time,
User_Id = user.Id
};
_dataBaseManager.CreateGeneralMessageAsync(generalMessage);
break;
case ChannelType.Private:
SendCurrentServer(eventArgs.Type, MessageSorter.GetSortedMessage(eventArgs), eventArgs.Agenda);
var privateMessage = new PrivateMessage
{
Message = eventArgs.Message,
Time = eventArgs.Time,
SenderId = _dataBaseManager.UserList.Find(u => u.Name == eventArgs.Author).Id,
TargetId = _dataBaseManager.UserList.Find(u => u.Name == ((PrivateAgenda)eventArgs.Agenda).Target).Id
};
_dataBaseManager.CreatePrivateMessageAsync(privateMessage);
break;
case ChannelType.Group:
break;
default:
throw new ArgumentOutOfRangeException();
}
EventSaveAsync(new MessageEventLogContainer(eventLogMessage), eventArgs.Agenda);
}
private void CheckConnect()
{
Thread.Sleep(CONNECT_WAIT_TIME);
if (!IsConnected)
{
var eventLog = new EventLogMessage()
{
IsSuccessfully = false,
SenderName = _login,
Text = "No connection",
Time = DateTime.Now,
Type = DispatchType.Connection
};
ConnectionStateChanged?.Invoke(this, new ConnectionStateChangedEventArgs(_login, false, eventLog));
_socket?.CloseAsync();
}
}
private void HandleConnectionStateChanged(object sender, ConnectionStateChangedEventArgs eventArgs)
{
string client = eventArgs.ClientName;
bool isRegistration = false;
if (eventArgs.EventLog.Type == DispatchType.Login && !eventArgs.EventLog.IsSuccessfully)
{
eventArgs.EventLog.IsSuccessfully = true;
isRegistration = true;
_dataBaseManager.CreateUserAsync(
new User
{
Name = eventArgs.ClientName
});
AddNewUserOnList(client);
}
if (eventArgs.EventLog.Type == DispatchType.Login && eventArgs.EventLog.IsSuccessfully)
{
SendLoginInitAsync(eventArgs);
}
if (eventArgs.EventLog.IsSuccessfully && Contains(client))
{
var crc = new ChannelResponseContainer(new UpdateChannel(eventArgs.Connected, client, isRegistration), client);
_wsServer.Send(crc, new GeneralAgenda());
_tcpServer.Send(crc, new GeneralAgenda());
}
string clientState = eventArgs.Connected ? "connect" : "disconnect";
string message = $"Client '{client}' {clientState}.";
AddUserOnList(eventArgs.Connected, client);
var eventLogMessage = new EventLogMessage
{
IsSuccessfully = eventArgs.EventLog.IsSuccessfully,
SenderName = client,
Text = message,
Time = DateTime.Now,
Type = DispatchType.Connection
};
EventSaveAsync(new MessageEventLogContainer(eventLogMessage), new GeneralAgenda());
}
/// <summary>
/// Setup SFTP Connection based on Congfiguration File Parameters
/// </summary>
public void SetupConnection()
{
EventLogMessage.WriteLogDebug("ConnectorSFTP: SetupConnection method");
// Read connection configuration
_connectData = ConfigData.ReadConfigSFTP();
client = new SftpClient(_connectData.Host, _connectData.Port, _connectData.Username, _connectData.Password);
client.ConnectionInfo.Timeout = TimeSpan.FromSeconds(_connectData.Timeout);
client.Connect();
EventLogMessage.WriteLog("Connected to " + _connectData.Host);
if (_connectData.WorkingDirectory != "")
{
client.ChangeDirectory(_connectData.WorkingDirectory);
}
}
internal void FreeConnection(Guid connectionId)
{
if (!_connections.TryRemove(connectionId, out WsConnection connection) || string.IsNullOrEmpty(connection.Login))
{
return;
}
var eventLogMessage = new EventLogMessage
{
IsSuccessfully = true,
SenderName = connection.Login,
Text = "Disconnect",
Time = DateTime.Now,
Type = DispatchType.EventLog
};
ConnectionStateChanged?.Invoke(this, new ConnectionStateChangedEventArgs(connection.Login, false, eventLogMessage));
}
public static LogEventArgs GetSortedEventMessage(JObject message)
{
if (!(message.ToObject(typeof(MessageEventLogContainer)) is MessageEventLogContainer messageResponse))
{
throw new ArgumentException("Event log message don't sorted!");
}
var eventLogMessage = new EventLogMessage
{
IsSuccessfully = messageResponse.Content.IsSuccessfully,
SenderName = messageResponse.Content.SenderName,
Text = messageResponse.Content.Text,
Time = messageResponse.Content.Time,
Type = messageResponse.Content.Type
};
return(new LogEventArgs(eventLogMessage));
}
private async Task OnEventLogEvent(EventLogMessage eventLogMessage)
{
var config = await _context.GuildConfigs.AsNoTracking()
.Where(e => e.GuildId == eventLogMessage.GuildId)
.FirstOrDefaultAsync();
if (config.LogChannel.HasValue && _client.Guilds.TryGetValue(eventLogMessage.GuildId, out var guild))
{
var channel = guild.GetChannel(config.LogChannel.GetValueOrDefault());
if (channel != null)
{
await channel.SendMessageAsync(
$"{eventLogMessage.Username}#{eventLogMessage.Discriminator} with id `{eventLogMessage.Id}`" +
$" {eventLogMessage.Message} `action taken: {eventLogMessage.ActionTaken}`");
}
}
}
private void SendCompleted(object sender, SocketAsyncEventArgs eventArgs)
{
if (eventArgs.BytesTransferred != eventArgs.Count || eventArgs.SocketError != SocketError.Success)
{
Disconnect();
var eventLogMessage = new EventLogMessage
{
IsSuccessfully = false,
SenderName = _login,
Text = "Send don't completed",
Time = DateTime.Now,
Type = DispatchType.Message
};
ConnectionStateChanged?.Invoke(this, new ConnectionStateChangedEventArgs(_login, false, eventLogMessage));
return;
}
SendImpl();
}
