Merge pull request #47 from contentstack/feat/DX-86-Taxonomy-Implementation

feat: taxonomy implementation with test cases

Author: nadeem-cs

.talismanrc

@@ -10,4 +10,6 @@ fileignoreconfig:
 - filename: Contentstack.Core/Models/Asset.cs
   checksum: 98b819cb9b1e6a9a9e5394ac23c07bc642a41c0c7512d169afc63afe3baa6fb3
 - filename: Contentstack.Core/Models/Query.cs
-  checksum: ceea632e4ea870f35ad3bd313e9f8b4e5ec21aa86f006fca2e0a32945999ba67
+  checksum: ceea632e4ea870f35ad3bd313e9f8b4e5ec21aa86f006fca2e0a32945999ba67
+- filename: Contentstack.Core/Models/Taxonomy.cs
+  checksum: db8bcefdc7aafde4286e7fb6d67348bec49f1ac27b54d84fddca8124135bd779

CHANGELOG.md

@@ -1,3 +1,9 @@
+### Version: 2.15.0
+#### Date: Jul-30-2024
+
+##### New Feature: 
+- Taxonomy class added
+
 ### Version: 2.14.0
 #### Date: May-28-2024
 

Contentstack.Core.Tests/TaxonomyTest.cs

@@ -0,0 +1,178 @@
+using System;
+using Xunit;
+using Contentstack.Core;
+using Contentstack.Core.Configuration;
+using Contentstack.Core.Models;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Linq;
+using Contentstack.Core.Tests.Models;
+using Newtonsoft.Json.Linq;
+using System.Reflection.PortableExecutable;
+
+namespace Contentstack.Core.Tests
+{
+
+    public class TaxonomyTest
+    {
+        ContentstackClient client = StackConfig.GetStack();
+
+        private String numbersContentType = "numbers_content_type";
+        String source = "source";
+
+        public double EPSILON { get; private set; }
+
+        [Fact]
+
+        public async Task TaxonomyExists() 
+        {
+            // Description: Taxonomy Exists - Get Entries With Any Taxonomy Terms ($exists)
+            Taxonomy query = client.Taxonomies();
+            query.Exists("taxonomies.one");
+            var result = await query.Find<Entry>();
+            if (result == null && result.Items.Count() == 0)
+            {
+                Assert.Fail("Query.Exec is not match with expected result.");
+            }
+            else if (result != null)
+            {
+                bool IsTrue = false;
+                foreach (Entry data in result.Items)
+                {
+                    IsTrue = data.GetContentType() != null;
+                    if (!IsTrue)
+                    {
+                        break;
+                    }
+                }
+                Assert.True(IsTrue);
+            }
+            else
+            {
+                Assert.Fail("Result doesn't mathced the count.");
+            }
+        }
+
+        [Fact]
+        public async Task TaxonomyEqualAndBelow()
+        {
+            // Description: Taxonomy EqualAndBelow - Get Entries With Taxonomy Terms and Also Matching Its Children Term ($eq_below, level)
+            Taxonomy query = client.Taxonomies();
+            query.EqualAndBelow("taxonomies.one", "term_one");
+            var result = await query.Find<Entry>();
+            if (result == null && result.Items.Count() == 0)
+            {
+                Assert.Fail("Query.Exec is not match with expected result.");
+            }
+            else if (result != null)
+            {
+                bool IsTrue = false;
+                foreach (Entry data in result.Items)
+                {
+                    IsTrue = data.GetContentType() != null;
+                    if (!IsTrue)
+                    {
+                        break;
+                    }
+                }
+                Assert.True(IsTrue);
+            }
+            else
+            {
+                Assert.Fail("Result doesn't mathced the count.");
+            }
+        }
+
+        [Fact]
+        public async Task TaxonomyBelow()
+        {
+            // Description: Taxonomy Below - Get Entries With Taxonomy Terms Children\'s and Excluding the term itself ($below, level)
+            Taxonomy query = client.Taxonomies();
+            query.Below("taxonomies.one", "term_one");
+            var result = await query.Find<Entry>();
+            if (result == null && result.Items.Count() == 0)
+            {
+                Assert.Fail("Query.Exec is not match with expected result.");
+            }
+            else if (result != null)
+            {
+                bool IsTrue = false;
+                foreach (Entry data in result.Items)
+                {
+                    IsTrue = data.GetContentType() != null;
+                    if (!IsTrue)
+                    {
+                        break;
+                    }
+                }
+                Assert.True(IsTrue);
+            }
+            else
+            {
+                Assert.Fail("Result doesn't mathced the count.");
+            }
+        }
+
+        [Fact]
+        public async Task TaxonomyEqualAndAbove()
+        {
+            // Description: Taxonomy EqualAndAbove - Get Entries With Taxonomy Terms and Also Matching Its Parent Term ($eq_above, level)
+            Taxonomy query = client.Taxonomies();
+            query.EqualAndAbove("taxonomies.one", "term_one");
+            var result = await query.Find<Entry>();
+            if (result == null && result.Items.Count() == 0)
+            {
+                Assert.Fail("Query.Exec is not match with expected result.");
+            }
+            else if (result != null)
+            {
+                bool IsTrue = false;
+                foreach (Entry data in result.Items)
+                {
+                    IsTrue = data.GetContentType() != null;
+                    if (!IsTrue)
+                    {
+                        break;
+                    }
+                }
+                Assert.True(IsTrue);
+            }
+            else
+            {
+                Assert.Fail("Result doesn't mathced the count.");
+            }
+        }
+
+        [Fact]
+        public async Task TaxonomyAbove()
+        {
+            // Description: Taxonomy Above - Get Entries With Taxonomy Terms Parent and Excluding the term itself ($above, level)
+            Taxonomy query = client.Taxonomies();
+            query.Above("taxonomies.one", "term_one");
+            var result = await query.Find<Entry>();
+            if (result == null && result.Items.Count() == 0)
+            {
+                Assert.Fail("Query.Exec is not match with expected result.");
+            }
+            else if (result != null)
+            {
+                bool IsTrue = false;
+                foreach (Entry data in result.Items)
+                {
+                    IsTrue = data.GetContentType() != null;
+                    if (!IsTrue)
+                    {
+                        break;
+                    }
+                }
+                Assert.True(IsTrue);
+            }
+            else
+            {
+                Assert.Fail("Result doesn't mathced the count.");
+            }
+        }
+
+    }
+}
+

