Add EnableResponseCallback

.gitignore

@@ -293,4 +293,5 @@ logs
 wwwroot
 appsettings.Production.json
 *.csproj.user
-env/
+env/
+FodyWeavers.*

src/Infrastructure/BotSharp.Abstraction/BotSharp.Abstraction.csproj

@@ -36,6 +36,7 @@
     <PackageReference Include="System.Text.Json" Version="8.0.4" />
     <PackageReference Include="Serilog.Sinks.Console" Version="5.0.1" />
     <PackageReference Include="Serilog.Sinks.File" Version="5.0.0" />
+    <PackageReference Include="Rougamo.Fody" Version="4.0.0" />
   </ItemGroup>
 
 </Project>

src/Infrastructure/BotSharp.Abstraction/Browsing/IWebPageResponseHook.cs

@@ -4,6 +4,6 @@ namespace BotSharp.Abstraction.Browsing;
 
 public interface IWebPageResponseHook
 {
-    void OnDataFetched(MessageInfo message, string url, string postData, string responsData);
-    T? GetResponse<T>(MessageInfo message, string url, string? queryParameter = null);
+    void OnDataFetched(MessageInfo message, WebPageResponseData response);
+    T? GetResponse<T>(MessageInfo message, WebPageResponseFilter filter);
 }

src/Infrastructure/BotSharp.Abstraction/Browsing/Models/ElementActionArgs.cs

@@ -12,6 +12,11 @@ public class ElementActionArgs
 
     public string? PressKey { get; set; }
 
+    /// <summary>
+    /// Locator option
+    /// </summary>
+    public bool FirstIfMultipleFound { get; set; } = false;
+
     /// <summary>
     /// Wait time in seconds
     /// </summary>

src/Infrastructure/BotSharp.Abstraction/Browsing/Models/ElementLocatingArgs.cs

@@ -26,6 +26,7 @@ public class ElementLocatingArgs
     public bool Parent { get; set; }
 
     public bool FailIfMultiple { get; set; }
+    public bool IgnoreIfNotFound { get; set; }
 
     /// <summary>
     /// Draw outline around the element

src/Infrastructure/BotSharp.Abstraction/Browsing/Models/MessageInfo.cs

@@ -1,11 +1,16 @@
+using BotSharp.Abstraction.Infrastructures;
+
 namespace BotSharp.Abstraction.Browsing.Models;
 
-public class MessageInfo
+public class MessageInfo : ICacheKey
 {
     public string AgentId { get; set; } = null!;
     public string UserId { get; set; } = null!;
     public string ContextId { get; set; } = null!;
     public string? MessageId { get; set; }
     public string? TaskId { get; set; }
     public string StepId { get; set; } = Guid.NewGuid().ToString();
+
+    public string GetCacheKey()
+        => $"{nameof(MessageInfo)}-{ContextId}";
 }

src/Infrastructure/BotSharp.Abstraction/Browsing/Models/PageActionArgs.cs

@@ -15,10 +15,25 @@ public class PageActionArgs
     /// This value has to be set to true if you want to get the page XHR/ Fetch responses
     /// </summary>
     public bool OpenNewTab { get; set; } = false;
+
+    public bool EnableResponseCallback { get; set; } = false;
+
     /// <summary>
     /// Exclude urls for XHR/ Fetch responses
     /// </summary>
     public string[]? ExcludeResponseUrls { get; set; }
+
+    /// <summary>
+    /// Only include urls for XHR/ Fetch responses
+    /// </summary>
+    public string[]? IncludeResponseUrls { get; set; }
+
+    /// <summary>
+    /// If set to true, the response will be stored in memory
+    /// </summary>
+    public bool ResponseInMemory { get; set; } = false;
+    public List<WebPageResponseData>? ResponseContainer { get; set; }
+
     public bool UseExistingPage { get; set; } = false;
 
     public bool WaitForNetworkIdle { get; set; } = true;

src/Infrastructure/BotSharp.Abstraction/Browsing/Models/WebPageResponseData.cs

@@ -0,0 +1,10 @@
+namespace BotSharp.Abstraction.Browsing.Models;
+
+public class WebPageResponseData
+{
+    public string Url { get; set; } = null!;
+    public string PostData { get; set; } = null!;
+    public string ResponseData { get; set; } = null!;
+    public bool ResponseInMemory { get; set; }
+    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+}

