added database to store metadata

ParadoxSaveParser.Lib/ParadoxSaveParser.Lib.csproj

@@ -8,6 +8,6 @@
     </PropertyGroup>
     
     <ItemGroup>
-      <PackageReference Include="Microsoft.Extensions.ObjectPool" Version="9.0.3" />
+      <PackageReference Include="Microsoft.Extensions.ObjectPool" Version="9.0.4" />
     </ItemGroup>
 </Project>

ParadoxSaveParser.WebAPI/BackgroundTasks/BackgroundJobManager.cs

@@ -1,4 +1,5 @@
-using ParadoxSaveParser.WebAPI.SaveDataFilters;
+using ParadoxSaveParser.WebAPI.Database;
+using ParadoxSaveParser.WebAPI.SaveDataFilters;
 
 namespace ParadoxSaveParser.WebAPI.BackgroundTasks;
 

ParadoxSaveParser.WebAPI/BackgroundTasks/SaveParsingOperation.cs

@@ -1,7 +1,9 @@
-using System.IO.Compression;
+using System.IO;
+using System.IO.Compression;
 using System.Linq;
 using System.Text.Encodings.Web;
 using System.Text.Json.Serialization;
+using ParadoxSaveParser.WebAPI.Database;
 using ParadoxSaveParser.WebAPI.SaveDataFilters;
 
 namespace ParadoxSaveParser.WebAPI.BackgroundTasks;
@@ -13,9 +15,9 @@ public class SaveParsingOperation
     private readonly SaveFileMetadata _meta;
     private readonly ISaveDataFilter _filter;
     private readonly ContextLogger _logger;
-    private readonly CancellationToken _cancelToken;
+    private readonly CancellationToken _ct;
 
-    private static readonly JsonSerializerOptions _saveSerializerOptions = new()
+    private static readonly JsonSerializerOptions _jsonOptions = new()
     {
         WriteIndented = false,
         Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
@@ -24,13 +26,13 @@ public class SaveParsingOperation
     };
 
     public SaveParsingOperation(long operationId, SaveFileMetadata meta, ISaveDataFilter filter,
-        ContextLogger logger, CancellationToken cancelToken)
+        ContextLogger logger, CancellationToken ct)
     {
         OperationId = operationId;
         _meta = meta;
         _filter = filter;
         _logger = logger;
-        _cancelToken = cancelToken;
+        _ct = ct;
     }
 
     public async void StartAsync()
@@ -52,7 +54,14 @@ public class SaveParsingOperation
         {
             string errorMesage = ex.ToStringDemystified();
             _logger.LogError(errorMesage);
-            _meta.errorMessage = errorMesage;
+            try
+            {
+                await Program.DB.SetMetadataError(_meta, errorMesage);
+            }
+            catch (Exception ex2)
+            {
+                _logger.LogError(ex2);
+            }
         }
         finally
         {
@@ -63,30 +72,31 @@ public class SaveParsingOperation
     private async Task ParseSaveEU4()
     {
         // wait for save file closing
-        await Task.Delay(200, _cancelToken);
+        await Task.Delay(200, _ct);
-        string extractedGamestatePath = PathHelper.GetSaveFilePath(_meta.id) + ".gamestate";
+        Dictionary<string, object> parsedData;
-        using (var zipArchive = ZipFile.Open(PathHelper.GetSaveFilePath(_meta.id).Str, ZipArchiveMode.Read))
+        await using (var gamestateStream = PathHelper.CreateTempFile())
+        {
+            using (var zipArchive = ZipFile.Open(_meta.GetSaveFilePath().Str, ZipArchiveMode.Read))
             {
                 var zipEntry = zipArchive.Entries.FirstOrDefault(e => e.Name == "gamestate");
                 if (zipEntry is null)
                     throw new Exception("Invalid save format: no 'gamestate' file found");
 
-            zipEntry.ExtractToFile(extractedGamestatePath, true);
+                await zipEntry.Open().CopyToAsync(gamestateStream, _ct);
+                gamestateStream.Seek(0, SeekOrigin.Begin);
             }
             
-        var gamestateStream = File.OpenRead(extractedGamestatePath);
+            await Program.DB.UpdateMetadataStatus(_meta, SaveFileProcessingStatus.Parsing);
-
-        _meta.status = SaveFileProcessingStatus.Parsing;
             var parser = new SaveParserEU4(gamestateStream, _filter.SearchExpression);
-        var result = parser.Parse();
+            parsedData = parser.Parse();
-        _filter.Apply(result);
+        }
 
-        _meta.status = SaveFileProcessingStatus.SavingResults;
+        _filter.Apply(parsedData);
-        var resultFilePath = PathHelper.GetParsedSaveFilePath(_meta.id);
+
-        await using var resultFile = File.OpenWrite(resultFilePath);
+        await Program.DB.UpdateMetadataStatus(_meta, SaveFileProcessingStatus.SavingResults);
-        await JsonSerializer.SerializeAsync(resultFile, result, 
+        var resultFilePath = _meta.GetParsedDataPath();
-            _saveSerializerOptions, _cancelToken);
+        await using (var resultFile = File.OpenWrite(resultFilePath))
-        _meta.status = SaveFileProcessingStatus.Done;
+            await JsonSerializer.SerializeAsync(resultFile, parsedData, _jsonOptions, _ct);
-        _meta.SaveToFile();
+        await Program.DB.UpdateMetadataStatus(_meta, SaveFileProcessingStatus.Done);
     }
 }

