Refactored property parsing

src/Sidekick.Apis.Poe/Authentication/IAuthenticationService.cs

@@ -1,5 +1,3 @@
-using Sidekick.Common.Initialization;
-
 namespace Sidekick.Apis.Poe.Authentication
 {
     public interface IAuthenticationService

src/Sidekick.Apis.Poe/Clients/States/ApiState.cs

@@ -1,5 +1,3 @@
-using Sidekick.Common.Enums;
-
 namespace Sidekick.Apis.Poe.Clients.States
 {
     public enum ApiState

src/Sidekick.Apis.Poe/Filters/FilterProvider.cs

@@ -1,6 +1,5 @@
 using Sidekick.Apis.Poe.Clients;
 using Sidekick.Apis.Poe.Filters.Models;
-using Sidekick.Apis.Poe.Items.Models;
 using Sidekick.Common.Cache;
 using Sidekick.Common.Enums;
 using Sidekick.Common.Extensions;

src/Sidekick.Apis.Poe/IItemStaticDataProvider.cs

@@ -7,6 +7,6 @@ public interface IItemStaticDataProvider : IInitializableService
     {
         string? GetImage(string id);
 
-        string? GetId(Header header);
+        string? GetId(ItemHeader itemHeader);
     }
 }

src/Sidekick.Apis.Poe/ITradeFilterService.cs

@@ -1,3 +1,4 @@
+using Sidekick.Apis.Poe.Parser.Properties.Filters;
 using Sidekick.Apis.Poe.Trade.Models;
 using Sidekick.Common.Game.Items;
 

src/Sidekick.Apis.Poe/ITradeSearchService.cs

@@ -1,3 +1,4 @@
+using Sidekick.Apis.Poe.Parser.Properties.Filters;
 using Sidekick.Apis.Poe.Trade.Models;
 using Sidekick.Apis.Poe.Trade.Results;
 using Sidekick.Common.Game;

src/Sidekick.Apis.Poe/Items/ApiItemConstants.cs

@@ -4,7 +4,7 @@ namespace Sidekick.Apis.Poe.Items;
 
 public class ApiItemConstants
 {
-    public static Dictionary<string, (Category Category, bool UseRegex)> Poe1Categories = new()
+    public static readonly Dictionary<string, (Category Category, bool UseRegex)> Poe1Categories = new()
     {
         { "accessory", (Category.Accessory, true) },
         { "armour", (Category.Armour, true) },
@@ -26,7 +26,7 @@ public class ApiItemConstants
         { "corpse", (Category.Corpse, true) },
     };
 
-    public static Dictionary<string, (Category Category, bool UseRegex)> Poe2Categories = new()
+    public static readonly Dictionary<string, (Category Category, bool UseRegex)> Poe2Categories = new()
     {
         { "accessory", (Category.Accessory, true) },
         { "armour", (Category.Armour, true) },

src/Sidekick.Apis.Poe/Items/Models/ApiItem.cs

@@ -29,7 +29,7 @@ public class ApiItem
     [JsonIgnore]
     public bool IsUnique => Flags?.Unique ?? false;
 
-    public Header ToHeader()
+    public ItemHeader ToHeader()
     {
         var categoryRarity = Category switch
         {
@@ -39,15 +39,15 @@ public Header ToHeader()
             _ => Rarity.Unknown
         };
 
-        return new Header()
+        return new ItemHeader()
         {
             Name = Name,
-            Type = Text ?? Type,
+            Type = Type,
             ApiItemId = Id ?? string.Empty,
             ApiName = Name,
             ApiType = Type,
-            ApiText = Text,
             ApiDiscriminator = Discriminator,
+            ApiText = Text,
             Game = Game,
             Category = Category ?? Common.Game.Items.Category.Unknown,
             Rarity = IsUnique ? Rarity.Unique : categoryRarity,

src/Sidekick.Apis.Poe/Parser/Headers/HeaderParser.cs

@@ -7,7 +7,6 @@
 using Sidekick.Apis.Poe.Items;
 using Sidekick.Apis.Poe.Items.Models;
 using Sidekick.Apis.Poe.Parser.Headers.Models;
-using Sidekick.Apis.Poe.Parser.Patterns;
 using Sidekick.Common.Extensions;
 using Sidekick.Common.Game;
 using Sidekick.Common.Game.Items;
@@ -205,7 +204,7 @@ private void InitializeRarityPatterns()
         };
     }
 
-    public Header Parse(ParsingItem parsingItem)
+    public ItemHeader Parse(ParsingItem parsingItem)
     {
         var rarity = ParseRarity(parsingItem);
 
@@ -231,7 +230,7 @@ public Header Parse(ParsingItem parsingItem)
         }
 
         var apiItem = ParseApiItem(rarity, name, type);
-        var header = apiItem?.ToHeader() ?? new Header();
+        var header = apiItem?.ToHeader() ?? new ItemHeader();
         header.Name = name;
         header.Type = type;
         header.ItemCategory = ParseItemCategory(parsingItem);

src/Sidekick.Apis.Poe/Parser/Headers/IHeaderParser.cs

@@ -5,5 +5,5 @@ namespace Sidekick.Apis.Poe.Parser.Headers;
 
 public interface IHeaderParser : IInitializableService
 {
-    Header Parse(ParsingItem parsingItem);
+    ItemHeader Parse(ParsingItem parsingItem);
 }

src/Sidekick.Apis.Poe/Parser/ItemParser.cs

@@ -1,12 +1,11 @@
-using System.Text.RegularExpressions;
 using Microsoft.Extensions.Logging;
 using Sidekick.Apis.Poe.Items;
 using Sidekick.Apis.Poe.Parser.AdditionalInformation;
 using Sidekick.Apis.Poe.Parser.Headers;
 using Sidekick.Apis.Poe.Parser.Modifiers;
-using Sidekick.Apis.Poe.Parser.Patterns;
 using Sidekick.Apis.Poe.Parser.Properties;
 using Sidekick.Apis.Poe.Parser.Pseudo;
+using Sidekick.Apis.Poe.Parser.Requirements;
 using Sidekick.Apis.Poe.Parser.Sockets;
 using Sidekick.Common.Exceptions;
 using Sidekick.Common.Game.Items;
@@ -18,7 +17,7 @@ public class ItemParser
     ILogger<ItemParser> logger,
     IModifierParser modifierParser,
     IPseudoParser pseudoParser,
-    IParserPatterns patterns,
+    IRequirementsParser requirementsParser,
     ClusterJewelParser clusterJewelParser,
     IApiInvariantItemProvider apiInvariantItemProvider,
     ISocketParser socketParser,
@@ -47,24 +46,22 @@ public Item ParseItem(string itemText)
                 throw new UnparsableException();
             }
 
-            Header? invariant = null;
+            ItemHeader? invariant = null;
             if (parsingItem.Header.ApiItemId != null && apiInvariantItemProvider.IdDictionary.TryGetValue(parsingItem.Header.ApiItemId, out var invariantMetadata))
             {
                 invariant = invariantMetadata.ToHeader();
             }
 
             // Order of parsing is important
-            ParseRequirements(parsingItem);
-
-            var influences = ParseInfluences(parsingItem);
+            requirementsParser.Parse(parsingItem);
             var sockets = socketParser.Parse(parsingItem);
-            var modifierLines = ParseModifiers(parsingItem);
-            var properties = propertyParser.Parse(parsingItem, modifierLines);
+            var properties = propertyParser.Parse(parsingItem);
+            var modifierLines = modifierParser.Parse(parsingItem);
+            propertyParser.ParseAfterModifiers(parsingItem, properties, modifierLines);
             var pseudoModifiers = pseudoParser.Parse(modifierLines);
             var item = new Item(invariant: invariant,
-                                header: parsingItem.Header,
-                                properties: properties,
-                                influences: influences,
+                                itemHeader: parsingItem.Header,
+                                itemProperties: properties,
                                 sockets: sockets,
                                 modifierLines: modifierLines,
                                 pseudoModifiers: pseudoModifiers,
@@ -83,53 +80,4 @@ public Item ParseItem(string itemText)
             throw;
         }
     }
-
-    private void ParseRequirements(ParsingItem parsingItem)
-    {
-        foreach (var block in parsingItem.Blocks.Where(x => !x.Parsed))
-        {
-            if (!block.TryParseRegex(patterns.Requirements, out _))
-            {
-                continue;
-            }
-
-            block.Parsed = true;
-            return;
-        }
-    }
-
-    private Influences ParseInfluences(ParsingItem parsingItem)
-    {
-        return parsingItem.Header?.Category switch
-        {
-            Category.Accessory or Category.Armour or Category.Weapon => new Influences()
-            {
-                Crusader = GetBool(patterns.Crusader, parsingItem),
-                Elder = GetBool(patterns.Elder, parsingItem),
-                Hunter = GetBool(patterns.Hunter, parsingItem),
-                Redeemer = GetBool(patterns.Redeemer, parsingItem),
-                Shaper = GetBool(patterns.Shaper, parsingItem),
-                Warlord = GetBool(patterns.Warlord, parsingItem),
-            },
-            _ => new Influences(),
-        };
-    }
-
-    private List<ModifierLine> ParseModifiers(ParsingItem parsingItem)
-    {
-        return parsingItem.Header?.Category switch
-        {
-            Category.DivinationCard or Category.Gem => new(),
-            _ => modifierParser.Parse(parsingItem),
-        };
-    }
-
-    #region Helpers
-
-    private static bool GetBool(Regex pattern, ParsingItem parsingItem)
-    {
-        return parsingItem.TryParseRegex(pattern, out _);
-    }
-
-    #endregion Helpers
 }

