quartznet/pulsar
2
0
Fork 0
mirror of https://github.com/9ParsonsB/Pulsar.git synced 2025-04-05 17:39:39 -04:00
Code Actions

Update Journal File Handling

Browse Source 
Now Correctly deserializes Journal events
This commit is contained in:
Ben Parsons 2024-05-12 12:55:28 +10:00
parent e59ca066ab
commit bd811c861c
29 changed files with 714 additions and 442 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
ObservatoryFramework/Files/Converters/FleetCarrierTravelConverter.cs
View File

@ -7,13 +7,13 @@ class FleetCarrierTravelConverter : JsonConverter<float>
{
public override float Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
if (reader.TokenType == JsonTokenType.String)
return float.Parse(reader.GetString().Split(' ')[0]);
return reader.GetSingle();
}
if (reader.TokenType == JsonTokenType.String)
return float.Parse(reader.GetString().Split(' ')[0]);
return reader.GetSingle();
}
public override void Write(Utf8JsonWriter writer, float value, JsonSerializerOptions options)
{
writer.WriteStringValue(value.ToString());
}
writer.WriteStringValue(value.ToString());
}
}

12
ObservatoryFramework/Files/Converters/IntBoolFlexConverter.cs
View File

@ -7,13 +7,13 @@ public class IntBoolFlexConverter : JsonConverter<bool>
{
public override bool Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
if (reader.TokenType == JsonTokenType.Number)
return reader.GetInt16() == 1;
return reader.GetBoolean();
}
if (reader.TokenType == JsonTokenType.Number)
return reader.GetInt16() == 1;
return reader.GetBoolean();
}
public override void Write(Utf8JsonWriter writer, bool value, JsonSerializerOptions options)
{
writer.WriteBooleanValue(value);
}
writer.WriteBooleanValue(value);
}
}

4
ObservatoryFramework/Files/Converters/LegacyFactionConverter.cs
View File

@ -21,6 +21,6 @@ public class LegacyFactionConverter<TFaction> : JsonConverter<TFaction> where TF
public override void Write(Utf8JsonWriter writer, TFaction value, JsonSerializerOptions options)
{
throw new NotImplementedException();
}
JsonSerializer.Serialize(writer, value, options);
}
}

7
ObservatoryFramework/Files/Converters/MaterialCompositionConverter.cs
View File

@ -41,11 +41,12 @@ public class MaterialCompositionConverter : JsonConverter<ImmutableList<Material
return materialComposition.ToImmutableList();
}
return (ImmutableList<MaterialComposition>)JsonSerializer.Deserialize(ref reader, typeof(ImmutableList<MaterialComposition>));
return JsonSerializer.Deserialize<ImmutableList<MaterialComposition>>(ref reader, options)!;
}
public override void Write(Utf8JsonWriter writer, ImmutableList<MaterialComposition> value, JsonSerializerOptions options)
public override void Write(Utf8JsonWriter writer, ImmutableList<MaterialComposition> value,
JsonSerializerOptions options)
{
throw new NotImplementedException();
JsonSerializer.Serialize(writer, value, options);
}
}

52
ObservatoryFramework/Files/Converters/MaterialConverter.cs
View File

@ -11,42 +11,44 @@ namespace Observatory.Framework.Files.Converters;
/// </summary>
public class MaterialConverter : JsonConverter<ImmutableList<Material>>
{
public override ImmutableList<Material> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
public override ImmutableList<Material> Read(ref Utf8JsonReader reader, Type typeToConvert,
JsonSerializerOptions options)
{
if (reader.TokenType == JsonTokenType.StartObject)
if (reader.TokenType == JsonTokenType.StartObject)
{
var materialComposition = new List<Material>();
while (reader.Read())
{
var materialComposition = new List<Material>();
while (reader.Read())
if (reader.TokenType != JsonTokenType.EndObject)
{
if (reader.TokenType != JsonTokenType.EndObject)
if (reader.TokenType == JsonTokenType.PropertyName)
{
if (reader.TokenType == JsonTokenType.PropertyName)
var name = reader.GetString();
reader.Read();
var count = reader.GetInt32();
var material = new Material
{
var name = reader.GetString();
reader.Read();
var count = reader.GetInt32();
var material = new Material
{
Name = name,
Name_Localised = name,
Count = count
};
materialComposition.Add(material);
}
}
else
{
break;
Name = name,
Name_Localised = name,
Count = count
};
materialComposition.Add(material);
}
}
return materialComposition.ToImmutableList();
else
{
break;
}
}
return (ImmutableList<Material>)JsonSerializer.Deserialize(ref reader, typeof(ImmutableList<Material>));
return materialComposition.ToImmutableList();
}
return JsonSerializer.Deserialize<ImmutableList<Material>>(ref reader, options)!;
}
public override void Write(Utf8JsonWriter writer, ImmutableList<Material> value, JsonSerializerOptions options)
{
throw new NotImplementedException();
}
JsonSerializer.Serialize(writer, value, options);
}
}

2
ObservatoryFramework/Files/Converters/MissionEffectConverter.cs
View File

@ -32,6 +32,6 @@ public class MissionEffectConverter : JsonConverter<MissionEffect>
public override void Write(Utf8JsonWriter writer, MissionEffect value, JsonSerializerOptions options)
{
throw new NotImplementedException();
JsonSerializer.Serialize(writer, value, options);
}
}