ParadoxSaveParser.WebAPI/Database/DatabaseConnector.cs

@@ -0,0 +1,105 @@
+using System.Linq;
+using SQLite;
+
+namespace ParadoxSaveParser.WebAPI.Database;
+
+public class DatabaseConnector
+{
+    private readonly int _uploadsLifetimeDays;
+    private readonly SQLiteAsyncConnection _db;
+    private readonly ContextLogger _logger;
+
+    public DatabaseConnector(string databasePath, int uploadsLifetimeDays, ILogger logger)
+    {
+        _uploadsLifetimeDays = uploadsLifetimeDays;
+        _db = new SQLiteAsyncConnection(databasePath);
+        _logger = new ContextLogger("Database", logger);
+    }
+
+    public async Task InitializeAsync()
+    {
+        await _db.CreateTableAsync<SaveFileMetadata>();
+    }
+    
+    public async Task<SaveFileMetadata?> GetMetadata(string id)
+    {
+        return (await _db.QueryAsync<SaveFileMetadata>(
+            "select * from SaveFileMetadata where id = ?", id))
+            .FirstOrDefault();
+    }
+    
+    public async Task<SaveFileMetadata> CreateMetadata(Game game)
+    {
+        var meta = new SaveFileMetadata
+        {
+            id = Guid.NewGuid().ToString(),
+            game = game,
+            status = SaveFileProcessingStatus.Initialized,
+            uploadDateTime = DateTime.Now
+        };
+        await _db.InsertAsync(meta);
+        return meta;
+    }
+
+    public async Task UpdateMetadataStatus(SaveFileMetadata meta, SaveFileProcessingStatus status)
+    {
+        meta.status = status;
+        await _db.UpdateAsync(meta);
+    }
+
+    public async Task SetMetadataError(SaveFileMetadata meta, string errorMessage)
+    {
+        meta.errorMessage = errorMessage;
+        await UpdateMetadataStatus(meta, SaveFileProcessingStatus.Error);
+        DeleteAssociatedFiles(meta);
+    }
+
+    public async Task DeleteMetadata(SaveFileMetadata meta)
+    {
+        _logger.LogDebug($"Deleting save file (id: {meta.id} status: {meta.status} " +
+                         $"uploadDate: {meta.uploadDateTime:yyyy/MM/dd})");
+        await _db.DeleteAsync(meta);
+        DeleteAssociatedFiles(meta);
+    }
+
+    /// <summary>
+    /// WARNING: Call this method only when no parsing operations are running.
+    /// </summary>
+    public async Task DeleteInvalidData()
+    {
+        _logger.LogInfo("Deleting invalid data...");
+        
+        var expirationDate = DateTime.Now.AddDays(-_uploadsLifetimeDays);
+        var metadataTable = _db.Table<SaveFileMetadata>();
+        int rowCount = await metadataTable.CountAsync();
+        int i = 0;
+        int deleteCount = 0;
+        while(i < rowCount)
+        {
+            var meta = await metadataTable.ElementAtAsync(i)!;
+            if(meta.status != SaveFileProcessingStatus.Done || 
+               meta.uploadDateTime < expirationDate ||
+               !meta.AssociatedFilesExist())
+            {
+                deleteCount++;
+                await DeleteMetadata(meta);
+            }
+            i++;
+        }
+
+        _logger.LogInfo($"Deleted {deleteCount} invalid records");
+    }
+
+    private void TryDeleteFile(IOPath file)
+    {
+        if (!File.Exists(file)) return;
+        _logger.LogDebug($"Deleting file '{file}'");
+        File.Delete(file);
+    }
+
+    private void DeleteAssociatedFiles(SaveFileMetadata meta)
+    {
+        TryDeleteFile(meta.GetSaveFilePath());
+        TryDeleteFile(meta.GetParsedDataPath());
+    }
+}

