add support for databases list query params ✨

Author: KoditkarVedant

Src/Notion.Client/DatabaseClient.cs

@@ -1,11 +1,11 @@
+using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace Notion.Client
 {
     public interface IDatabaseClient
     {
-        Task<PaginatedList<Database>> ListAsync();
-
+        Task<PaginatedList<Database>> ListAsync(DatabasesListParameters databasesListParameters = null);
     }
 
     public class DatabaseClient : IDatabaseClient
@@ -17,11 +17,17 @@ public DatabaseClient(IRestClient client)
             _client = client;
         }
 
-        public async Task<PaginatedList<Database>> ListAsync()
+        public async Task<PaginatedList<Database>> ListAsync(DatabasesListParameters databasesListParameters = null)
         {
             try
             {
-                return await _client.GetAsync<PaginatedList<Database>>("databases");
+                var queryParams = new Dictionary<string, string>()
+                {
+                    { "start_cursor", databasesListParameters?.PaginationParameters?.StartCursor },
+                    { "page_size", databasesListParameters?.PaginationParameters?.PageSize }
+                };
+
+                return await _client.GetAsync<PaginatedList<Database>>("databases", queryParams);
             }
             catch (System.Exception e)
             {

Src/Notion.Client/Models/Database.cs

@@ -7,6 +7,11 @@
 
 namespace Notion.Client
 {
+    public class DatabasesListParameters
+    {
+        public PaginationParameters PaginationParameters { get; set; }
+    }
+
     public class Database
     {
         public string Object => "database";

Src/Notion.Client/Models/PaginatedList.cs

@@ -3,6 +3,12 @@
 
 namespace Notion.Client
 {
+    public class PaginationParameters
+    {
+        public string StartCursor { get; set; }
+        public string PageSize { get; set; }
+    }
+
     public class PaginatedList<T>
     {
         public const string Object = "List";

Src/Notion.Client/RestClient.cs

@@ -4,12 +4,13 @@
 using System.Net.Http.Headers;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
+using Notion.Client.http;
 
 namespace Notion.Client
 {
     public interface IRestClient
     {
-        Task<T> GetAsync<T>(string uri);
+        Task<T> GetAsync<T>(string uri, Dictionary<string, string> queryParams = null);
     }
 
     public class RestClient : IRestClient
@@ -37,10 +38,12 @@ private static ClientOptions MergeOptions(ClientOptions options)
             };
         }
 
-        public async Task<T> GetAsync<T>(string uri)
+        public async Task<T> GetAsync<T>(string uri, Dictionary<string, string> queryParams = null)
         {
             EnsureHttpClient();
 
+            uri = queryParams == null ? uri : QueryHelpers.AddQueryString(uri, queryParams);
+
             using (var stream = await _httpClient.GetStreamAsync(uri))
             {
                 return SerializerHelper.Deserialize<T>(stream, jsonConverters);

Src/Notion.Client/http/QueryHelpers.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.Encodings.Web;
+
+namespace Notion.Client.http
+{
+    internal static class QueryHelpers
+    {
+        public static string AddQueryString(string uri, string name, string value)
+        {
+            if (uri == null)
+            {
+                throw new ArgumentNullException(nameof(uri));
+            }
+
+            if (name == null)
+            {
+                throw new ArgumentNullException(nameof(name));
+            }
+
+            if (value == null)
+            {
+                throw new ArgumentNullException(nameof(value));
+            }
+
+            return AddQueryString(uri, new[] { new KeyValuePair<string, string>(name, value) });
+        }
+
+        public static string AddQueryString(string uri, IDictionary<string, string> queryParams)
+        {
+            if (uri == null)
+            {
+                throw new ArgumentNullException(nameof(uri));
+            }
+
+            if (queryParams == null)
+            {
+                throw new ArgumentNullException(nameof(queryParams));
+            }
+
+            return AddQueryString(uri, (IEnumerable<KeyValuePair<string, string>>)queryParams);
+        }
+
+        private static string AddQueryString(
+            string uri,
+            IEnumerable<KeyValuePair<string, string>> queryParams)
+        {
+            if (uri == null)
+            {
+                throw new ArgumentNullException(nameof(uri));
+            }
+
+            if (queryParams == null)
+            {
+                throw new ArgumentNullException(nameof(queryParams));
+            }
+
+            queryParams = RemoveEmptyValueQueryParams(queryParams);
+
+            var anchorIndex = uri.IndexOf('#');
+            var uriToBeAppended = uri;
+            var anchorText = "";
+
+            if (anchorIndex != -1)
+            {
+                anchorText = uri.Substring(anchorIndex);
+                uriToBeAppended = uri.Substring(0, anchorIndex);
+            }
+
+            var queryIndex = uriToBeAppended.IndexOf('?');
+            var hasQuery = queryIndex != -1;
+
+            var sb = new StringBuilder();
+            sb.Append(uriToBeAppended);
+            foreach (var parameter in queryParams)
+            {
+                sb.Append(hasQuery ? '&' : '?');
+                sb.Append(UrlEncoder.Default.Encode(parameter.Key));
+                sb.Append('=');
+                sb.Append(UrlEncoder.Default.Encode(parameter.Value));
+                hasQuery = true;
+            }
+
+            sb.Append(anchorText);
+            return sb.ToString();
+        }
+
+        private static IEnumerable<KeyValuePair<string, string>> RemoveEmptyValueQueryParams(IEnumerable<KeyValuePair<string, string>> queryParams)
+        {
+            return queryParams.Where(x => !string.IsNullOrWhiteSpace(x.Value));
+        }
+
+    }
+}