5
ObservatoryFramework/Files/Converters/MutableStringDoubleConverter.cs
View File

@ -14,6 +14,9 @@ class MutableStringDoubleConverter : JsonConverter<object>
public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOptions options)
{
throw new NotImplementedException();
if (value.GetType() == typeof(string))
writer.WriteStringValue((string)value);
else
writer.WriteNumberValue((double)value);
}
}

2
ObservatoryFramework/Files/Converters/PipConverter.cs
View File

@ -14,6 +14,6 @@ class PipConverter : JsonConverter<(int Sys, int Eng, int Wep)>
public override void Write(Utf8JsonWriter writer, (int Sys, int Eng, int Wep) value, JsonSerializerOptions options)
{
JsonSerializer.Serialize(writer, new[] { value.Sys, value.Eng, value.Wep });
JsonSerializer.Serialize(writer, new {value.Sys, value.Eng, value.Wep}, options);
}
}

2
ObservatoryFramework/Files/Converters/RepInfConverter.cs
View File

@ -12,6 +12,6 @@ public class RepInfConverter : JsonConverter<int>
public override void Write(Utf8JsonWriter writer, int value, JsonSerializerOptions options)
{
throw new NotImplementedException();
JsonSerializer.Serialize(writer, value, options);
}
}

2
ObservatoryFramework/Files/Converters/StarPosConverter.cs
View File

@ -17,6 +17,6 @@ public class StarPosConverter : JsonConverter<(double x, double y, double z)>
public override void Write(Utf8JsonWriter writer, (double x, double y, double z) value, JsonSerializerOptions options)
{
throw new NotImplementedException();
JsonSerializer.Serialize(writer, value, options);
}
}

2
ObservatoryFramework/Files/Converters/StationServiceConverter.cs
View File

@ -21,6 +21,6 @@ public class StationServiceConverter : JsonConverter<StationService>
public override void Write(Utf8JsonWriter writer, StationService value, JsonSerializerOptions options)
{
throw new NotImplementedException();
JsonSerializer.Serialize(writer, value, options);
}
}

2
ObservatoryFramework/Files/Converters/StringIntConverter.cs
View File

@ -14,6 +14,6 @@ class StringIntConverter : JsonConverter<int>
public override void Write(Utf8JsonWriter writer, int value, JsonSerializerOptions options)
{
writer.WriteStringValue(value.ToString());
JsonSerializer.Serialize(writer, value, options);
}
}

24
ObservatoryFramework/Files/Converters/ThargoidWarRemainingTimeConverter.cs
View File

@ -7,22 +7,22 @@ class ThargoidWarRemainingTimeConverter : JsonConverter<int>
{
public override int Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
if (reader.TokenType == JsonTokenType.String)
{
var value = reader.GetString();
var dayCount = int.TryParse(value.Split(' ')[0], out var days)
? days
: 0;
if (reader.TokenType == JsonTokenType.String)
{
var value = reader.GetString();
return dayCount;
}
var dayCount = int.TryParse(value.Split(' ')[0], out var days)
? days
: 0;
return reader.GetInt32();
return dayCount;
}
return reader.GetInt32();
}
public override void Write(Utf8JsonWriter writer, int value, JsonSerializerOptions options)
{
writer.WriteStringValue(value + " Days");
}
writer.WriteStringValue(value + " Days");
}
}

16
ObservatoryFramework/Files/Converters/VoucherTypeConverter.cs
View File

@ -8,18 +8,18 @@ class VoucherTypeConverter : JsonConverter<VoucherType>
{
public override VoucherType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
var voucher = reader.GetString();
var voucher = reader.GetString();
if (voucher.Length == 0)
voucher = "None";
if (voucher.Length == 0)
voucher = "None";
var missionEffect = (VoucherType)Enum.Parse(typeof(VoucherType), voucher, true);
var missionEffect = (VoucherType)Enum.Parse(typeof(VoucherType), voucher, true);
return missionEffect;
}
return missionEffect;
}
public override void Write(Utf8JsonWriter writer, VoucherType value, JsonSerializerOptions options)
{
throw new NotImplementedException();
}
JsonSerializer.Serialize(writer, value, options);
}
}

10
ObservatoryFramework/Files/Journal/Travel/FSDJump.cs
View File

@ -20,15 +20,7 @@ public class FSDJump : JournalBase
public int BoostUsed { get; init; }
[JsonConverter(typeof(LegacyFactionConverter<SystemFaction>))]
public SystemFaction SystemFaction { get; init; }
[Obsolete(JournalUtilities.ObsoleteMessage)]
public string FactionState
{
get => SystemFaction.FactionState;
init
{
//Stale Data, discard
}
}
public string SystemAllegiance { get; init; }
public string SystemEconomy { get; init; }
public string SystemEconomy_Localised { get; init; }

11
ObservatoryFramework/Files/Journal/Travel/Location.cs
View File

@ -10,16 +10,7 @@ public class Location : JournalBase
[JsonConverter(typeof(IntBoolFlexConverter))]
public bool Docked { get; init; }
public double DistFromStarLS { get; init; }
[Obsolete(JournalUtilities.ObsoleteMessage)]
public string FactionState
{
get => SystemFaction.FactionState;
init
{
//Stale Data, discard
}
}
/// <summary>
/// Name of the station at which this event occurred.
/// </summary>

2
Pulsar/Features/FileHandlerService.cs
View File