ParadoxSaveParser.WebAPI/Database/SaveFileMetadata.cs

@@ -0,0 +1,45 @@
+using System.Text.Json.Serialization;
+
+namespace ParadoxSaveParser.WebAPI.Database;
+
+public enum SaveFileProcessingStatus
+{
+    Initialized,
+    Uploaded,
+    Parsing,
+    SavingResults,
+    Done,
+    Error,
+}
+
+public class SaveFileMetadata
+{
+    [SQLite.PrimaryKey]
+    [SQLite.NotNull]
+    public string id { get; init; } = null!;
+
+    [JsonConverter(typeof(JsonStringEnumConverter))]
+    [SQLite.NotNull]
+    public Game game { get; init; }
+
+    [JsonConverter(typeof(JsonStringEnumConverter))]
+    [SQLite.NotNull]
+    public SaveFileProcessingStatus status { get; set; }
+    
+    [SQLite.NotNull]
+    public DateTime uploadDateTime { get; set; }
+    
+    // if error occured during parsing, it's message is saved here
+    // status stays the same as when error occured
+    public string? errorMessage { get; set; }
+    
+    
+    public IOPath GetSaveFilePath() => Path.Concat(PathHelper.SAVES_DIR, id + ".eu4");
+
+    public IOPath GetParsedDataPath() => Path.Concat(PathHelper.PARSED_DIR, id + ".parsed.json");
+
+    public bool AssociatedFilesExist()
+    {
+        return File.Exists(GetSaveFilePath()) && File.Exists(GetParsedDataPath());
+    }
+}

ParadoxSaveParser.WebAPI/Game.cs

@@ -0,0 +1,7 @@
+namespace ParadoxSaveParser.WebAPI;
+
+public enum Game
+{
+    Unknown,
+    EU4
+}

ParadoxSaveParser.WebAPI/ParadoxSaveParser.WebAPI.csproj

@@ -15,6 +15,7 @@
     <ItemGroup>
         <PackageReference Include="DTLib.Web" Version="1.3.0"/>
         <PackageReference Include="Google.Protobuf" Version="3.30.2" />
+        <PackageReference Include="sqlite-net-pcl" Version="1.9.172" />
     </ItemGroup>
 
     <ItemGroup>

ParadoxSaveParser.WebAPI/PathHelper.cs

@@ -6,16 +6,31 @@ public static class PathHelper
 {
     public static readonly IOPath DATA_DIR = "data";
     public static readonly IOPath SAVES_DIR = Path.Concat(DATA_DIR, "saves");
-
+    public static readonly IOPath PARSED_DIR = Path.Concat(DATA_DIR, "parsed");
-    public static IOPath GetMetaFilePath(string save_id) => Path.Concat(SAVES_DIR, save_id + ".meta.json");
+    public static readonly IOPath TEMP_DIR = "temp";
-
-    public static IOPath GetSaveFilePath(string save_id) => Path.Concat(SAVES_DIR, save_id + ".eu4");
-
-    public static IOPath GetParsedSaveFilePath(string save_id) => Path.Concat(SAVES_DIR, save_id + ".parsed.json");
 
     public static void CreateProgramDirectories()
     {
         Directory.Create(DATA_DIR);
         Directory.Create(SAVES_DIR);
+        Directory.Create(PARSED_DIR);
+        Directory.Create(TEMP_DIR);
+    }
+
+    public static void CleanTempDirectory()
+    {
+        Directory.Delete(TEMP_DIR);
+        Directory.Create(TEMP_DIR);
+    }
+
+    public static Stream CreateTempFile()
+    {
+        string fileName = Guid.NewGuid().ToString();
+        IOPath filePath = Path.Concat(TEMP_DIR, fileName);
+        var stream = System.IO.File.Open(filePath.Str, FileMode.CreateNew, FileAccess.ReadWrite,
+            FileShare.Read | FileShare.Delete);
+        // file stays as a ghost until it is closed
+        File.Delete(filePath);
+        return stream;
     }
 }