src/Infrastructure/BotSharp.Abstraction/Browsing/Models/WebPageResponseFilter.cs

@@ -0,0 +1,7 @@
+namespace BotSharp.Abstraction.Browsing.Models;
+
+public class WebPageResponseFilter
+{
+    public string Url { get; set; } = null!;
+    public string[]? QueryParameters { get; set; }
+}

src/Infrastructure/BotSharp.Abstraction/Infrastructures/ICacheKey.cs

@@ -0,0 +1,6 @@
+namespace BotSharp.Abstraction.Infrastructures;
+
+public interface ICacheKey
+{
+    string GetCacheKey();
+}

src/Infrastructure/BotSharp.Abstraction/Infrastructures/ICacheService.cs

@@ -0,0 +1,8 @@
+namespace BotSharp.Abstraction.Infrastructures;
+
+public interface ICacheService
+{
+    Task<T?> GetAsync<T>(string key);
+    Task<object> GetAsync(string key, Type type);
+    Task SetAsync<T>(string key, T value, TimeSpan? expiry);
+}

src/Infrastructure/BotSharp.Abstraction/Infrastructures/SharpCacheAttribute.cs

@@ -0,0 +1,82 @@
+using BotSharp.Abstraction.Infrastructures;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
+using Rougamo;
+using Rougamo.Context;
+
+namespace BotSharp.Core.Infrastructures;
+
+public class SharpCacheAttribute : MoAttribute
+{
+    public static IServiceProvider Services { get; set; } = null!;
+
+    private int _minutes;
+
+    public SharpCacheAttribute(int minutes = 60)
+    {
+        _minutes = minutes;
+    }
+
+    public override void OnEntry(MethodContext context)
+    {
+        var settings = Services.GetRequiredService<SharpCacheSettings>();
+        if (!settings.Enabled)
+        {
+            return;
+        }
+
+        var cache = Services.GetRequiredService<ICacheService>();
+
+        var key = GetCacheKey(settings, context);
+        var value = cache.GetAsync(key, context.TaskReturnType).Result;
+        if (value != null)
+        {
+            context.ReplaceReturnValue(this, value);
+        }
+    }
+
+    public override void OnSuccess(MethodContext context)
+    {
+        var settings = Services.GetRequiredService<SharpCacheSettings>();
+        if (!settings.Enabled)
+        {
+            return;
+        }
+
+        var httpContext = Services.GetRequiredService<IHttpContextAccessor>();
+        if (httpContext.HttpContext.Response.Headers["Cache-Control"].ToString().Contains("no-store"))
+        {
+            return;
+        }
+
+        var cache = Services.GetRequiredService<ICacheService>();
+
+        if (context.ReturnValue != null)
+        {
+            var key = GetCacheKey(settings, context);
+            cache.SetAsync(key, context.ReturnValue, new TimeSpan(0, _minutes, 0)).Wait();
+        }
+    }
+
+    private string GetCacheKey(SharpCacheSettings settings, MethodContext context)
+    {
+        var key = settings.Prefix + "-" + context.Method.Name;
+        foreach (var arg in context.Arguments)
+        {
+            if (arg is null)
+            {
+                key += "-" + "<NULL>";
+            }
+            else if (arg is ICacheKey withCacheKey)
+            {
+                key += "-" + withCacheKey.GetCacheKey();
+            }
+            else
+            {
+                key += "-" + arg.ToString();
+            }
+        }
+
+        return key;
+    }
+}

src/Infrastructure/BotSharp.Abstraction/Infrastructures/SharpCacheSettings.cs

@@ -0,0 +1,7 @@
+namespace BotSharp.Abstraction.Infrastructures;
+
+public class SharpCacheSettings
+{
+    public bool Enabled { get; set; } = false;
+    public string Prefix { get; set; } = "cache";
+}

src/Infrastructure/BotSharp.Abstraction/Utilities/Pagination.cs

@@ -1,6 +1,8 @@
+using BotSharp.Abstraction.Infrastructures;
+
 namespace BotSharp.Abstraction.Utilities;
 
-public class Pagination
+public class Pagination : ICacheKey
 {
     private int _page;
     private int _size;
@@ -39,6 +41,9 @@ public int Offset
     }
 
     public bool ReturnTotal { get; set; } = true;