@ -89,6 +89,6 @@ public class FileHandlerService(
}
logger.LogInformation("Handling file {FileName} with Type {Type}", fileName, handler.GetType().ToString());
Task.Run(() => handler.HandleFile(path));
await handler.HandleFile(path);
}
}

49
Pulsar/Features/FileWatcherService.cs
View File

@ -3,44 +3,67 @@ namespace Pulsar.Features;
using System.Collections.Concurrent;
using Microsoft.Extensions.FileProviders;
public class FileWatcherService(IOptions<PulsarConfiguration> options, IFileHandlerService fileHandlerService) : IHostedService
public class FileWatcherService(IOptions<PulsarConfiguration> options, IFileHandlerService fileHandlerService)
: IHostedService
{
private PhysicalFileProvider watcher = null!;
public Task StartAsync(CancellationToken cancellationToken)
{
if (!Directory.Exists(options.Value.JournalDirectory))
{
throw new Exception($"Directory {options.Value.JournalDirectory} does not exist.");
}
watcher = new PhysicalFileProvider(options.Value.JournalDirectory);
Watch();
// read the journal directory to get the initial files
#if DEBUG
Task.Run(() =>
{
Thread.Sleep(TimeSpan.FromSeconds(10));
HandleFileChanged();
}, cancellationToken);
#else
HandleFileChanged();
#endif
return Task.CompletedTask;
}
ConcurrentDictionary<string, DateTimeOffset> FileDates = new();
private void HandleFileChanged(object? sender)
private void HandleFileChanged(object? sender = null)
{
foreach (var file in watcher.GetDirectoryContents(""))
{
if (file.IsDirectory || !file.Name.EndsWith(".json") && !(file.Name.StartsWith(FileHandlerService.JournalLogFileNameStart) && file.Name.EndsWith(FileHandlerService.JournalLogFileNameEnd)))
if (file.IsDirectory || !file.Name.EndsWith(".json") &&
!(file.Name.StartsWith(FileHandlerService.JournalLogFileNameStart) &&
file.Name.EndsWith(FileHandlerService.JournalLogFileNameEnd)))
{
continue;
}
var existing = FileDates.GetOrAdd(file.PhysicalPath, file.LastModified);
if (existing != file.LastModified)
FileDates.AddOrUpdate(file.PhysicalPath, _ =>
{
fileHandlerService.HandleFile(file.PhysicalPath);
}
Task.Run(() => fileHandlerService.HandleFile(file.PhysicalPath));
return file.LastModified;
}, (_, existing) =>
{
if (existing != file.LastModified)
{
Task.Run(() => fileHandlerService.HandleFile(file.PhysicalPath));
}
return file.LastModified;
});
}
Watch();
}
private void Watch()
{
watcher.Watch("*.*").RegisterChangeCallback(HandleFileChanged, null);

84
Pulsar/Features/Journal/JournalService.cs
View File

@ -1,12 +1,12 @@
namespace Pulsar.Features.Journal;
using System.Collections.Concurrent;
using System.Text.RegularExpressions;
using Observatory.Framework.Files.Journal;
public interface IJournalService : IJournalHandler<List<JournalBase>>;
public class JournalService
(
public class JournalService(
ILogger<JournalService> logger,
IOptions<PulsarConfiguration> options,
IEventHubContext hub,
@ -14,74 +14,52 @@ public class JournalService
) : IJournalService
{
public string FileName => FileHandlerService.JournalLogFileName;
static ConcurrentBag<JournalBase> _journals = new();
public Task HandleFile(string filePath) => HandleFile(filePath, CancellationToken.None);
public async Task HandleFile(string filePath, CancellationToken token)
static DateTimeOffset notBefore = DateTimeOffset.UtcNow.AddHours(-1);
public async Task HandleFile(string filePath)
{
if (!FileHelper.ValidateFile(filePath))
{
return;
}
var file = await File.ReadAllLinesAsync(filePath, Encoding.UTF8, token);
var journals = file.Select(line => JsonSerializer.Deserialize<JournalBase>(line)).ToList();
var file = await File.ReadAllLinesAsync(filePath, Encoding.UTF8);
var newJournals = new List<JournalBase>();
var notBefore = DateTimeOffset.UtcNow.Subtract(TimeSpan.FromHours(6));
foreach (var journal in journals)
var select = file.AsParallel().Select(line => JsonSerializer.Deserialize<JournalBase>(line,
new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true,
Converters = { new JournalConverter(logger) }
}));
foreach (var journal in select)
{
if (context.Journals.Any(j => j.Timestamp == journal.Timestamp && j.Event == journal.Event))
if (_journals.Any(j => j.Timestamp == journal.Timestamp && j.Event == journal.Event))
{
continue;
}
if (journal.Timestamp < notBefore)
{
continue;
}
context.Journals.Add(journal);
if (journal.Timestamp > notBefore)
{
newJournals.Add(journal);
}
_journals.Add(journal);
newJournals.Add(journal);
}
await hub.Clients.All.JournalUpdated(newJournals);
if (newJournals.Any())
{
await hub.Clients.All.JournalUpdated(newJournals);
}
}
public async Task<List<JournalBase>> Get()
{
var folder = new DirectoryInfo(options.Value.JournalDirectory);
var regex = new Regex(FileHandlerService.JournalLogFileNameRegEx);
if (!folder.Exists)
{
logger.LogWarning("Journal directory {JournalDirectory} does not exist", folder.FullName);
return [];
}
var dataFileName = folder.GetFiles().FirstOrDefault(f => regex.IsMatch(f.Name))?.FullName;
if (!FileHelper.ValidateFile(dataFileName))
{
return [];
}
// Seems each entry is a new line. Not sure if this can be relied on?
var logs = File.ReadAllLines(dataFileName);
var journals = new List<JournalBase>();
foreach (var log in logs)
{
// var info = JournalReader.ObservatoryDeserializer<JournalBase>(log);
var info = JsonSerializer.Deserialize<JournalBase>(log);
if (info != null)
{
journals.Add(info);
}
}
if (journals.Count > 0) return journals;
logger.LogWarning("Failed to deserialize module info file {file}", dataFileName);
return [];
await hub.Clients.All.JournalUpdated(_journals.ToList());
return _journals.ToList();
}
}
}