ParadoxSaveParser.WebAPI/Program.cs

@@ -11,28 +11,25 @@ global using ParadoxSaveParser.Lib;
 global using Directory = DTLib.Filesystem.Directory;
 global using File = DTLib.Filesystem.File;
 global using Path = DTLib.Filesystem.Path;
-using System.Collections.Concurrent;
-using System.IO;
 using DTLib.Console;
 using DTLib.Dtsod;
 using DTLib.Web;
 using DTLib.Web.Routes;
 using ParadoxSaveParser.WebAPI.BackgroundTasks;
+using ParadoxSaveParser.WebAPI.Database;
 using ParadoxSaveParser.WebAPI.Routes;
 using ParadoxSaveParser.WebAPI.SaveDataFilters;
+// ReSharper disable MethodHasAsyncOverload
 
 namespace ParadoxSaveParser.WebAPI;
 
 public static class Program
 {
-    private static readonly IOPath _configPath = "./config.dtsod";
+    internal static bool IsDebug = true;
-    private static Config _config = new();
+    internal static DatabaseConnector DB = null!;
-    private static bool IsDebug = true;
-    private static readonly CancellationTokenSource _mainCancel = new();
-    internal static readonly ConcurrentDictionary<string, SaveFileMetadata> _saveMetadataStorage = new();
 
 
-    public static void Main(string[] args)
+    public static async Task Main(string[] args)
     {
         Console.InputEncoding = Encoding.UTF8;
         Console.OutputEncoding = Encoding.UTF8;
@@ -60,44 +57,36 @@ public static class Program
         var loggerMain = new ContextLogger(nameof(Main), loggerRoot);
         loggerMain.LogDebug("Debug log is enabled");
 
+        CancellationTokenSource mainCancel = new();
         Console.CancelKeyPress += (_, e) =>
         {
             e.Cancel = true;
             loggerMain.LogInfo("Ctrl+C Pressed");
-            _mainCancel.Cancel();
+            mainCancel.Cancel();
         };
 
         try
         {
             // config
-            if (!File.Exists(_configPath))
+            IOPath configPath = "./config.dtsod";
+            Config config;
+            if (File.Exists(configPath))
             {
-                loggerMain.LogWarn("config file not found.");
+                config = Config.FromDtsod(new DtsodV23(File.ReadAllText(configPath)));
-                File.WriteAllText(_configPath, _config.ToString());
-                loggerMain.LogWarn($"created default at {_configPath}.");
             }
             else
             {
-                _config = Config.FromDtsod(new DtsodV23(File.ReadAllText(_configPath)));
+                loggerMain.LogWarn("config file not found.");
+                config = new();
+                File.WriteAllText(configPath, config.ToString());
+                loggerMain.LogWarn($"created default at {configPath}.");
             }
             
             PathHelper.CreateProgramDirectories();
-
+            PathHelper.CleanTempDirectory();
-            var metaFiles = System.IO.Directory.GetFiles(
+            DB = new("database.sqlite", 30, loggerRoot);
-                PathHelper.SAVES_DIR.Str, "*.meta.json",
+            await DB.InitializeAsync();
-                SearchOption.TopDirectoryOnly);
+            await DB.DeleteInvalidData();
-            foreach (string metaFilePath in metaFiles)
-            {
-                using var metaFile = File.OpenRead(metaFilePath);
-                var meta = JsonSerializer.Deserialize<SaveFileMetadata>(metaFile) ??
-                           throw new NullReferenceException(metaFilePath);
-                if (meta.status != SaveFileProcessingStatus.Done)
-                    loggerMain.LogWarn(nameof(Main),
-                        $"metadata file '{metaFilePath}' status has invalid status {meta.status}");
-
-                if (!_saveMetadataStorage.TryAdd(meta.id, meta))
-                    throw new Exception("Guid collision!");
-            }
 
             var bgJobManager = new BackgroundJobManager(loggerRoot);
             var saveFilters = new Dictionary<Game, ISaveDataFilter>
@@ -108,13 +97,13 @@ public static class Program
             // http server
             var router = new SimpleRouter(loggerRoot);
             router.DefaultRoute = new ServeFilesRouteHandler("public");
-            router.MapRoute("/getSaveStatus", HttpMethod.GET, new GetSaveStatusHandler(_mainCancel.Token));
+            router.MapRoute("/getSaveStatus", HttpMethod.GET, new GetSaveStatusHandler(mainCancel.Token));
-            router.MapRoute("/uploadSave/eu4", HttpMethod.POST, new UploadSaveHandler(_mainCancel.Token, 
+            router.MapRoute("/uploadSave", HttpMethod.POST, new UploadSaveHandler(mainCancel.Token, 
                 bgJobManager, saveFilters));
-            router.MapRoute("/getSaveData", HttpMethod.GET, new GetSaveDataHandler(_mainCancel.Token));
+            router.MapRoute("/getSaveData", HttpMethod.GET, new GetSaveDataHandler(mainCancel.Token));
 
-            var app = new WebApp(_config.BaseUrl, loggerRoot, router, _mainCancel.Token);
+            var app = new WebApp(config.BaseUrl, loggerRoot, router, mainCancel.Token);
-            app.Run().GetAwaiter().GetResult();
+            await app.Run();
         }
         catch (OperationCanceledException ex)
         {
@@ -125,6 +114,4 @@ public static class Program
             loggerMain.LogError(ex.ToStringDemystified());
         }
     }
-
-    
 }

ParadoxSaveParser.WebAPI/README.md

@@ -1,10 +1,15 @@
 # WebAPI
 Simple web application created using DTLib.Web.
 
-# Routes
 
-### POST `/uploadSave/eu4`
+## Important
-- **Request:** `application/octet-stream` - .eu4 file
+Restart web application once per day to delete outdated data and clean RAM.
+
+## Routes
+### POST `/uploadSave`
+- **Query Params:**
+  - `game` - short name of the game (see [../README.md](../README.md))
+- **Request Body:** `application/octet-stream` - .eu4 file
 - **Response:**
     ```json
     { "saveId": "string" }

ParadoxSaveParser.WebAPI/Routes/GetSaveDataHandler.cs

@@ -1,4 +1,5 @@
 using System.Net;
+using ParadoxSaveParser.WebAPI.Database;
 using ParadoxSaveParser.WebAPI.HttpHelpers;
 
 namespace ParadoxSaveParser.WebAPI.Routes;
@@ -18,7 +19,8 @@ internal class GetSaveDataHandler : RouteHandlerBase
             return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken, idOrError.Error!);
         string id = idOrError.Value!;
 
-        if(!Program._saveMetadataStorage.TryGetValue(id, out var meta))
+        var meta = await Program.DB.GetMetadata(id);
+        if(meta is null)
             return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken, 
                 new ErrorMessage(HttpStatusCode.NotFound,
                     $"Save with id {id} not found"));
@@ -27,7 +29,7 @@ internal class GetSaveDataHandler : RouteHandlerBase
                 new ErrorMessage(HttpStatusCode.BadRequest,
                     $"Save with id {id} has status {meta.status}"));
         
-        IOPath dataFilePath = PathHelper.GetParsedSaveFilePath(id);
+        IOPath dataFilePath = meta.GetParsedDataPath();
         if (!File.Exists(dataFilePath))
             return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken,
                 new ErrorMessage(HttpStatusCode.InternalServerError, 

ParadoxSaveParser.WebAPI/Routes/GetSaveStatusHandler.cs

@@ -18,7 +18,8 @@ internal class GetSaveStatusHandler : RouteHandlerBase
             return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken, idOrError.Error!);
         string id = idOrError.Value!;
 
-        if (!Program._saveMetadataStorage.TryGetValue(id, out var meta))
+        var meta = await Program.DB.GetMetadata(id);
+        if (meta is null)
             return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken,
                 new ErrorMessage(HttpStatusCode.InternalServerError, 
                     $"Save with id {id} not found")

ParadoxSaveParser.WebAPI/Routes/UploadSaveHandler.cs

@@ -1,6 +1,8 @@
 using System.Linq;
 using System.Net;
+using System.Reflection.Metadata;
 using ParadoxSaveParser.WebAPI.BackgroundTasks;
+using ParadoxSaveParser.WebAPI.Database;
 using ParadoxSaveParser.WebAPI.HttpHelpers;
 using ParadoxSaveParser.WebAPI.SaveDataFilters;
 
@@ -28,34 +30,28 @@ public class UploadSaveHandler : RouteHandlerBase
         if (contentType != "application/octet-stream")
             return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken,
                     new ErrorMessage(HttpStatusCode.BadRequest,
-                $"Invalid request Content-Type: '{contentType}'")
+                $"Invalid request Content-Type: '{contentType}'"));
-                    );
 
-        string saveId = Guid.NewGuid().ToString();
+        var gameStrOrError = RequestHelper.GetQueryValue(ctx, "game");
-        var metaFilePath = PathHelper.GetMetaFilePath(saveId);
+        if (gameStrOrError.HasError)
-        if (File.Exists(metaFilePath))
+            return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken, gameStrOrError.Error!);
+
+        if (!Enum.TryParse(gameStrOrError.Value, ignoreCase: true, out Game game))
             return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken,
-                    new ErrorMessage(HttpStatusCode.InternalServerError,
+                new ErrorMessage(HttpStatusCode.BadRequest,
-                $"Guid collision! file' {metaFilePath}' already exists.")
+                    $"Invalid requested game: '{gameStrOrError.Value}'"));  
-                    );
+        var meta = await Program.DB.CreateMetadata(game);
 
-        var meta = new SaveFileMetadata
+        var saveFilePath = meta.GetSaveFilePath();
-            { id = saveId, game = Game.EU4, status = SaveFileProcessingStatus.Initialized };
+        await using (var saveFile = File.OpenWrite(saveFilePath))
-        if (!Program._saveMetadataStorage.TryAdd(saveId, meta))
+        {
-            return await ReturnHelper.ResponseError(ctx, requestLogger, _cancelAllToken,
+            await using (var remoteStream = ctx.Request.InputStream)
-                    new ErrorMessage(HttpStatusCode.InternalServerError,
-                $"Guid collision! Can't create metadata with id {saveId}")
-                    );
-
-        meta.status = SaveFileProcessingStatus.Uploading;
-        var saveFilePath = PathHelper.GetSaveFilePath(meta.id);
-        await using var saveFile = File.OpenWrite(saveFilePath);
-        await using var remoteStream = ctx.Request.InputStream;
                 await remoteStream.CopyToAsync(saveFile, _cancelAllToken);
-        meta.status = SaveFileProcessingStatus.Uploaded;
+        }
+        await Program.DB.UpdateMetadataStatus(meta, SaveFileProcessingStatus.Uploaded);
 
         _bgJobManager.StartNewParsingOperation(meta, _saveFilters[meta.game], _cancelAllToken);
-        dynamic responseData = new { saveId };
+        dynamic responseData = new { meta.id };
         return await ReturnHelper.ResponseJson(ctx, requestLogger, _cancelAllToken, responseData);
     }
 }

ParadoxSaveParser.WebAPI/SaveFileMetadata.cs

@@ -1,45 +0,0 @@
-using System.Text.Json.Serialization;
-
-namespace ParadoxSaveParser.WebAPI;
-
-public enum SaveFileProcessingStatus
-{
-    Initialized,
-    Uploading,
-    Uploaded,
-    Parsing,
-    SavingResults,
-    Done
-}
-
-public enum Game
-{
-    Unknown,
-    EU4
-}
-
-public class SaveFileMetadata
-{
-    private static readonly JsonSerializerOptions _configSerializerOptions = new()
-    {
-        WriteIndented = true,
-        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
-    };
-    public required string id { get; init; }
-
-    [JsonConverter(typeof(JsonStringEnumConverter))]
-    public required Game game { get; init; }
-
-    [JsonConverter(typeof(JsonStringEnumConverter))]
-    public required SaveFileProcessingStatus status { get; set; }
-    
-    // if error occured during parsing, it's message is saved here
-    // status stays the same as when error occured
-    public string? errorMessage { get; set; }
-
-    public void SaveToFile()
-    {
-        using var metaFile = File.OpenWrite(PathHelper.GetMetaFilePath(id));
-        JsonSerializer.Serialize(metaFile, this, _configSerializerOptions);
-    }
-}

TODO.md

@@ -1,8 +1,3 @@
-## WebAPI:
-	Temp files management system
-	Database to store metadata (SQLite-Net Extensions)
-
 ## WebAPI.SaveParsingOperation:
-	Add debug log
 	Save parsed data in protobuf
 	Re-parse if saved data was parsed with another query