src/Sidekick.Apis.Poe/Parser/Modifiers/ModifierParser.cs

@@ -20,6 +20,11 @@ IFuzzyService fuzzyService
         /// <inheritdoc/>
         public List<ModifierLine> Parse(ParsingItem parsingItem)
         {
+            if (parsingItem.Header?.Category is Category.DivinationCard or Category.Gem)
+            {
+                return [];
+            }
+
             var modifierLines = new List<ModifierLine>();
 
             foreach (var match in MatchModifiers(parsingItem))

src/Sidekick.Apis.Poe/Parser/ParsingItem.cs

@@ -26,7 +26,7 @@ public ParsingItem(string text)
                 .ToList();
         }
 
-        public Header? Header { get; set; }
+        public ItemHeader? Header { get; set; }
 
         /// <summary>
         /// Item sections seperated by dashes when copying an item in-game.

src/Sidekick.Apis.Poe/Parser/Properties/Definitions/AreaLevelProperty.cs

@@ -0,0 +1,49 @@
+using System.Text.RegularExpressions;
+using Sidekick.Apis.Poe.Parser.Properties.Filters;
+using Sidekick.Apis.Poe.Trade.Requests.Filters;
+using Sidekick.Common.Game.Items;
+using Sidekick.Common.Game.Languages;
+
+namespace Sidekick.Apis.Poe.Parser.Properties.Definitions;
+
+public class AreaLevelProperty(IGameLanguageProvider gameLanguageProvider) : PropertyDefinition
+{
+    private Regex? Pattern { get; set; }
+
+    public override List<Category> ValidCategories { get; } = [Category.Sanctum, Category.Logbook, Category.Contract, Category.Map];
+
+    public override void Initialize()
+    {
+        Pattern = gameLanguageProvider.Language.DescriptionAreaLevel.ToRegexIntCapture();
+    }
+
+    public override void Parse(ItemProperties itemProperties, ParsingItem parsingItem)
+    {
+        var propertyBlock = parsingItem.Blocks[1];
+        itemProperties.AreaLevel = GetInt(Pattern, propertyBlock);
+        if (itemProperties.AreaLevel > 0) propertyBlock.Parsed = true;
+    }
+
+    public override BooleanPropertyFilter? GetFilter(Item item, double normalizeValue)
+    {
+        if (item.Properties.AreaLevel <= 0) return null;
+
+        var filter = new IntPropertyFilter(this)
+        {
+            Text = gameLanguageProvider.Language.DescriptionAreaLevel,
+            NormalizeEnabled = false,
+            NormalizeValue = normalizeValue,
+            Value = item.Properties.AreaLevel,
+            Checked = true,
+        };
+        filter.NormalizeMinValue();
+        return filter;
+    }
+
+    public override void PrepareTradeRequest(SearchFilters searchFilters, Item item, BooleanPropertyFilter filter)
+    {
+        if (!filter.Checked || filter is not IntPropertyFilter intFilter) return;
+
+        searchFilters.GetOrCreateMapFilters().Filters.AreaLevel = intFilter.Checked ? new StatFilterValue(intFilter) : null;
+    }
+}