32
Pulsar/Features/Status/StatusService.cs
View File

@ -13,31 +13,6 @@ public class StatusService
{
public string FileName => FileHandlerService.StatusFileName;
public bool ValidateFile(string filePath)
{
if (!File.Exists(filePath))
{
logger.LogWarning("Journal file {JournalFile} does not exist", filePath);
return false;
}
var fileInfo = new FileInfo(filePath);
if (!string.Equals(fileInfo.Name, FileName, StringComparison.InvariantCultureIgnoreCase))
{
logger.LogWarning("Journal file {name} is not valid");
return false;
}
if (fileInfo.Length == 0)
{
logger.LogWarning("Journal file {name} is empty", filePath);
return false;
}
return true;
}
public async Task HandleFile(string filePath)
{
if (!FileHelper.ValidateFile(filePath))
@ -46,6 +21,13 @@ public class StatusService
}
var file = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
if (file.Length < 2)
{
logger.LogWarning("File {FilePath} is empty", filePath);
return;
}
var status = await JsonSerializer.DeserializeAsync<Status>(file);
if (status == null)

301
Pulsar/Utils/JournalJsonConverter.cs Normal file
View File

@ -0,0 +1,301 @@
using Observatory.Framework.Files.Journal.Combat;
using Observatory.Framework.Files.Journal.Exploration;
using Observatory.Framework.Files.Journal.Odyssey;
using Observatory.Framework.Files.Journal.Other;
using Observatory.Framework.Files.Journal.Powerplay;
using Observatory.Framework.Files.Journal.Startup;
using Observatory.Framework.Files.Journal.StationServices;
using Observatory.Framework.Files.Journal.Trade;
using Observatory.Framework.Files.Journal.Travel;
namespace Pulsar.Utils;
using Observatory.Framework.Files.Journal;
[Flags]
public enum JournalReaderState
{
/// <summary>
/// Have read the first character of the object
/// </summary>
Start,
/// <summary>
/// Have read the timestamp. Generally the first property in a journal entry.
/// </summary>
Timestamp,
/// <summary>
/// have read the event name. Generally the second property in a journal entry.
/// </summary>
Event,
/// <summary>
/// Have read the last character of the object, the next character should be a newline, whitespace, EOF, or another object.
/// </summary>
End,
}
/// <summary>
/// A JournalFile contains a collection of journal entries.
/// Each journal entry is a JSON object, delimited by a newline character.
/// all Journals can be deserialized into a JournalBase object for identification
/// and then deserialized into their respective types.
/// </summary>
public class JournalConverter(ILogger logger) : JsonConverter<JournalBase>
{
private JournalReaderState state = JournalReaderState.Start;
public override JournalBase? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
Utf8JsonReader clone = reader;
DateTimeOffset? timestamp = null;
string? eventName = null;
// for debug
int depth = 0;
do
{
depth++;
switch (clone.TokenType)
{
case JsonTokenType.None:
break;
case JsonTokenType.StartObject:
state = JournalReaderState.Start;
break;
case JsonTokenType.EndObject:
state = JournalReaderState.End;
break;
case JsonTokenType.StartArray:
break;
case JsonTokenType.EndArray:
break;
case JsonTokenType.PropertyName:
var propertyName = clone.GetString();
// if we have not started reading the body, and we have not read the (timestamp or event name)
if ((state & JournalReaderState.Timestamp) == 0 || (state & JournalReaderState.Event) == 0)
{
switch (propertyName)
{
case "timestamp":
clone.Read();
timestamp = clone.GetDateTimeOffset();
state = JournalReaderState.Timestamp;
break;
case "event":
clone.Read();
eventName = clone.GetString();
state = JournalReaderState.Event;
break;
}
}
if ((state & JournalReaderState.Event) != 0)
{
// create destination type
return GetDestinationType(ref reader, eventName!);
}
break;
case JsonTokenType.Comment:
continue;
case JsonTokenType.String:
break;
case JsonTokenType.Number:
break;
case JsonTokenType.True:
break;
case JsonTokenType.False:
break;
case JsonTokenType.Null:
break;
default:
throw new ArgumentOutOfRangeException();
}
} while (clone.Read());
return new() { Timestamp = timestamp!.Value, Event = eventName! };
// TODO: handle inf (invalid data) in the journal files
// else if (typeof(TJournal) == typeof(Scan) && json.Contains("\"RotationPeriod\":inf"))
// {
// deserialized = JsonSerializer.Deserialize<TJournal>(json.Replace("\"RotationPeriod\":inf,", ""));
// }
}
private JournalBase GetDestinationType(ref Utf8JsonReader reader, string eventName)
{
switch (eventName.ToLower())
{
case "fileheader":
return JsonSerializer.Deserialize<FileHeader>(ref reader)!;
case "commander":
return JsonSerializer.Deserialize<Commander>(ref reader)!;
case "materials":
return JsonSerializer.Deserialize<Materials>(ref reader)!;
case "rank":
return JsonSerializer.Deserialize<Rank>(ref reader)!;
case "music":
return JsonSerializer.Deserialize<Music>(ref reader)!;
case "cargo":
return JsonSerializer.Deserialize<Cargo>(ref reader)!;
case "loadout":
return JsonSerializer.Deserialize<Loadout>(ref reader)!;
case "missions":
return JsonSerializer.Deserialize<Missions>(ref reader)!;
case "fsssignaldiscovered":
return JsonSerializer.Deserialize<FSSSignalDiscovered>(ref reader)!;
case "reputation":
return JsonSerializer.Deserialize<Reputation>(ref reader)!;
case "loadgame":
return JsonSerializer.Deserialize<LoadGame>(ref reader)!;
case "receivetext":
return JsonSerializer.Deserialize<ReceiveText>(ref reader)!;
case "shiplocker":
return JsonSerializer.Deserialize<ShipLockerMaterials>(ref reader)!;
case "location":
return JsonSerializer.Deserialize<Location>(ref reader)!;
case "powerplay":
return JsonSerializer.Deserialize<Powerplay>(ref reader)!;
case "reservoirreplenished":
return JsonSerializer.Deserialize<ReservoirReplenished>(ref reader)!;
case "statistics":
return JsonSerializer.Deserialize<Statistics>(ref reader)!;
case "scan":
return JsonSerializer.Deserialize<Scan>(ref reader)!;
case "shipyard":
return JsonSerializer.Deserialize<Shipyard>(ref reader)!;
case "docked":
return JsonSerializer.Deserialize<Docked>(ref reader)!;
case "leavebody":
return JsonSerializer.Deserialize<LeaveBody>(ref reader)!;
case "progress":
return JsonSerializer.Deserialize<Progress>(ref reader)!;
case "supercruiseexit":
return JsonSerializer.Deserialize<SupercruiseExit>(ref reader)!;
case "engineerprogress":
return JsonSerializer.Deserialize<EngineerProgress>(ref reader)!;
case "dockingrequested":
return JsonSerializer.Deserialize<DockingRequested>(ref reader)!;
case "npccrewpaidwage":
return JsonSerializer.Deserialize<NpcCrewPaidWage>(ref reader)!;
case "supercruiseentry":
return JsonSerializer.Deserialize<SupercruiseEntry>(ref reader)!;
case "dockinggranted":
return JsonSerializer.Deserialize<DockingGranted>(ref reader)!;
case "startjump":
return JsonSerializer.Deserialize<StartJump>(ref reader)!;
case "fssallbodiesfound":
return JsonSerializer.Deserialize<FSSAllBodiesFound>(ref reader)!;
case "fssbodysignals":
return JsonSerializer.Deserialize<FSSBodySignals>(ref reader)!;
case "liftoff":
return JsonSerializer.Deserialize<Liftoff>(ref reader)!;
case "supercruisedestinationdrop":
return JsonSerializer.Deserialize<SupercruiseDestinationDrop>(ref reader)!;
case "fsdtarget":
return JsonSerializer.Deserialize<FSDTarget>(ref reader)!;
case "fsdjump":
return JsonSerializer.Deserialize<FSDJump>(ref reader)!;
case "codexentry":
return JsonSerializer.Deserialize<CodexEntry>(ref reader)!;
case "hulldamage":
return JsonSerializer.Deserialize<HullDamage>(ref reader)!;
case "materialcollected":
return JsonSerializer.Deserialize<MaterialCollected>(ref reader)!;
case "navroute":
return JsonSerializer.Deserialize<NavRoute>(ref reader)!;
case "navrouteclear":
return JsonSerializer.Deserialize<NavRouteClear>(ref reader)!;
case "scanbarycentre":
return JsonSerializer.Deserialize<ScanBaryCentre>(ref reader)!;
case "jetconeboost":
return JsonSerializer.Deserialize<JetConeBoost>(ref reader)!;
case "shutdown":
return JsonSerializer.Deserialize<Shutdown>(ref reader)!;
case "fuelscoop":
return JsonSerializer.Deserialize<FuelScoop>(ref reader)!;
case "fssdiscoveryscan":
return JsonSerializer.Deserialize<FSSDiscoveryScan>(ref reader)!;
case "moduleinfo":
return JsonSerializer.Deserialize<ModuleInfo>(ref reader)!;
case "shiptargeted":
return JsonSerializer.Deserialize<ShipTargeted>(ref reader)!;
case "afmurepairs":
return JsonSerializer.Deserialize<AfmuRepairs>(ref reader)!;
case "heatwarning":
return JsonSerializer.Deserialize<HeatWarning>(ref reader)!;
case "modulebuy":
return JsonSerializer.Deserialize<ModuleBuy>(ref reader)!;
case "buydrones":
return JsonSerializer.Deserialize<BuyDrones>(ref reader)!;
case "shieldstate":
return JsonSerializer.Deserialize<ShieldState>(ref reader)!;
case "buyammo":
return JsonSerializer.Deserialize<BuyAmmo>(ref reader)!;
case "ejectcargo":
return JsonSerializer.Deserialize<EjectCargo>(ref reader)!;
case "approachbody":
return JsonSerializer.Deserialize<ApproachBody>(ref reader)!;
case "docksrv":
return JsonSerializer.Deserialize<DockSRV>(ref reader)!;
case "touchdown":
return JsonSerializer.Deserialize<Touchdown>(ref reader)!;
case "saasignalsfound":
return JsonSerializer.Deserialize<SAASignalsFound>(ref reader)!;
case "engineercraft":
return JsonSerializer.Deserialize<EngineerCraft>(ref reader)!;
case "materialtrade":
return JsonSerializer.Deserialize<MaterialTrade>(ref reader)!;
case "repair":
return JsonSerializer.Deserialize<Repair>(ref reader)!;
case "refuelall":
return JsonSerializer.Deserialize<RefuelAll>(ref reader)!;
case "storedmodules":
return JsonSerializer.Deserialize<StoredModules>(ref reader)!;
case "synthesis":
return JsonSerializer.Deserialize<Synthesis>(ref reader)!;
case "scanned":
return JsonSerializer.Deserialize<Scanned>(ref reader)!;
case "sendtext":
return JsonSerializer.Deserialize<SendText>(ref reader)!;
case "embark":
return JsonSerializer.Deserialize<Embark>(ref reader)!;
case "multisellexplorationdata":
return JsonSerializer.Deserialize<MultiSellExplorationData>(ref reader)!;
case "backpack":
return JsonSerializer.Deserialize<BackpackMaterials>(ref reader)!;
case "modulesell":
return JsonSerializer.Deserialize<ModuleSell>(ref reader)!;
case "undocked":
return JsonSerializer.Deserialize<Undocked>(ref reader)!;
case "repairall":
return JsonSerializer.Deserialize<RepairAll>(ref reader)!;
case "outfitting":
return JsonSerializer.Deserialize<Outfitting>(ref reader)!;
case "powerplaysalary":
return JsonSerializer.Deserialize<PowerplaySalary>(ref reader)!;
case "redeemvoucher":
return JsonSerializer.Deserialize<RedeemVoucher>(ref reader)!;
case "saascancomplete":
return JsonSerializer.Deserialize<SAAScanComplete>(ref reader)!;
case "friends":
return JsonSerializer.Deserialize<Friends>(ref reader)!;
case "launchsrv":
return JsonSerializer.Deserialize<LaunchSRV>(ref reader)!;
case "suitloadout":
return JsonSerializer.Deserialize<SuitLoadout>(ref reader)!;
case "disembark":
return JsonSerializer.Deserialize<Disembark>(ref reader)!;
case "materialdiscovered":
return JsonSerializer.Deserialize<MaterialDiscovered>(ref reader)!;
case "storedships":
return JsonSerializer.Deserialize<StoredShips>(ref reader)!;
default:
logger.LogWarning("Unknown Journal event type {EventName}", eventName);
return JsonSerializer.Deserialize<JournalBase>(ref reader)!;
}
}
public override void Write(Utf8JsonWriter writer, JournalBase value, JsonSerializerOptions options)
{
throw new NotSupportedException();
}
}

