/**
* @fileOverview     Contensis Search API objects required to query a Contensis repository.
* @requires         Depends on jQuery for the NodeFinder.Find callback
*/

/** 
* Contensis API namespace
*
* @namespace 
*/
(function (Contensis) {
    // Core settings, overridable for CORS.
    Contensis.baseUrl = '';
    Contensis.currentUser = { Id: 0 };
    Contensis.currentContext = { page: { languageId: 1 } };

    /** 
    * Encapsulates all REST related API functions.
    *
    * @namespace
    * @name Contensis.Rest 
    */
    Contensis.Rest = (function ($) {

        var NODE_REST_URL = '/api/Nodes/';
        var TAXONOMY_REST_URL = '/api/Taxonomy/';

        var buildUrl = function (path) {
            var baseUrl = Contensis.baseUrl;

            // If there is a trailing '/', then remove it.
            if (baseUrl.indexOf('/', baseUrl.length - 1) !== -1) {
                baseUrl = baseUrl.substring(0, baseUrl.length - 1);
            }

            return baseUrl + path;
        }

        var getNodes = function (query, options) {

            if (typeof options === 'undefined') {
                options = null;
            }

            // We don't want these properties included in serialisation, but we want to maintain the values in memory in the original.
            var expressionTreeCopy = jQuery.extend(true, {}, query.expressionTree);
            delete expressionTreeCopy.startIndex;
            delete expressionTreeCopy.selectCount;

            var selectCountOption = options != null && options.hasOwnProperty('selectCount') ? options.selectCount : 0;
            var startIndexOption = options != null && options.hasOwnProperty('startIndex') ? options.startIndex : 0;

            var searchObject = {
                startPath: options && options.startPath ? options.startPath : null,
                selectCount: query.expressionTree.selectCount || selectCountOption,
                startIndex: query.expressionTree.startIndex || startIndexOption,
                enableInflections: options && options.hasOwnProperty('enableInflections') ? options.enableInflections : true,
                enablePartialWords: options && options.hasOwnProperty('enablePartialWords') ? options.enablePartialWords : true,
                query: expressionTreeCopy,
                includeNodeData: options && options.includeNodeData ? options.includeNodeData : false,
                excludeEmptyNodeData: options && options.hasOwnProperty('excludeEmptyNodeData') ? options.excludeEmptyNodeData : false
            };

            return ajax(buildUrl(NODE_REST_URL), toJson(searchObject, true), 'POST');
        };

        var getNode = function (id, options) {
            return ajax(buildUrl(NODE_REST_URL + id), options, 'GET', options.async);
        }

        var getNodeData = function (options) {
            return ajax(buildUrl(NODE_REST_URL + options.data.id + '/data/' + options.data.name), options.data, 'GET', options.async);
        };

        var getRelatedNodesByNodeId = function (nodeId) {
            var url = buildUrl(NODE_REST_URL + nodeId + "/RelatedNodes/");
            return ajax(url, "", "GET", false);
        };

        var getRelationshipCategories = function (nodeId) {
            var url = buildUrl(NODE_REST_URL + nodeId + "/RelationshipCategories/");
            return ajax(url, "", "GET", false);
        };

        var getRelationshipCategoriesById = function (nodeId, id) {
            var url = buildUrl(NODE_REST_URL + nodeId + "/RelationshipCategories/" + id);
            return ajax(url, "", "GET", false);
        };

        var getRelationshipCategoriesByRelationshipType = function (nodeId, relationshipType) {
            var url = buildUrl(NODE_REST_URL + nodeId + "/RelationshipCategories/Type/" + relationshipType);
            return ajax(url, "", "GET", false);
        };

        var getRelationshipCategoriesByRelationshipCategoryName = function (nodeId, relationshipCategoryName) {
            var url = buildUrl(NODE_REST_URL + nodeId + "/RelationshipCategories/Name/" + relationshipCategoryName);
            return ajax(url, "", "GET", false);
        };

        var getRelatedNodesByRelationshipCategoryName = function (nodeId, relationshipCategoryName) {
            var url = buildUrl(NODE_REST_URL + nodeId + "/RelatedNodes/" + relationshipCategoryName);
            return ajax(url, "", "GET", false);
        };

        var getRelatedNodesByRelationshipType = function (nodeId, relationshipType) {
            var url = buildUrl(NODE_REST_URL + nodeId + "/" + relationshipType + "/RelatedNodes/");
            return ajax(url, "", "GET", false);
        };

        var getTaxonomyNodeByKey = function (key, sort) {

            // Remove leading '/' if present.
            if (key.lastIndexOf('/', 0) === 0) {
                key = key.substring(1);
            }

            var url = buildUrl(TAXONOMY_REST_URL + "key/" + key);

            if (sort) {
                url += "?sort=" + sort;
            }

            return ajax(url, "", "GET", false);
        };

        var getTaxonomyNodeByPath = function (path, sort) {

            // Remove leading '/' if present.
            if (path.lastIndexOf('/', 0) === 0) {
                path = path.substring(1);
            }

            var url = buildUrl(TAXONOMY_REST_URL + "path/" + path);

            if (sort) {
                url += "?sort=" + sort;
            }

            return ajax(url, "", "GET", false);
        };

        var getRootTaxonomyNode = function (sort) {
            var url = buildUrl(TAXONOMY_REST_URL + "root");

            if (sort) {
                url += "?sort=" + sort;
            }

            return ajax(url, "", "GET", false);
        };

        var ajax = function (url, data, method, async) {

            var crossDomain = (Contensis.baseUrl && Contensis.baseUrl.length > 0);

            // Only invoke for cross-domain and IE 8/9
            if (crossDomain && window.XDomainRequest) {
                var deferred = jQuery.Deferred();

                var xdr = new XDomainRequest();
                xdr.open(method, setXdrParams(url));
                xdr.ontimeout = function () {
                    deferred.reject('Request timed out');
                };
                xdr.onerror = function (err) {
                    deferred.reject('Request error: ' + err);
                };
                xdr.onload = function () {
                    deferred.resolve(JSON.parse(xdr.responseText));
                }
                setTimeout(function () { xdr.send(data); }, 0);
                return deferred.promise();

            } else {
                async = (async === void 0) ? true : !!async;

                if (!Contensis.Rest.enableSynchronousRequests) async = true;
                return $.ajax({
                    url: url,
                    async: async,
                    type: method,
                    crossDomain: crossDomain,
                    data: data,
                    dataType: "json",
                    contentType: 'application/json; charset=utf-8',
                    beforeSend: function (xhr) {
                        setHeaders(xhr);
                    }
                });
            }
        };

        var setXdrParams = function (url) {
            var params = [];
            if (Contensis.currentUser.Id != 0) {
                params.push('X-Contensis-UserId=' + Contensis.currentUser.Id);
            }
            if (Contensis.currentContext.page.languageId != 1) {
                params.push('X-Contensis-LanguageId=' + Contensis.currentContext.page.languageId);
            }
            if (params.length > 0) {
                url += "?" + params.join('&');
            }
            return url;
        }

        var setHeaders = function (xhr) {
            if (Contensis.currentUser.Id != 0) {
                xhr.setRequestHeader("X-Contensis-UserId", Contensis.currentUser.Id);
            }
            if (Contensis.currentContext.page.languageId != 1) {
                xhr.setRequestHeader("X-Contensis-LanguageId", Contensis.currentContext.page.languageId);
            }
        }

        var toJson = function (obj, minify) {
            if (minify) minifyObject(obj);
            return JSON.stringify(obj);
        };

        // Removes all properties that are null, empty or have a default value
        // and removes arrays that are empty.
        var minifyObject = function (obj) {
            var objectIsArray = obj instanceof Array;
            for (var k in obj) {
                if (!obj[k]) {
                    if (objectIsArray) {
                        obj.splice(k, 1);
                    } else {
                        delete obj[k];
                    }
                }
                if (typeof obj[k] == "object") {
                    minifyObject(obj[k]);
                    if (jQuery.isEmptyObject(obj[k]) || obj[k].length === 0) {
                        delete obj[k];
                    }
                }
            }
        };

        return {
            getNodes: getNodes,
            getNode: getNode,
            getNodeData: getNodeData,
            getRelatedNodesByNodeId: getRelatedNodesByNodeId,
            getRelatedNodesByRelationshipCategoryName: getRelatedNodesByRelationshipCategoryName,
            getRelatedNodesByRelationshipType: getRelatedNodesByRelationshipType,
            getRelationshipCategories: getRelationshipCategories,
            getRelationshipCategoriesById: getRelationshipCategoriesById,
            getRelationshipCategoriesByRelationshipType: getRelationshipCategoriesByRelationshipType,
            getRelationshipCategoriesByRelationshipCategoryName: getRelationshipCategoriesByRelationshipCategoryName,
            getTaxonomyNodeByKey: getTaxonomyNodeByKey,
            getTaxonomyNodeByPath: getTaxonomyNodeByPath,
            getRootTaxonomyNode: getRootTaxonomyNode,
            enableSynchronousRequests: true
        };

    }(window.jQuery));

    /** 
    * Encapsulates all Taxonomy related API functions.
    *
    * @namespace
    * @name Contensis.Taxonomy 
    */
    Contensis.Taxonomy = Contensis.Taxonomy || (function ($) {

        var getByKey = function (key, sort) {
            return Contensis.Rest.getTaxonomyNodeByKey(key, sort);
        };

        var getByPath = function (path, sort) {
            return Contensis.Rest.getTaxonomyNodeByPath(path, sort);
        };

        var getRoot = function (sort) {
            return Contensis.Rest.getRootTaxonomyNode(sort);
        };

        return {
            getRoot: getRoot,
            getByKey: getByKey,
            getByPath: getByPath
        };

    })(window.jQuery);

    /** 
    * Encapsulates all Node Relationship related API functions.
    *
    * @namespace
    * @name Contensis.Relationships 
    */
    Contensis.Relationships = Contensis.Relationships || (function ($) {

        var getRelatedNodesByNodeId = function (nodeId) {
            return Contensis.Rest.getRelatedNodesByNodeId(nodeId);
        };

        var getRelatedNodesByRelationshipCategoryName = function (nodeId, relationshipCategoryName) {
            return Contensis.Rest.getRelatedNodesByRelationshipCategoryName(nodeId, relationshipCategoryName);
        };

        var getRelatedNodesByRelationshipType = function (nodeId, relationshipType) {
            return Contensis.Rest.getRelatedNodesByRelationshipType(nodeId, relationshipType);
        };

        var getRelationshipCategories = function (nodeId) {
            return Contensis.Rest.getRelationshipCategories(nodeId);
        };

        var getRelationshipCategoriesById = function (nodeId, id) {
            return Contensis.Rest.getRelationshipCategoriesById(nodeId, id);
        };

        var getRelationshipCategoriesByRelationshipType = function (nodeId, relationshipType) {
            return Contensis.Rest.getRelationshipCategoriesByRelationshipType(nodeId, relationshipType);
        };

        var getRelationshipCategoriesByRelationshipCategoryName = function (nodeId, relationshipCategoryName) {
            return Contensis.Rest.getRelationshipCategoriesByRelationshipCategoryName(nodeId, relationshipCategoryName);
        };

        return {
            getRelatedNodesByNodeId: getRelatedNodesByNodeId,
            getRelatedNodesByRelationshipCategoryName: getRelatedNodesByRelationshipCategoryName,
            getRelatedNodesByRelationshipType: getRelatedNodesByRelationshipType,
            getRelationshipCategoriesById: getRelationshipCategoriesById,
            getRelationshipCategoriesByRelationshipType: getRelationshipCategoriesByRelationshipType,
            getRelationshipCategoriesByRelationshipCategoryName: getRelationshipCategoriesByRelationshipCategoryName,
            getRelationshipCategories: getRelationshipCategories
        };

    })(window.jQuery);

    /** 
    * Encapsulates all Search related API functions.  Ensures that only publicly available classes and methods are exposed
    *
    * @namespace
    * @name Contensis.Search 
    */
    Contensis.Search = Contensis.Search || (function ($) {

        /
        *   Private members
        /

        /** 
        * Determine if object is an array
        *
        * @private
        * @name Contensis.Search.isArray
        * @remarks Rather than having a library dependency for this, I'd implement it locally, 
        *          but longer term we may want to centralise it.
        */
        var isArray = Function.isArray || function (o) {
            return typeof o === "object" &&
            Object.prototype.toString.call(o) === "[object Array]";
        };

        /** 
        * Constants for Conditional Operators
        *
        * @private
        * @enum {Integer} 
        * @name Contensis.Search.ConditionalOperator 
        */
        var ConditionalOperator = {
            Contains: '~',
            DoesNotContain: '!~',
            IsEqualTo: '=',
            IsNotEqualTo: '!=',
            StartsWith: 'StartsWith',
            EndsWith: 'EndsWith',
            GreaterThan: '>',
            LessThan: '<',
            IsGreaterThanOrEqualTo: '>=',
            LessThanOrEqualTo: '<=',
            Between: 'Between',
            NotBetween: 'NotBetween',
            IsEmpty: 'IsEmtpy',
            IsNotEmpty: 'IsNotEmpty',
            IsNull: 'IsNull',
            IsNotNull: 'IsNotNull',
            FullTextContains: 'FullTextContains'
            // NOTE: No custom allowed as it is SQL
        };


        /** 
        * String Constants for Logical Operators
        *
        * @private
        * @enum {Integer} 
        * @name Contensis.Search.LogicalOperator 
        */
        var LogicalOperator = {
            None: null,
            And: 'AND',
            Or: 'OR'
        };

        /** 
        * String Constants for Order By parameters
        *
        * @private
        * @enum {Integer} 
        * @name Contensis.Search.SortDirection 
        */
        var OrderDirection = {
            None: null,
            Ascending: 'ASC',
            Descending: 'DESC'
        };


        /**
        * Extension Object for Node to Enbale Lazy Loading of Node Data
        * 
        * @private
        * @class
        * @name Contensis.Search.DynamicNodeData
        */
        var DynamicNodeData = {
            data: function (name, fetchAll, async, callback) {
                var self = this;
                var defer = $.Deferred();

                fetchAll = (fetchAll === void 0) ? true : fetchAll;
                async = (async === void 0) ? true : async;
                if (self.nodeData) {
                    var result = self.nodeData;
                    if (name) {
                        result = self.nodeData[name.toLowerCase()];
                    }
                    if (!async) {
                        return result;
                    }
                    defer.resolve(result);
                    if (callback) {
                        callback(result);
                    }
                }

                var nodeDataRequest = {
                    id: self.id,
                    name: name ? name.toLowerCase() : '',
                    fetchAll: fetchAll
                };

                var options = {
                    data: nodeDataRequest,
                    async: async
                };

                Contensis.Rest.getNodeData(options)
                    .done(function (result) {
                        var callbackArg = self.nodeData;
                        if (self.nodeData !== null && !fetchAll) {
                            if (name) {
                                self.nodeData[name.toLowerCase()] = result.nodeData[name.toLowerCase()];
                                callbackArg = self.nodeData[name.toLowerCase()];
                            }
                        } else {
                            self.nodeData = result.nodeData;
                        }

                        defer.resolve(callbackArg);

                        if (callback) {
                            callback(callbackArg);
                        }
                    })
                    .fail(function (err) {
                        defer.reject(err);
                    });

                if (!async) {
                    return self.nodeData[name.toLowerCase()];
                }

                return defer.promise();
            }
        };

        var RelatedNodeData = {
            relatedNodes: function (nodeId, async, callback) {
                var self = this;
                var defer = $.Deferred();

                if (self.nodeData !== null && (relatedContentNodes in self.nodeData)) {
                    if (!async) {
                        return self.nodeData[relatedContentNodes];
                    }

                    defer.resolve(self.nodeData[relatedContentNodes]);

                    if (callback) {
                        callback(self.nodeData[relatedContentNodes]);
                    }
                }
                var nodeDataRequest = {
                    id: self.id
                };

                var options = {
                    data: nodeDataRequest,
                    async: async
                };

                Contensis.Rest.getRelatedNodes(options)
                    .done(function (result) {
                        self.nodeData = result.nodeData;
                        defer.resolve(self.nodeData[relatedContentNodes]);

                        if (callback) {
                            callback(self.nodeData[relatedContentNodes]);
                        }
                    })
                    .fail(function (err) {
                        defer.reject(err);
                    });

                if (!async) {
                    return self.nodeData[relatedContentNodes];
                }

                return defer.promise();
            }
        };

        /** 
        * Query instance object.  Is recursively returned to provide chaining of Query operations
        * 
        * @private
        * @class 
        * @name Contensis.Search.QueryImp 
        */
        var QueryImp = function () {

            var _expressionTree = new ExpressionTree(),
                _currentExpression = null;

            // Private functions
            var _and = function (fieldName) {
                _addLogicalCondition(fieldName, LogicalOperator.And);
                return new Condition(this, _currentExpression);
            };

            var _or = function (fieldName) {
                _addLogicalCondition(fieldName, LogicalOperator.Or);
                return new Condition(this, _currentExpression);
            };

            var _andSubQuery = function (subQuery) {
                _addSubQueryLogicalCondition(subQuery, LogicalOperator.And);
                return this;
            };

            var _orSubQuery = function (subQuery) {
                _addSubQueryLogicalCondition(subQuery, LogicalOperator.Or);
                return this;
            };

            var _orderBy = function (fieldName) {
                _expressionTree.orderBy.add(fieldName);
                var _orderedQuery = new OrderedQuery(this);
                return _orderedQuery;
            };

            var _addLogicalCondition = function (fieldName, logicalOperator) {
                _currentExpression = new QueryExpression();
                _currentExpression.name = fieldName;
                _currentExpression.logicalOperator = logicalOperator;
                _expressionTree.add(_currentExpression);
            };

            var _addSubQueryLogicalCondition = function (subQuery, logicalOperator) {

                var _expressions = subQuery.expressionTree.expressions;
                if (_expressions.length > 0) {
                    _expressions[0].logicalOperator = logicalOperator;
                    _currentExpression.subQueryExpressions.push(_expressions);
                }
            };

            var _createWhere = function (fieldName) {

                _currentExpression = new QueryExpression();
                _currentExpression.name = fieldName;
                _expressionTree.add(_currentExpression);
                return new Condition(this, _currentExpression);
            };

            var _createFullTextContains = function (keywords, columns) {
                _weightedColumns = [];

                if (columns === undefined)
                    throw 'You must specify columns to query using Full Text';

                var isValidColumn = function (column) {
                    if (column.columnName === undefined || column.weight === undefined)
                        throw 'Full text contains require valid Column Objects with \'columnName\' and \'weight\' properties.';
                    else
                        return true;
                }

                // make sure each object in the array is a valid Weighted Column
                if (isArray(columns)) {
                    for (var i = columns.length - 1; i >= 0; i--) {
                        if (isValidColumn(columns[i])) {
                            var columnToAdd = new WeightedColumn(columns[i].columnName, columns[i].weight);
                            _weightedColumns.push(columnToAdd);
                        }
                    }
                }
                else if (typeof columns === 'object') {
                    if (isValidColumn(columns)) {
                        var columnToAdd = new WeightedColumn(columns.columnName, columns.weight);
                        _weightedColumns.push(columnToAdd);
                    }
                }

                _currentExpression = new QueryExpression();
                _currentExpression.value = keywords;
                _currentExpression.weightedColumns = _weightedColumns;
                _currentExpression.operator = ConditionalOperator.FullTextContains;
                _expressionTree.add(_currentExpression);

                return this;
            };

            var _skip = function (numberOfItems) {

                _expressionTree.startIndex = numberOfItems;
                return this;
            }

            var _take = function (numberOfItems) {

                _expressionTree.selectCount = numberOfItems;
                return this;
            }

            var _first = function () {

                return this.take(1);
            }

            return {
                and: _and,
                or: _or,
                andSubQuery: _andSubQuery,
                orSubQuery: _orSubQuery,
                skip: _skip,
                take: _take,
                first: _first,
                expressionTree: _expressionTree,
                orderBy: _orderBy,
                createWhere: _createWhere,
                createFullTextContains: _createFullTextContains
            };
        };

        /** 
        * Condition instance object.  Is recursively returned to provide chaining of Condition operations
        * 
        * @private
        * @class 
        * @name Contensis.Search.Condition 
        */
        var Condition = function (q, e) {
            var _query = q, _expression = e;

            // Private functions
            var _contains = function (value) {
                _setExpressionValue(ConditionalOperator.Contains, value);
                return _query;
            };

            var _doesNotContain = function (value) {
                _setExpressionValue(ConditionalOperator.DoesNotContain, value);
                return _query;
            };

            var _endsWith = function (value) {
                _setExpressionValue(ConditionalOperator.EndsWith, value);
                return _query;
            };

            var _fullTextContains = function (value) {
                _setExpressionValue(ConditionalOperator.FullTextContains, value);
                return _query;
            };

            var _isBetween = function (value, value2) {
                _setExpressionValue(ConditionalOperator.Between, value, value2);
                return _query;
            }

            var _isEmpty = function (value) {
                _setExpressionValue(ConditionalOperator.IsEmpty, value);
                return _query;
            };

            var _isEqualTo = function (value) {
                _setExpressionValue(ConditionalOperator.IsEqualTo, value);
                return _query;
            };

            var _isGreaterThan = function (value) {
                _setExpressionValue(ConditionalOperator.GreaterThan, value);
                return _query;
            };

            var _isGreaterThanOrEqualTo = function (value) {
                _setExpressionValue(ConditionalOperator.GreaterThanOrEqualTo, value);
                return _query;
            };

            var _isLessThan = function (value) {
                _setExpressionValue(ConditionalOperator.LessThan, value);
                return _query;
            };

            var _isLessThanOrEqualTo = function (value) {
                _setExpressionValue(ConditionalOperator.LessThanOrEqualTo, value);
                return _query;
            };

            var _isNotEmpty = function (value) {
                _setExpressionValue(ConditionalOperator.IsNotEmpty, value);
                return _query;
            };

            var _isNotEqualTo = function (value) {
                _setExpressionValue(ConditionalOperator.IsNotEqualTo, value);
                return _query;
            };

            var _isNotNull = function (value) {
                _setExpressionValue(ConditionalOperator.IsNotNull, value);
                return _query;
            };

            var _isNull = function (value) {
                _setExpressionValue(ConditionalOperator.IsNull, value);
                return _query;
            };

            var _isNotBetween = function (value, value2) {
                _setExpressionValue(ConditionalOperator.NotBetween, value, value2);
                return _query;
            };

            var _startsWith = function (value) {
                _setExpressionValue(ConditionalOperator.StartsWith, value);
                return _query;
            };

            var _setExpressionValue = function (conditionalOperator, value, value2) {
                _expression.operator = conditionalOperator;

                if (value) _expression.value = value;

                if (value2) _expression.value2 = value2;
            }

            return {
                contains: _contains,
                doesNotContain: _doesNotContain,
                endsWith: _endsWith,
                fullTextContains: _fullTextContains,
                isBetween: _isBetween,
                isEmpty: _isEmpty,
                isEqualTo: _isEqualTo,
                isGreaterThan: _isGreaterThan,
                isGreaterThanOrEqualTo: _isGreaterThanOrEqualTo,
                isLessThan: _isLessThan,
                isLessThanOrEqualTo: _isLessThanOrEqualTo,
                isNotBetween: _isNotBetween,
                isNotEmpty: _isNotEmpty,
                isNotEqualTo: _isNotEqualTo,
                isNotNull: _isNotNull,
                isNull: _isNull,
                startsWith: _startsWith
            }
        };

        /** 
        * Expression Tree object.  Encapsulates an Array of Expressions
        * 
        * @private
        * @class 
        * @name Contensis.Search.ExpressionTree 
        */
        var ExpressionTree = function () {

            var _expressionTree = [],
                _orderByClause = new OrderByClause(),
                _startIndex = 0,
                _selectCount = 0,
                _enableInflections = true,
                _enablePartialWords = false;

            var _add = function (operator, value, value2) {
                _expressionTree.push(operator);
                if (value) _expressionTree.push(value);
                if (value2) _expressionTree.push(value2);
            };

            var _clear = function () {
                _expressionTree.length = 0;
            };

            return {
                add: _add,
                clear: _clear,
                expressions: _expressionTree,
                orderBy: _orderByClause,
                startIndex: _startIndex,
                selectCount: _selectCount,
                enableInflections: _enableInflections,
                enablePartialWords: _enablePartialWords
            };
        };

        /** 
        * Query Expression object.  Encapsulates each Expression
        * 
        * @private
        * @class 
        * @name Contensis.Search.QueryExpression 
        */
        var QueryExpression = function () {
            var _name = '',
                _conditionalOperator = ConditionalOperator.IsEqualTo,
                _logicalOperator = LogicalOperator.None,
                _value = null,
                _value2 = null,
                _subQueryExpressions = [],
                _weightedColumns = [];

            return {
                name: _name,
                operator: _conditionalOperator,
                logicalOperator: _logicalOperator,
                value: _value,
                value2: _value2,
                subQueryExpressions: _subQueryExpressions,
                weightedColumns: _weightedColumns
            };
        };

        /** 
        * WeightedColumn object.  Simple object encapsulating Column names and Weighting 
        * 
        * @private
        * @class 
        * @name Contensis.Search.WeightedColumn 
        */
        var WeightedColumn = function (columnName, weight) {

            var _columnName = columnName,
                _weight = weight;

            return {
                columnName: _columnName,
                weight: _weight
            };
        };

        /** 
        * Order By Clause object.  Encapsulates an array of Order By fields
        * 
        * @private
        * @class 
        * @name Contensis.Search.OrderByClause 
        */
        var OrderByClause = function () {

            var _orderFields = [],
                _lastOrderField;

            var _add = function (fieldName, orderDirection) {
                var _direction = orderDirection ? orderDirection : OrderDirection.None,
                    _orderField = new OrderField(fieldName, _direction);

                _lastOrderField = _orderField;
                _orderFields.push(_orderField);
            };

            var _setOrderDirection = function (orderDirection) {
                _lastOrderField.direction = orderDirection;
            };

            return {
                orderFields: _orderFields,
                add: _add,
                setOrderDirection: _setOrderDirection
            };
        };

        /** 
        * Order By Field object.  Encapsulates the field and Order direction of each parameter
        * 
        * @private
        * @class 
        * @name Contensis.Search.OrderField 
        */
        var OrderField = function (fieldName, direction) {
            var _fieldName = fieldName;
            var _direction = direction == null ? OrderDirection.None : direction;

            return {
                fieldName: _fieldName,
                direction: _direction
            };
        };

        /** 
        * OrderedQuery object.  Encapsulates the Expression object returning only the methods possible on
        * on an Ordered Query
        * 
        * @private
        * @class 
        * @name Contensis.Search.OrderedQuery 
        */
        var OrderedQuery = function (query) {

            var _expressionTree = query.expressionTree;

            var _descending = function () {
                var _extendedOrderedQuery = new ExtendedOrderedQuery(query);

                _expressionTree.orderBy.setOrderDirection(OrderDirection.Descending);
                return _extendedOrderedQuery;
            };

            var _ascending = function () {
                var _extendedOrderedQuery = new ExtendedOrderedQuery(query);

                _expressionTree.orderBy.setOrderDirection(OrderDirection.Ascending);
                return _extendedOrderedQuery;
            };

            var _thenBy = function (fieldName) {
                var _orderedQuery = new OrderedQuery(query);

                _expressionTree.orderBy.add(fieldName);
                return _orderedQuery;
            }

            return {
                descending: _descending,
                ascending: _ascending,
                thenBy: _thenBy,
                expressionTree: _expressionTree
            };
        };

        /** 
        * ExtendedOrderedQuery object.  Encapsulates the Expression object returning only the methods possible on
        * on a Query object that has already had OrderBy called on it.
        * 
        * @private
        * @class 
        * @name Contensis.Search.ExtendedOrderedQuery 
        */
        var ExtendedOrderedQuery = function (query) {

            var _expressionTree = query.expressionTree;

            var _thenBy = function (fieldName) {
                var _orderedQuery = new OrderedQuery(query);

                _expressionTree.orderBy.add(fieldName);
                return _orderedQuery;
            };

            return {
                thenBy: _thenBy,
                expressionTree: _expressionTree
            };
        };

        /
        *   Private Types end
        /

        /
        *   Public Types 
        /
        /** 
        * Query object allows for building of nesting expressions for Querying of a Contensis repository
        * 
        * @public
        * @class 
        * @name Contensis.Search.Query 
        */
        var query = (function () {

            var _where = function (field) {
                return new QueryImp().createWhere(field);
            };

            var _whereFullTextContains = function (keywords, columns) {
                return new QueryImp().createFullTextContains(keywords, columns);
            };

            return {
                where: _where,
                whereFullTextContains: _whereFullTextContains
            };
        }());

        /** 
        * SubQuery object allows for addition of SubQueries in nesting expressions for Querying of a Contensis repository
        * 
        * @public
        * @class 
        * @name Contensis.Search.SubQuery 
        */
        var subQuery = (function () {

            var _where = function (field) {
                return new QueryImp().createWhere(field);
            };

            var _whereFullTextContains = function (keywords, columns) {
                return new QueryImp().createFullTextContains(keywords, columns);
            };

            // Public methods
            return {
                where: _where,
                whereFullTextContains: _whereFullTextContains
            };
        }());

        /** 
        * Nodefinder static object allows for retrieval of ContentNodes from a Contensis repository
        * 
        * @public
        * @class 
        * @name Contensis.Search.NodeFinder 
        */
        var nodeFinder = (function ($) {

            var _find = function (queryObj, options, success, error) {

                return Contensis.Rest.getNodes(queryObj, options)
                .fail(function (err) {
                    if (error) error(err);
                })
                .done(function (result) {
                    for (var n = 0; n < result.nodes.length; n++) {
                        $.extend(result.nodes[n], DynamicNodeData);
                        $.extend(result.nodes[n], RelatedNodeData);
                    }

                    if (success) success(result);
                });
            };

            // Public methods
            return {
                find: _find
            };
        }(window.jQuery));

        var nodeFactory = (function ($) {
            var _loadById = function (id, options, success, error) {
                if (arguments.length > 1) {
                    if (typeof options == 'function') {
                        error = success;
                        success = options;
                        options = {};
                    }
                }

                return Contensis.Rest.getNode(id, options)
                    .fail(function (err) {
                        if (error) error(err);
                    })
                    .done(function (result) {
                        if (result) {
                            $.extend(result, DynamicNodeData);
                            $.extend(result, RelatedNodeData);
                        }
                        if (success) success(result);
                    });
            };

            return {
                loadById: _loadById
            };
        }(window.jQuery));

        /
        *   Public Types end
        /

        // Public Types
        return {
            SubQuery: subQuery,
            Query: query,
            NodeFinder: nodeFinder,
            NodeFactory: nodeFactory
        };

    })(window.jQuery);
}(window.Contensis = window.Contensis || {}));