private void LogBattleFormat(LogLineEvent logLineEvent)
{
var filePath = Path.Combine(_configuration.Logging.LogLocation,
"Kapture_" + _kaptureVersion + "_" + DateTime.Now.ToString("yyyyMMdd") + ".log");
lock (Lock)
{
File.AppendAllText(filePath, logLineEvent.GetMessageWithTimestamp() + Environment.NewLine);
}
}
private void LogSimpleFormat(LogLineEvent logLineEvent)
{
var filePath = Path.Combine(Configuration.Logging.LogLocation,
"Kapture_" + KaptureVersion + "_" + DateTime.Now.ToString("yyyyMMdd") + ".log");
lock (Lock)
{
File.AppendAllText(filePath, logLineEvent.LogMessage + Environment.NewLine);
}
}
private void CreateEvent(ACTLogLineEvent actLogLineEvent)
{
LogLineEvent = new LogLineEvent {
ACTLogLineEvent = actLogLineEvent
};
LogLineEvent.LogMessage = LogLineEvent.ACTLogLineEvent.LogLine;
var match = Context.PrefixRegex.Match(LogLineEvent.LogMessage);
LogLineEvent.LogMessage = match.Groups["Residual"].Value;
}
private void LogJsonFormat(LogLineEvent logLineEvent)
{
var filePath = Path.Combine(Configuration.Logging.LogLocation,
"Kapture_" + KaptureVersion + "_" + DateTime.Now.ToString("yyyyMMdd") + ".json");
var json = _serializer.Serialize(logLineEvent);
lock (Lock)
{
File.AppendAllText(filePath, json + Environment.NewLine);
}
}
private void LogJsonFormat(LogLineEvent logLineEvent)
{
var filePath = Path.Combine(_configuration.Logging.LogLocation,
"Kapture_" + _kaptureVersion + "_" + DateTime.Now.ToString("yyyyMMdd") + ".json");
var json = JsonConvert.SerializeObject(logLineEvent, _jsonSerializerSettings);
lock (Lock)
{
File.AppendAllText(filePath, json + Environment.NewLine);
}
}
private void SendToDiscordQueue(LogLineEvent logLineEvent)
{
if (!_configuration.Discord.DiscordEnabled)
{
return;
}
if (_configuration.Discord.Endpoint == null)
{
return;
}
lock (DiscordLock)
{
var json = "{\"content\": \"" + logLineEvent.GetShorthand() + "\"}";
_discordQueue.Enqueue(json);
}
}
private void SendToHTTPQueue(LogLineEvent logLineEvent)
{
if (!_configuration.HTTP.HTTPEnabled)
{
return;
}
if (_configuration.HTTP.Endpoint == null)
{
return;
}
lock (HTTPLock)
{
var json = JsonConvert.SerializeObject(new object[] { logLineEvent, _configuration.HTTP.CustomJson },
_jsonSerializerSettings);
_httpQueue.Enqueue(json);
}
}
private void LogCsvFormat(LogLineEvent logLineEvent)
{
var filePath = Path.Combine(_configuration.Logging.LogLocation,
"Kapture_" + _kaptureVersion + "_" + DateTime.Now.ToString("yyyyMMdd") + ".csv");
lock (Lock)
{
var csvMsg = logLineEvent.Id + PluginConstants.CsvSep +
logLineEvent.ACTLogLineEvent.DetectedTime + PluginConstants.CsvSep +
logLineEvent.KaptureEvent?.EventType + PluginConstants.CsvSep +
logLineEvent.KaptureEvent?.Actor?.Name + PluginConstants.CsvSep +
logLineEvent.KaptureEvent?.Item?.ProperName + PluginConstants.CsvSep +
logLineEvent.KaptureEvent?.Item?.Quantity + PluginConstants.CsvSep +
logLineEvent.KaptureEvent?.Roll;
File.AppendAllText(filePath, csvMsg + Environment.NewLine);
}
}
private async Task SendRestCall(LogLineEvent logLineEvent)
{
if (Configuration.HTTP.Endpoint == null)
{
return;
}
var json = _serializer.Serialize(new object[] { logLineEvent, Configuration.HTTP.CustomJson });
try
{
await _httpClient.PostAsync(new Uri(Configuration.HTTP.Endpoint),
new StringContent(json.ToString(), Encoding.UTF8, "application/json"));
}
catch (Exception ex)
{
Logger.GetInstance().Error(ex);
}
}
private async Task SendToDiscordWebHook(LogLineEvent logLineEvent)
{
if (Configuration.Discord.Endpoint == null)
{
return;
}
var json = "{\"content\": \"" + logLineEvent.LogMessage + "\"}";
try
{
await _httpClient.PostAsync(new Uri(Configuration.Discord.Endpoint),
new StringContent(json, Encoding.UTF8, "application/json"));
}
catch (Exception ex)
{
_logger.Error(ex);
}
}
private void LogMessage(LogLineEvent logLineEvent)
{
if (!_configuration.Logging.LoggingEnabled)
{
return;
}
if (_configuration.Logging.LogFormat.ToString().Equals(LogFormat.BattleLog.ToString()))
{
LogBattleFormat(logLineEvent);
}
else if (_configuration.Logging.LogFormat.ToString().Equals(LogFormat.CSV.ToString()))
{
LogCsvFormat(logLineEvent);
}
else if (_configuration.Logging.LogFormat.ToString().Equals(LogFormat.JSON.ToString()))
{
LogJsonFormat(logLineEvent);
}
}
public void Parse(ACTLogLineEvent actLogLineEvent)
{
if (IsExcludedEvent(actLogLineEvent))
{
return;
}
CreateEvent(actLogLineEvent);
PreUpdateMessage();
ParseLootEvent();
if (IsExcludedLootEvent())
{
LogLineEvent = null;
return;
}
PostUpdateMessage();
ExtractStaticFields();
GetMarketBoardData();
}
private void HandleLootEvent(object sender, LogLineEvent logLineEvent)
{
try
{
if (logLineEvent == null)
{
return;
}
_configuration = (Configuration)KaptureConfig.GetInstance().ConfigManager.Config;
_kaptureGuiLogger.Info(logLineEvent.LogMessage);
LogMessage(logLineEvent);
SendToDiscordQueue(logLineEvent);
SendToHTTPQueue(logLineEvent);
EventSource.SendEvent("LootData", logLineEvent);
}
catch (Exception ex)
{
_kaptureGuiLogger.Error(logLineEvent?.LogMessage + "." + Environment.NewLine, ex);
}
}
private void ParseLootEvents(object sender, LogLineEvent logLineEvent)
{
try
{
// loot filter
if (logLineEvent?.XIVEvent == null)
{
return;
}
if (logLineEvent.XIVEvent.XIVEventType != XIVEventTypeEnum.Loot)
{
return;
}
// set vars
var lootEvent = logLineEvent.XIVEvent;
Configuration = (Configuration)KaptureConfig.ConfigManager.Config;
// general filter
if (!Configuration.General.PluginEnabled)
{
return;
}
if (logLineEvent.ACTLogLineEvent.IsImport && !Configuration.General.LogImportsEnabled)
{
return;
}
// events filter
if (lootEvent.XIVEventSubType == XIVEventSubTypeEnum.AddLoot)
{
if (!Configuration.Events.ItemAddedEnabled)
{
return;
}
}
else if (lootEvent.XIVEventSubType == XIVEventSubTypeEnum.LostLoot)
{
if (!Configuration.Events.ItemDroppedEnabled)
{
return;
}
}
else if (lootEvent.XIVEventSubType == XIVEventSubTypeEnum.ObtainLoot)
{
if (lootEvent.Actor.IsReporter)
{
if (!Configuration.Events.YouObtainedEnabled)
{
return;
}
}
else if (!lootEvent.Actor.IsReporter)
{
if (!Configuration.Events.TheyObtainedEnabled)
{
return;
}
}
else
{
return;
}
}
else if (lootEvent.XIVEventSubType == XIVEventSubTypeEnum.NeedLoot ||
lootEvent.XIVEventSubType == XIVEventSubTypeEnum.GreedLoot)
{
if (lootEvent.Actor.IsReporter)
{
if (!Configuration.Events.YouRolledEnabled)
{
return;
}
}
else if (!lootEvent.Actor.IsReporter)
{
if (!Configuration.Events.TheyRolledEnabled)
{
return;
}
}
else
{
return;
}
}
// items filter
if (Configuration.Items.FilterByItems)
{
if (Configuration.Items.IncludeItems)
{
if (!Configuration.Items.ItemsList.Contains(lootEvent.Item.ProperName))
{
return;
}
}
else if (Configuration.Items.ExcludeItems)
{
if (Configuration.Items.ItemsList.Contains(lootEvent.Item.ProperName))
{
return;
}
}
}
// zones filter
if (Configuration.Zones.FilterByZones && !logLineEvent.ACTLogLineEvent.IsImport)
{
if (Configuration.Zones.IncludeZones)
{
if (!Configuration.Zones.ZonesList.Contains(lootEvent.Location.Zone.Name))
{
return;
}
}
else if (Configuration.Zones.ExcludeZones)
{
if (Configuration.Zones.ZonesList.Contains(lootEvent.Location.Zone.Name))
{
return;
}
}
}
// log messages
if (Configuration.Logging.LoggingEnabled)
{
if (Configuration.Logging.LogFormat.ToString().Equals(LogFormat.LogFile.ToString()))
{
LogSimpleFormat(logLineEvent);
}
else if (Configuration.Logging.LogFormat.ToString().Equals(LogFormat.CSV.ToString()))
{
LogCsvFormat(logLineEvent);
}
else if (Configuration.Logging.LogFormat.ToString().Equals(LogFormat.JSON.ToString()))
{
LogJsonFormat(logLineEvent);
}
}
// send message to discord
if (Configuration.Discord.DiscordEnabled)
{
SendToDiscordWebHook(logLineEvent);
}
// send message to rest endpoint
if (Configuration.HTTP.HTTPEnabled)
{
SendRestCall(logLineEvent);
}
}
catch (Exception ex)
{
_logger.Info("Failed on log line: " + logLineEvent?.LogMessage);
_logger.Error(ex);
}
}