70
Pulsar/Utils/JournalReader.cs
View File

@ -1,70 +0,0 @@
using Observatory.Framework.Files.Journal;
using Observatory.Framework.Files.Journal.Exploration;
namespace Pulsar.Utils;
public static class JournalReader
{
public static TJournal ObservatoryDeserializer<TJournal>(string json) where TJournal : JournalBase
{
TJournal deserialized;
if (typeof(TJournal) == typeof(InvalidJson))
{
InvalidJson invalidJson;
try
{
var reader = new Utf8JsonReader(Encoding.UTF8.GetBytes(json));
var eventType = string.Empty;
var timestamp = string.Empty;
while ((eventType == string.Empty || timestamp == string.Empty) && reader.Read())
{
if (reader.TokenType == JsonTokenType.PropertyName)
{
if (reader.GetString() == "event")
{
reader.Read();
eventType = reader.GetString();
}
else if (reader.GetString() == "timestamp")
{
reader.Read();
timestamp = reader.GetString();
}
}
}
invalidJson = new InvalidJson
{
Event = "InvalidJson",
Timestamp = DateTimeOffset.UnixEpoch,
OriginalEvent = eventType
};
}
catch
{
invalidJson = new InvalidJson
{
Event = "InvalidJson",
Timestamp = DateTimeOffset.UnixEpoch,
OriginalEvent = "Invalid"
};
}
deserialized = (TJournal)Convert.ChangeType(invalidJson, typeof(TJournal));
}
//Journal potentially had invalid JSON for a brief period in 2017, check for it and remove.
//TODO: Check if this gets handled by InvalidJson now.
else if (typeof(TJournal) == typeof(Scan) && json.Contains("\"RotationPeriod\":inf"))
{
deserialized = JsonSerializer.Deserialize<TJournal>(json.Replace("\"RotationPeriod\":inf,", ""));
}
else
{
deserialized = JsonSerializer.Deserialize<TJournal>(json);
}
return deserialized;
}
}