Contentstack.Core/ContentstackClient.cs

@@ -409,6 +409,22 @@ public AssetLibrary AssetLibrary()
             return asset;
         }
 
+        /// <summary>
+        /// Represents a Taxonomy. Creates Taxonomy Instance.
+        /// </summary>
+        /// <returns>Current instance of Taxonomy, this will be useful for a chaining calls.</returns>
+        /// <example>
+        /// <code>
+        ///     ContentstackClient stack = new ContentstackClinet(&quot;api_key&quot;, &quot;delivery_token&quot;, &quot;environment&quot;);
+        ///     Taxonomy taxonomy = stack.Taxonomy();
+        /// </code>
+        /// </example>
+        public Taxonomy Taxonomies()
+        {
+            Taxonomy tx = new Taxonomy(this);
+            return tx;
+        }
+
         /// <summary>
         /// Get version.
         /// </summary>

Contentstack.Core/Models/Query.cs

@@ -590,7 +590,6 @@ public Query LessThan(String key, Object value)
         /// </example>
         public Query LessThanOrEqualTo(String key, Object value)
         {
-
             if (key != null && value != null)
             {
 
@@ -745,7 +744,6 @@ public Query NotEqualTo(String key, Object value)
             {
                 throw new Exception(StackConstants.ErrorMessage_QueryFilterException, null);
             }
-
             return this;
 
         }