/// <summary>
        ///     Get transactions information
        /// </summary>
        /// <param name="transactionType">The transaction type</param>
        /// <param name="transactionHash">The transaction hash</param>
        /// <returns>IObservable&lt;Transaction&gt;</returns>
        public IObservable <Transaction> SearchTransactions(TransactionGroupType transactionType, string transactionHash)
        {
            //if (transactionType == null) throw new ArgumentException(nameof(transactionType));
            if (transactionHash == null)
            {
                throw new ArgumentException(nameof(transactionHash));
            }

            var route = $"{BasePath}/transactions/{transactionType}/{transactionHash}";

            return(Observable.FromAsync(async ar => await route.GetJsonAsync <JObject>())
                   .Select(t => new TransactionMapping().Apply(t)));
        }
        /// <summary>
        ///     Returns transactions information for a given array of transactionIds
        /// </summary>
        /// <param name="transactionHashes">Transaction hashes</param>
        /// <returns>IObservable&lt;List&lt;Transaction&gt;&gt;</returns>
        public IObservable <List <Transaction> > GetTransactions(List <string> transactionHashes, TransactionGroupType group)
        {
            if (transactionHashes.Count < 0)
            {
                throw new ArgumentNullException(nameof(transactionHashes));
            }

            var hashes = new TransactionIds
            {
                _TransactionIds = transactionHashes
            };

            var route = $"{BasePath}/transactions/{group}";

            return(Observable.FromAsync(async ar => await route.PostJsonAsync(hashes).ReceiveJson <List <JObject> >())
                   .Select(h => h.Select(t => new TransactionMapping().Apply(t)).ToList()));
        }
        /// <summary>
        ///     Get transactions information
        /// </summary>
        /// <param name="transactionType">The transaction group type</param>
        /// <param name="query">The query params</param>
        /// <returns>IObservable&lt;TransactionSearch&gt;</returns>
        public IObservable <TransactionSearch> SearchTransactions(TransactionGroupType transactionType, TransactionQueryParams query = null)
        {
            var route = $"{BasePath}/transactions/{transactionType}";

            if (query != null)
            {
                if (query.PageSize > 0)
                {
                    if (query.PageSize < 10)
                    {
                        route = route.RemoveQueryParam("pageSize");
                    }
                    else if (query.PageSize > 100)
                    {
                        route = route.SetQueryParam("pageSize", 100);
                    }
                }
                if (query.Type != 0)
                {
                    route = route.SetQueryParam("type", query.Type);
                }
                if (query.Embedded != false)
                {
                    route = route.SetQueryParam("embedded", query.Embedded);
                }
                if (query.PageNumber <= 0)
                {
                    route = route.SetQueryParam("pageNumber", 1);
                }

                if (query.Height > 0)
                {
                    if (query.ToHeight > 0)
                    {
                        route = route.RemoveQueryParam("toheight");
                    }
                    if (query.FromHeight > 0)
                    {
                        route = route.RemoveQueryParam("fromHeight");
                    }
                }
                if (query.Address != null)
                {
                    if (query.RecipientAddress != null)
                    {
                        route = route.RemoveQueryParam("recipientAddress");
                    }
                    if (query.SignerPublicKey != null)
                    {
                        route = route.RemoveQueryParam("signerPublicKey");
                    }
                }

                switch (query.Order)
                {
                case Order.ASC:
                    route = route.SetQueryParam("ordering", "id");
                    route = route.SetQueryParam("block", "meta.height");

                    break;

                case Order.DESC:
                    route = route.SetQueryParam("ordering", "-id");
                    route = route.SetQueryParam("block", "meta.height");
                    break;

                default:
                    route = route.SetQueryParam("ordering", "-id");
                    route = route.SetQueryParam("block", "meta.height");
                    break;
                }
            }
            return(Observable.FromAsync(async ar => await route.GetJsonAsync <JObject>()).Select(t => TransactionSearchMapping.Apply(t)));
        }
        private List <TransactionGroupNode> FillTransactionGroupList(List <TransactionGroup> list, int?parentId, TransactionGroupType type, bool isExpanded)
        {
            List <TransactionGroupNode> result = null;

            foreach (var item in list.Where(x => x.TypeId == type && x.ParentId == parentId))
            {
                if (result == null)
                {
                    result = new List <TransactionGroupNode>();
                }
                result.Add(new TransactionGroupNode
                {
                    Item       = item,
                    Members    = FillTransactionGroupList(list, item.TransactionGroupId, type, isExpanded),
                    IsExpanded = isExpanded
                });
            }

            return(result);
        }