10
Pulsar/WebApp/.vscode/settings.json vendored Normal file
View File

@ -0,0 +1,10 @@
{
"editor.formatOnSave": true,
"editor.formatOnSaveMode": "file",
"[typescript]": {
"editor.defaultFormatter": "biomejs.biome"
},
"[svelte]": {
"editor.defaultFormatter": "svelte.svelte-vscode"
}
}

186
Pulsar/WebApp/src/lib/JournalLog.svelte
View File

@ -1,146 +1,66 @@
<script lang="ts">
import connection from "./stores/Connection.store";
import type JournalBase from "../types/api/JournalBase";
import connection from "./stores/Connection.store";
let value = $state("");
const values: JournalBase[] = $state([]);
$connection.on("JournalUpdated", (journals) => {
console.log(journals);
value += `${JSON.stringify(journals)}\n`;
$connection.on("JournalUpdated", (journals) => {
console.log(journals);
values.push(...(journals as JournalBase[]));
values.sort((a, b) => {
// sort based on timestamp
if (a.timestamp < b.timestamp) return 1;
if (a.timestamp > b.timestamp) return -1;
return 0;
});
let data: any[] = [{}, {}, {}, {}, {}];
});
</script>
<section>
<div class="title">
<h1>Journals</h1>
</div>
<div class="box">
{#each data as row}
<div class="group">
<div class="summary">
<span>Body Name: Farseer Inc</span>
<div>
<span>Signals: 1</span>
<span>Base Value: 11111</span>
</div>
</div>
<table class="details">
<thead>
<tr>
<th>Flags</th>
<th>Genus</th>
<th>Species</th>
<th>Seen</th>
<th>Samples</th>
<th>Type</th>
<th>Possible Variants</th>
<th>Base Value</th>
<th>Distance</th>
</tr>
</thead>
<tbody>
{#each data as row}
<tr>
<td>Test</td>
<td>Test</td>
<td>Test</td>
<td>Test</td>
<td>Test</td>
<td>Test</td>
<td>Test</td>
<td>Test</td>
<td>500m</td>
</tr>
{/each}
</tbody>
</table>
</div>
{/each}
</div>
<div class="title">
<h1>Journals</h1>
</div>
<button
onclick={() => {
fetch("http://localhost:5000/api/journal");
}}
>
Refresh (debug)
</button>
<ul>
{#each values as value (value.timestamp + value.event)}
<li>
<span class="time">{value.timestamp}</span>
<span class="event">{value.event}</span>
<input readonly value={JSON.stringify(value)} />
</li>
{/each}
</ul>
</section>
<style>
section {
margin-top: 5px;
height: 500px;
overflow-y: scroll;
}
<style lang="scss">
section {
margin-top: 5px;
height: 500px;
overflow-y: scroll;
}
.box {
display: flex;
flex-direction: column;
gap: 20px;
}
.title {
padding-left: 5px;
padding-right: 5px;
width: 50%;
display: inline-block;
}
.title {
padding-left: 5px;
padding-right: 5px;
}
button {
position: relative;
display: inline-block;
margin-left: 40%;
}
.summary {
display: flex;
align-items: center;
justify-content: space-between;
gap: 50px;
padding-top: 5px;
padding-bottom: 5px;
background-color: #c06400;
color: var(--font-color-2);
font-weight: bold;
}
.summary span {
padding-left: 5px;
}
.summary div {
display: flex;
gap: 20px;
}
.details {
border-collapse: collapse;
border: none;
table-layout: auto;
width: 100%;
}
thead {
background-color: #c06400;
}
tbody tr:nth-child(even) {
background-color: #301900;
color: #cccccc;
}
tbody tr:nth-child(odd) {
background-color: #170c00;
color: #cccccc;
}
tbody tr:hover td {
background-color: rgba(79, 42, 0, 0.85);
}
th {
padding-top: 5px;
padding-bottom: 5px;
padding-left: 5px;
padding-right: 5px;
text-wrap: wrap;
text-align: left;
color: var(--font-color-2);
}
th:not(:first-child) {
text-align: center;
}
td:not(:first-child) {
text-align: center;
}
input {
width: 100%;
background-color: transparent;
color: white;
}
</style>

1
Pulsar/WebApp/src/lib/JournalService.ts Normal file
View File

@ -0,0 +1 @@
export default class JournalService {}

65
Pulsar/WebApp/src/lib/Status.svelte
View File

@ -1,46 +1,47 @@
<script lang="ts">
import { onMount } from "svelte";
import { statusStore } from "./stores/Status.store";
import connection from "./stores/Connection.store";
import { onMount } from "svelte";
import { statusStore } from "./stores/Status.store";
import connection from "./stores/Connection.store";
const x: string | null = $state(null);
const x: string | null = $state(null);
onMount(async () => {
await $connection.start();
onMount(async () => {
await $connection.start();
$connection.on("StatusUpdated", (message) => {
statusStore.update((s) => {
return { ...s, ...message };
});
console.log($statusStore);
});
$connection.on("StatusUpdated", (message) => {
statusStore.update((s) => {
return { ...s, ...message };
});
console.log($statusStore);
});
});
</script>
<h1>Status</h1>
<br />
<div>
{#if $statusStore}
<span>{$statusStore.event}</span>
<span>{(($statusStore.fuel?.fuelMain ?? 0) / 32) * 100}%</span>
<span>{$statusStore?.pips?.join(',')}</span>
<span>{$statusStore?.destination?.name}</span>
<span>{$statusStore.guiFocus}</span>
<span>{$statusStore.cargo}</span>
{:else}
<span>No data :(</span>
{/if}
<div>
{#if $statusStore}
<span>Fuel%: {(($statusStore.fuel?.fuelMain ?? 0) / 32) * 100}%</span>
<span
>Sys: {$statusStore?.pips?.sys ?? "?"} Eng: {$statusStore?.pips?.eng ??
"?"} Wep:
{$statusStore?.pips?.wep ?? "?"}</span
>
<span>dest?: {$statusStore?.destination?.name}</span>
<span>gui focus: {$statusStore.guiFocus}</span>
<span>cargo: {$statusStore.cargo}</span>
<span>flag1: {$statusStore.flags}</span>
<span>flag2: {$statusStore.flags2}</span>
{:else}
<span>No data :(</span>
{/if}
</div>
<style>
div {
display: flex;
flex-direction: column;
}
<style>
div {
display: flex;
flex-direction: column;
}
</style>

50
Pulsar/WebApp/src/routes/+page.svelte
View File

@ -1,33 +1,37 @@
<script lang="ts">
import Status from "$lib/Status.svelte";
import Ship from "$lib/Ship.svelte";
import Debug from "$lib/Debug.svelte";
import MissionStack from "$lib/MissionStack.svelte";
import JournalLog from "$lib/JournalLog.svelte";
import Status from "$lib/Status.svelte";
import Ship from "$lib/Ship.svelte";
import Debug from "$lib/Debug.svelte";
import MissionStack from "$lib/MissionStack.svelte";
import JournalLog from "$lib/JournalLog.svelte";
import Explorer from "./explorer/Explorer.svelte";
</script>
<section>
<div>
<Status />
</div>
<div>
<JournalLog />
</div>
<div>
<Status />
</div>
<div>
<Explorer />
</div>
<div>
<JournalLog />
</div>
</section>
<style>
div {
border: 2px solid var(--border-color);
}
div {
border: 2px solid var(--border-color);
}
section {
display: flex;
flex-wrap: wrap;
gap: 20px;
}
section {
display: flex;
flex-wrap: wrap;
gap: 20px;
}
div {
flex: 50%;
max-width: 100%;
}
div {
flex: 50%;
max-width: 100%;
}
</style>

133
Pulsar/WebApp/src/routes/explorer/Explorer.svelte Normal file
View File

@ -0,0 +1,133 @@
<script lang="ts">
const data: unknown[] = [{}, {}, {}, {}];
</script>
<section>
<div class="title">
<h1>Explorer</h1>
</div>
<div class="box">
{#each data as row}
<div class="group">
<div class="summary">
<span>Body Name: Farseer Inc</span>
<div>
<span>Signals: 1</span>
<span>Base Value: 11111</span>
</div>
</div>
<table class="details">
<thead>
<tr>
<th>Flags</th>
<th>Genus</th>
<th>Species</th>
<th>Seen</th>
<th>Samples</th>
<th>Type</th>
<th>Possible Variants</th>
<th>Base Value</th>
<th>Distance</th>
</tr>
</thead>
<tbody>
{#each data as row}
<tr>
<td>Test</td>
<td>Test</td>
<td>Test</td>
<td>Test</td>
<td>Test</td>
<td>Test</td>
<td>Test</td>
<td>Test</td>
<td>500m</td>
</tr>
{/each}
</tbody>
</table>
</div>
{/each}
</div>
</section>
<style lang="scss">
section {
margin-top: 5px;
max-height: 500px;
overflow-y: scroll;
}
.title {
padding-left: 5px;
padding-right: 5px;
}
.box {
display: flex;
flex-direction: column;
gap: 20px;
}
.summary {
display: flex;
align-items: center;
justify-content: space-between;
gap: 50px;
padding-top: 5px;
padding-bottom: 5px;
background-color: #c06400;
color: var(--font-color-2);
font-weight: bold;
span {
padding-left: 5px;
}
div {
display: flex;
gap: 20px;
}
}
.details {
border-collapse: collapse;
border: none;
table-layout: auto;
width: 100%;
}
thead {
background-color: #c06400;
}
tbody {
tr:nth-child(even) {
background-color: #301900;
color: #cccccc;
}
tr:nth-child(odd) {
background-color: #170c00;
color: #cccccc;
}
tr:hover td {
background-color: rgba(79, 42, 0, 0.85);
}
th {
padding-top: 5px;
padding-bottom: 5px;
padding-left: 5px;
padding-right: 5px;
text-wrap: wrap;
text-align: left;
color: var(--font-color-2);
}
}
th:not(:first-child) {
text-align: center;
}
td:not(:first-child) {
text-align: center;
}
</style>

8
Pulsar/WebApp/src/types/api/Status.ts
View File

@ -1,17 +1,17 @@
import type Destination from "./Destination";
import type Fuel from "./Fuel";
import type JournalBase from "./JournalBase";
export default interface Status {
export default interface Status extends JournalBase {
event: "Status";
flags: number;
flags2: number;
pips: number[];
pips: { eng: number; sys: number; wep: number };
guiFocus: number;
fuel: Fuel;
cargo: number;
legalState: string;
balance: number;
destination: Destination;
timestamp: Date;
event: string;
FireGroup: number;
}