Taxonomy.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using Contentstack.Core.Configuration;
using Contentstack.Core.Internals;
using Newtonsoft.Json.Linq;

namespace Contentstack.Core.Models
{
    public class Taxonomy: Query
    {

        #region Internal Variables
        private Dictionary<string, object> _ObjectAttributes = new Dictionary<string, object>();
        private Dictionary<string, object> _Headers = new Dictionary<string, object>();
        private Dictionary<string, object> _StackHeaders = new Dictionary<string, object>();
        private Dictionary<string, object> UrlQueries = new Dictionary<string, object>();

        protected override string _Url
        {
            get
            {
                if (this.Stack == null)
                {
                    throw new TaxonomyException("Taxonomy Stack instance is null. Please ensure the Taxonomy is properly initialized with a ContentstackClient instance.");
                }
                if (this.Stack.Config == null)
                {
                    throw new TaxonomyException("Taxonomy Stack Config is null. Please ensure the ContentstackClient is properly configured.");
                }
                Config config = this.Stack.Config;
                return String.Format("{0}/taxonomies/entries", config.BaseUrl);
            }
        }
        #endregion
        public ContentstackClient Stack
        {
            get;
            set;
        }

       
        #region Internal Constructors

        internal Taxonomy()
        {
        }
        internal Taxonomy(ContentstackClient stack): base(stack)
        {
            if (stack == null)
            {
                throw new TaxonomyException("ContentstackClient instance cannot be null when creating a Taxonomy instance.");
            }
            this.Stack = stack;
            this._StackHeaders = stack._LocalHeaders;
        }

        #endregion
        #region Public Functions

        /// <summary>
        /// Add a constraint to the query that requires a particular key entry to be less than the provided value.
        /// </summary>
        /// <param name="key">the key to be constrained.</param>
        /// <param name="value">the value that provides an upper bound.</param>
        /// <returns>Current instance of Query, this will be useful for a chaining calls.</returns>
        /// <example>
        /// <code>
        ///     ContentstackClient stack = new ContentstackClinet("api_key", "delivery_token", "environment");
        ///     Query csQuery = stack.ContentType("contentType_id").Query();
        ///     
        ///     csQuery.LessThan("due_date", "2013-06-25T00:00:00+05:30");
        ///     csQuery.Find<Product>().ContinueWith((queryResult) => {
        ///         //Your callback code.
        ///     });
        /// </code>
        /// </example>
        public Taxonomy Above(String key, Object value)
        {
            if (key != null && value != null)
            {
                try
                {
                    Dictionary<string, object> queryValue = new Dictionary<string, object>{ { "$above", value } };
                    QueryValueJson.Add(key, queryValue);
                } catch (Exception e) {
                    throw TaxonomyException.CreateForProcessingError(e);
                }
            }
            else
            {
                throw TaxonomyException.CreateForProcessingError(null);
            }

            return this;
        }

        /// <summary>
        /// Add a constraint to the query that requires a particular key entry to be less than the provided value.
        /// </summary>
        /// <param name="key">the key to be constrained.</param>
        /// <param name="value">the value that provides an upper bound.</param>
        /// <returns>Current instance of Query, this will be useful for a chaining calls.</returns>
        /// <example>
        /// <code>
        ///     ContentstackClient stack = new ContentstackClinet("api_key", "delivery_token", "environment");
        ///     Query csQuery = stack.ContentType("contentType_id").Query();
        ///     
        ///     csQuery.LessThan("due_date", "2013-06-25T00:00:00+05:30");
        ///     csQuery.Find<Product>().ContinueWith((queryResult) => {
        ///         //Your callback code.
        ///     });
        /// </code>
        /// </example>
        public Taxonomy EqualAndAbove(String key, Object value)
        {
            if (key != null && value != null)
            {
                try
                {
                    Dictionary<string, object> queryValue = new Dictionary<string, object>{ { "$eq_above", value } };
                    QueryValueJson.Add(key, queryValue);
                }
                catch (Exception e)
                {
                    throw TaxonomyException.CreateForProcessingError(e);
                }
            }
            else
            {
                throw TaxonomyException.CreateForProcessingError(null);
            }

            return this;
        }
        
        /// <summary>
        /// Add a constraint to the query that requires a particular key entry to be less than the provided value.
        /// </summary>
        /// <param name="key">the key to be constrained.</param>
        /// <param name="value">the value that provides an upper bound.</param>
        /// <returns>Current instance of Query, this will be useful for a chaining calls.</returns>
        /// <example>
        /// <code>
        ///     ContentstackClient stack = new ContentstackClinet("api_key", "delivery_token", "environment");
        ///     Query csQuery = stack.ContentType("contentType_id").Query();
        ///     
        ///     csQuery.LessThan("due_date", "2013-06-25T00:00:00+05:30");
        ///     csQuery.Find<Product>().ContinueWith((queryResult) => {
        ///         //Your callback code.
        ///     });
        /// </code>
        /// </example>
        public Taxonomy Below(String key, Object value)
        {
            if (key != null && value != null)
            {
                try
                {
                    Dictionary<string, object> queryValue = new Dictionary<string, object> { { "$below", value } };
                    QueryValueJson.Add(key, queryValue);
                }
                catch (Exception e)
                {
                    throw TaxonomyException.CreateForProcessingError(e);
                }
            }
            else
            {
                throw TaxonomyException.CreateForProcessingError(null);
            }

            return this;
        }
        