+
+    public string GetCacheKey()
+        => $"{nameof(Pagination)}_{_page}_{_size}_{Sort}_{Order}";
 }
 
 public class PagedItems<T>

src/Infrastructure/BotSharp.Core/BotSharp.Core.csproj

@@ -46,10 +46,13 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <Compile Remove="packages\**" />
     <Compile Remove="Planning\**" />
     <Compile Remove="Translation\Models\**" />
+    <EmbeddedResource Remove="packages\**" />
     <EmbeddedResource Remove="Planning\**" />
     <EmbeddedResource Remove="Translation\Models\**" />
+    <None Remove="packages\**" />
     <None Remove="Planning\**" />
     <None Remove="Translation\Models\**" />
   </ItemGroup>

src/Infrastructure/BotSharp.Core/BotSharpCoreExtensions.cs

@@ -1,12 +1,13 @@
-using BotSharp.Abstraction.Functions;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.Configuration;
+using BotSharp.Abstraction.Functions;
 using BotSharp.Core.Plugins;
 using BotSharp.Abstraction.Settings;
 using BotSharp.Abstraction.Options;
 using BotSharp.Abstraction.Messaging.JsonConverters;
 using BotSharp.Abstraction.Users.Settings;
 using BotSharp.Abstraction.Interpreters.Settings;
+using BotSharp.Abstraction.Infrastructures;
 
 namespace BotSharp.Core;
 
@@ -22,8 +23,15 @@ public static IServiceCollection AddBotSharpCore(this IServiceCollection service
 
         services.AddScoped<ISettingService, SettingService>();
         services.AddScoped<IUserService, UserService>();
+
         services.AddSingleton<DistributedLocker>();
 
+        // Register cache service
+        var cacheSettings = new SharpCacheSettings();
+        config.Bind("SharpCache", cacheSettings);
+        services.AddSingleton(x => cacheSettings);
+        services.AddSingleton<ICacheService, CacheService>();
+
         RegisterPlugins(services, config);
         ConfigureBotSharpOptions(services, configOptions);
 
@@ -61,6 +69,9 @@ public static IApplicationBuilder UseBotSharp(this IApplicationBuilder app)
 
         app.ApplicationServices.GetRequiredService<PluginLoader>().Configure(app);
 
+        // Set root services for SharpCacheAttribute
+        SharpCacheAttribute.Services = app.ApplicationServices;
+
         return app;
     }
 

src/Infrastructure/BotSharp.Core/Infrastructures/CacheService.cs

@@ -0,0 +1,74 @@
+using BotSharp.Abstraction.Infrastructures;
+using Newtonsoft.Json;
+using StackExchange.Redis;
+
+namespace BotSharp.Core.Infrastructures;
+
+public class CacheService : ICacheService
+{
+    private readonly BotSharpDatabaseSettings _settings;
+    private static ConnectionMultiplexer redis = null!;
+
+    public CacheService(BotSharpDatabaseSettings settings)
+    {
+        _settings = settings;
+    }
+
+    public async Task<T?> GetAsync<T>(string key)
+    {
+        if (string.IsNullOrEmpty(_settings.Redis))
+        {
+            return default;
+        }
+
+        if (redis == null)
+        {
+            redis = ConnectionMultiplexer.Connect(_settings.Redis);
+        }
+
+        var db = redis.GetDatabase();
+        var value = await db.StringGetAsync(key);
+
+        if (value.HasValue)
+        {
+            return JsonConvert.DeserializeObject<T>(value);
+        }
+
+        return default;
+    }
+
+    public async Task<object> GetAsync(string key, Type type)
+    {
+        if (string.IsNullOrEmpty(_settings.Redis))
+        {
+            return default;
+        }
+
+        if (redis == null)
+        {
+            redis = ConnectionMultiplexer.Connect(_settings.Redis);
+        }
+
+        var db = redis.GetDatabase();
+        var value = await db.StringGetAsync(key);
+
+        if (value.HasValue)
+        {
+            return JsonConvert.DeserializeObject(value, type);
+        }
+
+        return default;
+    }
+
+
+    public async Task SetAsync<T>(string key, T value, TimeSpan? expiry)
+    {
+        if (string.IsNullOrEmpty(_settings.Redis))
+        {
+            return;
+        }
+
+        var db = redis.GetDatabase();
+        await db.StringSetAsync(key, JsonConvert.SerializeObject(value), expiry);
+    }
+}