        /// <summary>
        /// Add a constraint to the query that requires a particular key entry to be less than the provided value.
        /// </summary>
        /// <param name="key">the key to be constrained.</param>
        /// <param name="value">the value that provides an upper bound.</param>
        /// <returns>Current instance of Query, this will be useful for a chaining calls.</returns>
        /// <example>
        /// <code>
        ///     ContentstackClient stack = new ContentstackClinet("api_key", "delivery_token", "environment");
        ///     Query csQuery = stack.ContentType("contentType_id").Query();
        ///     
        ///     csQuery.LessThan("due_date", "2013-06-25T00:00:00+05:30");
        ///     csQuery.Find<Product>().ContinueWith((queryResult) => {
        ///         //Your callback code.
        ///     });
        /// </code>
        /// </example>
        public Taxonomy EqualAndBelow(String key, Object value)
        {
            if (key != null && value != null)
            {
                try
                {
                    Dictionary<string, object> queryValue = new Dictionary<string, object> { { "$eq_below", value } };
                    QueryValueJson.Add(key, queryValue);
                }
                catch (Exception e)
                {
                    throw TaxonomyException.CreateForProcessingError(e);
                }
            }
            else
            {
                throw TaxonomyException.CreateForProcessingError(null);
            }

            return this;
        }

        #endregion
        #region Private Functions

        private Dictionary<string, object> GetHeader(Dictionary<string, object> localHeader)
        {
            Dictionary<string, object> mainHeader = _StackHeaders;
            Dictionary<string, object> classHeaders = new Dictionary<string, object>();

            if (localHeader != null && localHeader.Count > 0)
            {
                if (mainHeader != null && mainHeader.Count > 0)
                {
                    foreach (var entry in localHeader)
                    {
                        String key = entry.Key;
                        classHeaders.Add(key, entry.Value);
                    }

                    foreach (var entry in mainHeader)
                    {
                        String key = entry.Key;
                        if (!classHeaders.ContainsKey(key))
                        {
                            classHeaders.Add(key, entry.Value);
                        }
                    }

                    return classHeaders;

                }
                else
                {
                    return localHeader;
                }

            }
            else
            {
                return _StackHeaders;
            }
        }
        internal static ContentstackException GetContentstackError(Exception ex)
        {
            Int32 errorCode = 0;
            string errorMessage = string.Empty;
            HttpStatusCode statusCode = HttpStatusCode.InternalServerError;
            ContentstackException contentstackError = new ContentstackException(ex);
            Dictionary<string, object> errors = null;

            try
            {
                System.Net.WebException webEx = ex as System.Net.WebException;
                
                if (webEx != null && webEx.Response != null)
                {
                    using (var exResp = webEx.Response)
                    {
                        var stream = exResp.GetResponseStream();
                        if (stream != null)
                        {
                            using (stream)
                            using (var reader = new StreamReader(stream))
                            {
                                errorMessage = reader.ReadToEnd();
                                
                                if (!string.IsNullOrWhiteSpace(errorMessage))
                                {
                                    try
                                    {
                                        JObject data = JObject.Parse(errorMessage.Replace("\r\n", ""));

                                        JToken token = data["error_code"];
                                        if (token != null)
                                            errorCode = token.Value<int>();

                                        token = data["error_message"];
                                        if (token != null)
                                            errorMessage = token.Value<string>();

                                        token = data["errors"];
                                        if (token != null)
                                            errors = token.ToObject<Dictionary<string, object>>();
                                    }
                                    catch (Newtonsoft.Json.JsonException)
                                    {
                                        // If JSON parsing fails, use the raw error message
                                        // errorMessage is already set from ReadToEnd()
                                    }
                                }

                                var response = exResp as HttpWebResponse;
                                if (response != null)
                                    statusCode = response.StatusCode;
                            }
                        }
                        else
                        {
                            errorMessage = webEx.Message;
                        }
                    }
                }
                else
                {
                    errorMessage = ex.Message;
                }
            }
            catch
            {
                errorMessage = ex.Message;
            }

            contentstackError = new ContentstackException(errorMessage)
            {
                ErrorCode = errorCode,
                StatusCode = statusCode,
                Errors = errors
            };

            return contentstackError;
        }
        #endregion
    }
}