dashboardv3/public/js/views/search/tree/GlossaryTreeLayoutView.js

/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
define([
    "require",
    "hbs!tmpl/search/tree/GlossaryTreeLayoutView_tmpl",
    "utils/Utils",
    'utils/Messages',
    "utils/Globals",
    "utils/UrlLinks",
    "utils/CommonViewFunction",
    "collection/VSearchList",
    "collection/VGlossaryList",
    "jstree"
], function(require, GlossaryTreeLayoutView_tmpl, Utils, Messages, Globals, UrlLinks, CommonViewFunction, VSearchList, VGlossaryList) {
    "use strict";

    var GlossaryTreeLayoutView = Marionette.LayoutView.extend({
        template: GlossaryTreeLayoutView_tmpl,

        regions: {},
        ui: {
            refreshTree: '[data-id="refreshTree"]',
            termSearchTree: '[data-id="termSearchTree"]',
            createGlossary: '[data-id="createGlossary"]',
            showGlossaryType: '[data-id="showGlossaryType"]',
            importGlossary: "[data-id='importGlossary']",
            downloadTemplate: "[data-id='downloadTemplate']",
            glossaryTreeLoader: ".glossary-tree-loader"
        },
        templateHelpers: function() {
            return {
                apiBaseUrl: UrlLinks.apiBaseUrl,
                importTmplUrl: UrlLinks.glossaryImportTempUrl()
            };
        },
        events: function() {
            var events = {},
                that = this;
            events["click " + this.ui.refreshTree] = function(e) {
                that.changeLoaderState(true);
                that.ui.refreshTree.attr("disabled", true).tooltip("hide");
                var type = $(e.currentTarget).data("type");
                e.stopPropagation();
                that.refresh({ type: type });
            };

            events["click " + this.ui.createGlossary] = function(e) {
                var that = this;
                e.stopPropagation();
                CommonViewFunction.createEditGlossaryCategoryTerm({
                    isGlossaryView: true,
                    collection: that.glossaryCollection,
                    callback: function(rModel) {
                        that.glossaryCollection.fullCollection.add(rModel);
                    },
                    onModalClose: function() {}
                })
            };

            events["click " + this.ui.showGlossaryType] = function(e) {
                var getTreeData, displayText;
                e.stopPropagation();
                this.isTermView = !this.isTermView;
                this.glossarySwitchBtnUpdate();
            };
            events["click " + this.ui.importGlossary] = function(e) {
                e.stopPropagation();
                var $target = $(e.target);
                if ($target.parents(".disable-list-option").length == 0 && $target.hasClass("disable-list-option") == false) {
                    that.onClickImportGlossary();
                }
            };
            events['click ' + this.ui.downloadTemplate] = function(e) {
                e.stopPropagation();
            };
            return events;
        },
        bindEvents: function() {
            var that = this;
            this.listenTo(
                this.glossaryCollection.fullCollection, "reset add change",
                function(skip) {
                    if (this.ui.termSearchTree.jstree(true)) {
                        that.isGlossaryTree = true; //To Keep the selection of Term after any new Glossary is Created.
                        this.ui.termSearchTree.jstree(true).refresh();
                    } else {
                        this.renderGlossaryTree();
                    }
                    that.changeLoaderState();
                    that.ui.refreshTree.attr("disabled", false);
                },
                this
            );
            if (this.options.categoryEvent) {
                this.options.categoryEvent.on("Success:TermRename", function(options) {
                    that.refresh();
                })
            }

            $('body').on('click', '.termPopoverOptions li, .categoryPopoverOptions li', function(e) {
                that.$('.termPopover,.categoryPopover').popover('hide');
                that[$(this).find('a').data('fn')](e)
            });
        },
        glossarySwitchBtnUpdate: function() {
            var tooltipTitle = (this.isTermView ? "Show Category" : "Show Term");
            this.ui.showGlossaryType.attr({ "data-original-title": tooltipTitle, "title": tooltipTitle });
            this.ui.showGlossaryType.tooltip('hide');
            this.ui.showGlossaryType.find("i").toggleClass("switch-button");
            if (this.isTermView) {
                this.ui.importGlossary.removeClass("disable-list-option").find('a').attr("href", "javascript:void(0)");
                this.ui.downloadTemplate.removeClass("disable-list-option").find('a').attr("href", UrlLinks.glossaryImportTempUrl());
            } else {
                this.ui.importGlossary.addClass("disable-list-option").find('a').removeAttr("href");
                this.ui.downloadTemplate.addClass("disable-list-option").find('a').removeAttr("href");
            }
            this.ui.termSearchTree.jstree(true).refresh();
        },
        initialize: function(options) {
            this.options = options;
            _.extend(
                this,
                _.pick(
                    options,
                    "typeHeaders",
                    "searchVent",
                    "entityDefCollection",
                    "enumDefCollection",
                    "classificationDefCollection",
                    "searchTableColumns",
                    "searchTableFilters",
                    "metricCollection",
                    "query",
                    "categoryEvent"
                )
            );
            this.glossaryTermId = this.glossaryId = null;
            this.glossaryCollection = new VGlossaryList([], {
                comparator: function(item) {
                    return item.get("name");
                }
            });
            this.getViewType();
            this.bindEvents();
            //To stop the trigger Search event, if the node is selected in Old UI and swicthed to New UI.
            this.isGlossaryTree = this.isGlossryTreeview();
        },
        isGlossryTreeview: function() {
            var queryParams = Utils.getUrlState.getQueryParams();
            if (queryParams && (queryParams.gType === "term" || queryParams.gType === "category")) {
                return true;
            }
        },
        onRender: function() {
            this.changeLoaderState(true);
            this.fetchGlossary();
        },
        changeLoaderState: function(showLoader) {
            if (showLoader) {
                this.ui.termSearchTree.hide();
                this.ui.glossaryTreeLoader.show();
            } else {
                this.ui.termSearchTree.show();
                this.ui.glossaryTreeLoader.hide();
            }
        },
        onBeforeDestroy: function() {
            this.options.categoryEvent.off("Success:TermRename")
        },
        getViewType: function() {
            if (Utils.getUrlState.isGlossaryTab()) {
                this.isTermView = this.options.value.viewType ? this.options.value.viewType == "term" ? true : false : true;
            } else {
                this.isTermView = true;
            }
        },
        manualRender: function(options) {
            var that = this;
            _.extend(this.options, options);
            if (this.options.value === undefined) {
                this.options.value = {};
            }
            if (!this.options.value.term && this.options.value.gType != 'category') {
                if (this.ui.termSearchTree.jstree(true)) {
                    this.ui.termSearchTree.jstree(true).deselect_all();
                }
                this.glossaryTermId = null;
            } else {
                if (this.options.value.term) {
                    var glossaryName = this.options.value.term.split('@')[1],
                        termName = this.options.value.term.split('@')[0],
                        dataFound = this.glossaryCollection.fullCollection.find(function(obj) {
                            return obj.get("name") === glossaryName;
                        });
                    if (dataFound) {
                        var terms = dataFound.get('terms');
                        var terModel = _.find(terms, function(model) {
                            return model.displayText === termName;
                        });
                        if (terModel) {
                            if ((this.glossaryTermId && this.glossaryTermId !== terModel.termGuid) || this.glossaryTermId === null) {
                                if (this.glossaryTermId) {
                                    this.ui.termSearchTree.jstree(true).deselect_node(this.glossaryTermId);
                                }
                                this.ui.termSearchTree.jstree(true).deselect_all();
                                this.glossaryTermId = terModel.termGuid;
                                this.fromManualRender = true;
                                this.ui.termSearchTree.jstree(true).select_node(terModel.termGuid);
                            }
                        }
                    }
                }
            }
        },
        fetchGlossary: function() {
            this.glossaryCollection.fetch({ reset: true });
        },
        renderGlossaryTree: function() {
            this.generateSearchTree({
                $el: this.ui.termSearchTree

            });
            this.createTermAction();
        },
        onNodeSelect: function(options, showCategory) {
            var nodeType = options.node.original.type;
            if (this.isGlossaryTree && (nodeType === "GlossaryTerm" || nodeType === "GlossaryCategory")) {
                //To stop the trigger Search event,if the node is selected in Old UI and swicthed to New UI.
                this.isGlossaryTree = false;
                return;
            }
            var name, type, selectedNodeId, that = this,
                glossaryType = options.node.original.gType;
            if (glossaryType == "category") {
                selectedNodeId = options.node.id;
                if (that.glossaryTermId != selectedNodeId) {
                    that.glossaryTermId = selectedNodeId;
                    that.onViewEdit();
                } else {
                    that.glossaryTermId = null;
                    that.showDefaultPage();
                }

            } else if (glossaryType == "term") {
                if (options) {
                    name = _.unescape(options.node.original.name);
                    selectedNodeId = options.node.id;
                }
                var termValue = null,
                    params = {
                        searchType: "basic"
                    };
                if (this.options.value) {
                    if (this.options.value.isCF) {
                        this.options.value.isCF = null;
                    }
                }
                if (that.glossaryTermId != selectedNodeId) {
                    that.glossaryTermId = selectedNodeId;
                    termValue = options ? name + '@' + options.node.original.parent.name : this.options.value.term;
                    params['term'] = termValue;
                    params['gtype'] = 'term';
                    params['viewType'] = 'term';
                    params['guid'] = selectedNodeId;

                } else {
                    that.glossaryTermId = params["term"] = null;
                    that.ui.termSearchTree.jstree(true).deselect_all(true);
                    if (!that.options.value.type && !that.options.value.tag && !that.options.value.query) {
                        that.showDefaultPage();
                        return;
                    }
                }
                that.glossaryId = null;
                var searchParam = _.extend({}, that.options.value, params);

                this.triggerSearch(searchParam);
                if (that.searchVent) {
                    that.searchVent.trigger("Success:Category");
                }
            } else if (glossaryType = "glossary") { //This condition is added to setUrl after click on Glossary for highlighting issue from New UI to Old UI.                
                that.glossaryTermId = null;
                if (that.glossaryId != options.node.id) {
                    that.glossaryId = options.node.id;
                    var params = {
                        "gId": that.glossaryId,
                        "gType": options.node.original.gType,
                        "viewType": (this.isTermView) ? "term" : "category"
                    };
                    Utils.setUrl({
                        url: '#!/glossary/' + that.glossaryId,
                        urlParams: params,
                        mergeBrowserUrl: false,
                        trigger: false,
                        updateTabState: true
                    });
                } else {
                    that.glossaryId = null;
                    that.ui.termSearchTree.jstree(true).deselect_all(true);
                    this.showDefaultPage();
                }
            } else {
                that.glossaryTermId = null;
                if (that.glossaryId != options.node.id) {
                    that.glossaryId = options.node.id;
                } else {
                    that.glossaryId = null;
                    that.ui.termSearchTree.jstree(true).deselect_all(true);
                }
            }
        },
        triggerSearch: function(params, url) {
            var serachUrl = url ? url : '#!/search/searchResult';
            Utils.setUrl({
                url: serachUrl,
                urlParams: params,
                mergeBrowserUrl: false,
                trigger: true,
                updateTabState: true
            });
        },
        showDefaultPage: function() {
            Utils.setUrl({
                url: '!/search',
                mergeBrowserUrl: false,
                trigger: true,
                updateTabState: true
            });
        },
        generateCategoryData: function(options) {
            var that = this,
                isSelected = false;
            return _.map(options.data, function(obj) {
                return {
                    "text": _.escape(obj.displayText),
                    "icon": "fa fa-files-o",
                    "guid": obj.categoryGuid,
                    "id": obj.categoryGuid,
                    "glossaryId": options.node.glossaryId,
                    "glossaryName": options.node.glossaryName,
                    "model": obj,
                    "type": "GlossaryCategory",
                    "gType": "category",
                    "children": true
                }
            });
        },
        getCategory: function(options) {
            var that = this;
            this.glossaryCollection.getCategory({
                "guid": options.node.guid,
                "related": true,
                "ajaxOptions": {
                    success: function(data) {
                        if (data && data.children) {
                            options.callback(that.generateCategoryData(_.extend({}, { "data": data.children }, options)));
                        } else {
                            options.callback([]);
                        }
                    },
                    cust_error: function() {
                        options.callback([]);
                    }
                }
            });
        },
        getGlossaryTree: function(options) {
            var that = this,
                collection = (options && options.collection) || this.glossaryCollection.fullCollection,
                listOfParents = [],
                type = "term",
                queryParams = Utils.getUrlState.getQueryParams(),
                glossaryGuid = queryParams ? queryParams.gId : null,
                gType = queryParams ? queryParams.gType : "term";
            return this.glossaryCollection.fullCollection.map(function(model, i) {
                var obj = model.toJSON(),
                    parent = {
                        text: _.escape(obj.name),
                        name: _.escape(obj.name),
                        icon: "fa fa-folder-o",
                        guid: obj.guid,
                        id: obj.guid,
                        model: obj,
                        type: obj.typeName ? obj.typeName : "GLOSSARY",
                        gType: "glossary",
                        children: [],
                        state: {
                            opened: true,
                            selected: (model.id === glossaryGuid && gType === "glossary") ? true : false
                        }
                    },
                    openGlossaryNodesState = function(treeDate) {
                        if (treeDate.length == 1) {
                            _.each(treeDate, function(model) {
                                model.state['opeaned'] = true;
                            })
                        }
                    },
                    generateNode = function(nodeOptions, model, isTermView, parentNode) {
                        var nodeStructure = {
                            text: _.escape(model.displayText),
                            name: _.escape(model.displayText),
                            type: nodeOptions.type,
                            gType: that.isTermView ? "term" : "category",
                            guid: nodeOptions.guid,
                            id: nodeOptions.guid,
                            parent: parentNode ? parentNode : obj,
                            glossaryName: parentNode ? parentNode.name ? parentNode.name : parentNode.displayText : obj.name,
                            glossaryId: parentNode ? parentNode.guid ? parentNode.guid : parentNode.categoryGuid : obj.guid,
                            model: model,
                            icon: "fa fa-file-o"
                        };
                        return nodeStructure;

                    };

                if (!that.isTermView && obj.categories && !that.isTermView) {
                    var isSelected = false,
                        parentGuid = obj.guid,
                        parentCategoryGuid = null,
                        categoryList = [],
                        catrgoryRelation = [];
                    _.each(obj.categories, function(category) {
                        if (that.options.value) {
                            isSelected = that.options.value.guid ? that.options.value.guid == category.categoryGuid : false;
                        }

                        var typeName = category.typeName || "GlossaryCategory",
                            guid = category.categoryGuid,
                            categoryObj = {
                                id: guid,
                                guid: guid,
                                text: _.escape(category.displayText),
                                type: typeName,
                                gType: "category",
                                glossaryId: obj.guid,
                                glossaryName: obj.name,
                                children: [],
                                model: category,
                                icon: "fa fa-files-o"
                            };
                        if (category.parentCategoryGuid) {
                            catrgoryRelation.push({ parent: category.parentCategoryGuid, child: guid })
                        }
                        categoryList.push(categoryObj);
                    });
                    _.each(categoryList, function(category) {
                        var getRelation = _.find(catrgoryRelation, function(catrgoryObj) {
                            if (catrgoryObj.child == category.guid) return catrgoryObj;
                        })
                        if (getRelation) {
                            _.map(categoryList, function(catrgoryObj) {
                                if (catrgoryObj.guid == getRelation.parent) {
                                    catrgoryObj["children"].push(category);
                                };
                            })
                        } else {
                            parent.children.push(category)
                        }
                    })
                }
                if (that.isTermView && obj.terms) {
                    var isSelected = false;
                    _.each(obj.terms, function(term) {
                        if (that.options.value) {
                            isSelected = that.options.value.term ? that.options.value.term.split('@')[0] == term.displayText : false;
                        }
                        var parentNodeDetails = {
                                type: term.typeName || "GlossaryTerm",
                                guid: term.termGuid
                            },
                            parentNodeProperties = {},
                            getParentNodeDetails = generateNode(parentNodeDetails, term, that.isTermView),
                            termParentNode = (_.extend(parentNodeProperties, getParentNodeDetails));
                        parent.children.push(termParentNode);
                    });
                }
                openGlossaryNodesState(parent);
                return parent;
            });
        },
        createTermAction: function() {
            var that = this;
            Utils.generatePopover({
                el: this.$el,
                contentClass: 'termPopoverOptions',
                popoverOptions: {
                    selector: '.termPopover',
                    content: function() {
                        var type = $(this).data('detail'),
                            liString = "";
                        if (type == "glossary") {
                            liString = "<li data-type=" + type + " class='listTerm'><i class='fa fa-plus'></i> <a href='javascript:void(0)' data-fn='createSubNode'>Create Term</a></li>" +
                                "<li data-type=" + type + " class='listTerm'><i class='fa fa-list-alt'></i><a href='javascript:void(0)' data-fn='onViewEdit'>View/Edit Glossary</a></li>" +
                                "<li data-type=" + type + " class='listTerm'><i class='fa fa-trash-o'></i><a href='javascript:void(0)' data-fn='deleteNode'>Delete Glossary</a></li>"
                        } else {
                            liString = "<li data-type=" + type + " class='listTerm'><i class='fa fa-list-alt'></i><a href='javascript:void(0)' data-fn='onViewEdit'>View/Edit Term</a></li>" +
                                "<li data-type=" + type + " class='listTerm'><i class='fa fa-search'></i><a href='javascript:void(0)' data-fn='searchSelectedTerm'>Search</a></li>" +
                                "<li data-type=" + type + " class='listTerm'><i class='fa fa-trash-o'></i><a href='javascript:void(0)' data-fn='deleteNode'>Delete Term</a></li>"
                        }
                        return "<ul>" + liString + "</ul>";
                    }
                }
            });
        },
        createCategoryAction: function() {
            var that = this;
            Utils.generatePopover({
                el: this.$('.categoryPopover'),
                contentClass: 'categoryPopoverOptions',
                popoverOptions: {
                    content: function() {
                        var type = $(this).data('detail'),
                            liString = "";
                        if (type == "glossary") {
                            liString = "<li data-type=" + type + " class='listTerm'><i class='fa fa-plus'></i> <a href='javascript:void(0)' data-fn='createSubNode'>Create Category</a></li>";
                        } else {
                            liString = "<li data-type=" + type + " class='listTerm'><i class='fa fa-list-alt'></i><a href='javascript:void(0)' data-fn='createSubNode'>Create Sub-Category</a></li>";
                        }
                        return "<ul>" + liString + "</ul>";
                    },
                    viewFixedPopover: true,
                }
            });
        },
        createSubNode: function(opt) {
            var that = this,
                selectednode = that.ui.termSearchTree.jstree("get_selected", true);
            if ((selectednode[0].original.type == "GLOSSARY" || selectednode[0].original.type == "GlossaryCategory") && !this.isTermView) {
                CommonViewFunction.createEditGlossaryCategoryTerm({
                    "isCategoryView": true,
                    "collection": that.glossaryCollection,
                    "callback": function(updateCollection) {
                        var updatedObj = {
                                categoryGuid: updateCollection.guid,
                                displayText: updateCollection.name,
                                relationGuid: updateCollection.anchor ? updateCollection.anchor.relationGuid : null
                            },
                            glossary = that.glossaryCollection.fullCollection.findWhere({ guid: updateCollection.anchor.glossaryGuid });
                        if (updateCollection.parentCategory) {
                            updatedObj["parentCategoryGuid"] = updateCollection.parentCategory.categoryGuid;
                        }
                        if (glossary) {
                            var glossaryAttributes = glossary.attributes || null;
                            if (glossaryAttributes) {
                                if (glossaryAttributes.categories) {
                                    glossaryAttributes['categories'].push(updatedObj);
                                } else {
                                    glossaryAttributes['categories'] = [updatedObj];
                                }
                            }
                        }
                        that.ui.termSearchTree.jstree(true).refresh();
                    },
                    "node": selectednode[0].original
                })
            } else {
                CommonViewFunction.createEditGlossaryCategoryTerm({
                    "isTermView": true,
                    "callback": function() {
                        that.fetchGlossary();
                        that.options.categoryEvent.trigger("Success:Term", true);
                    },
                    "collection": that.glossaryCollection,
                    "node": selectednode[0].original
                })
            }
        },
        searchSelectedTerm: function() {
            var params = {
                searchType: "basic",
                dslChecked: false,
                term: this.options.value.term
            };
            this.triggerSearch(params);
        },
        deleteNode: function(opt) {
            var that = this,
                messageType = "",
                selectednode = this.ui.termSearchTree.jstree("get_selected", true),
                type = selectednode[0].original.type,
                guid = selectednode[0].original.guid,
                gId = selectednode[0].original.parent && selectednode[0].original.parent.guid,
                options = {
                    success: function(rModel, response) {
                        var searchParam = null;
                        if (!gId) {
                            gId = guid;
                        }
                        if (gId === guid) {
                            that.glossaryCollection.fullCollection.remove(gId);
                        }
                        var glossary = that.glossaryCollection.fullCollection.get(gId);
                        if (type == "GlossaryTerm") {
                            glossary.set('terms', _.reject(glossary.get('terms'), function(obj) {
                                return obj.termGuid == guid;
                            }), { silent: true });
                        }
                        Utils.notifySuccess({
                            content: messageType + Messages.getAbbreviationMsg(false, 'deleteSuccessMessage')
                        });
                        that.ui.termSearchTree.jstree(true).refresh();
                        var params = {
                            searchType: "basic",
                            term: null
                        };
                        that.glossaryTermId = null;
                        if (that.options.value && that.options.value.gType == "category") {
                            that.showDefaultPage();
                        } else {
                            searchParam = _.extend({}, that.options.value, params);
                            that.triggerSearch(searchParam);
                        }
                    },
                    complete: function() {
                        that.notificationModal.hideButtonLoader();
                        that.notificationModal.remove();
                    }
                },
                notifyObj = {
                    modal: true,
                    ok: function(obj) {
                        that.notificationModal = obj;
                        obj.showButtonLoader();
                        if (type == "Glossary" || type == "GLOSSARY") {
                            new that.glossaryCollection.model().deleteGlossary(guid, options);
                        } else if (type == "GlossaryCategory") {
                            new that.glossaryCollection.model().deleteCategory(guid, options);

                        } else if (type == "GlossaryTerm") {
                            new that.glossaryCollection.model().deleteTerm(guid, options);
                        }
                    },
                    okCloses: false,
                    cancel: function(argument) {}
                };
            if (type == "Glossary" || type == "GLOSSARY") {
                messageType = "Glossary";
            } else if (type == "GlossaryCategory") {
                messageType = "Category"
            } else if (type == "GlossaryTerm") {
                messageType = "Term";
            }
            notifyObj['text'] = "Are you sure you want to delete the " + messageType;;
            Utils.notifyConfirm(notifyObj);
        },
        onViewEdit: function() {
            var that = this,
                selectednode = this.ui.termSearchTree.jstree("get_selected", true),
                type = selectednode[0].original.type,
                guid = selectednode[0].original.guid,
                gId = selectednode[0].original.parent && selectednode[0].original.parent.guid,
                isGlossaryView = (type == 'GlossaryTerm' || type == 'GlossaryCategory') ? false : true,
                model = this.glossaryCollection.fullCollection.get(guid),
                termModel = this.glossaryCollection.fullCollection.get(gId);
            if (isGlossaryView) {
                CommonViewFunction.createEditGlossaryCategoryTerm({
                    "model": model,
                    "isGlossaryView": true,
                    "collection": this.glossaryCollection,
                    "callback": function(sModel) {
                        var data = sModel.toJSON();
                        model.set(data, { silent: true }); // update glossaryCollection
                        that.ui.termSearchTree.jstree(true).refresh();
                    }
                });
            } else {
                var glossaryId = selectednode[0].original.glossaryId,
                    getSelectedParent = null,
                    params = null;
                if (selectednode[0].parents.length > 2) {
                    getSelectedParent = selectednode[0].parents[selectednode[0].parents.length - 3];
                } else {
                    getSelectedParent = selectednode[0].id;
                }

                params = {
                    gId: glossaryId,
                    guid: getSelectedParent,
                    gType: that.isTermView ? 'term' : 'category',
                    viewType: that.isTermView ? 'term' : 'category',
                    searchType: "basic"
                }
                if (type === "GlossaryTerm") {
                    //Below condition is used to keep the selection or Highlight after clicking on the viewEdit option on term.
                    params['term'] = selectednode[0].original.name + '@' + selectednode[0].original.parent.name;
                }
                var serachUrl = '#!/glossary/' + guid;
                this.triggerSearch(params, serachUrl);
                if (!this.isTermView && this.options.categoryEvent) {
                    that.options.categoryEvent.trigger("Success:Category", true);
                }
            }
        },
        generateSearchTree: function(options) {
            var $el = options && options.$el,
                data = options && options.data,
                type = options && options.type,
                that = this,
                createAction = function(options) {
                    that.isTermView ? that.createTermAction() : that.createCategoryAction();
                },
                getEntityTreeConfig = function(opt) {
                    return {
                        plugins: ["search", "core", "sort", "conditionalselect", "changed", "wholerow", "node_customize"],

                        state: { opened: true },
                        search: {
                            show_only_matches: true,
                            case_sensitive: false
                        },
                        node_customize: {
                            default: function(el, node) {
                                var aTerm = $(el).find(">a.jstree-anchor");
                                aTerm.append("<span class='tree-tooltip'>" + _.escape(aTerm.text()) + "</span>");
                                var popoverClass = that.isTermView ? "fa fa-ellipsis-h termPopover " : "fa fa-ellipsis-h categoryPopover";
                                $(el).append('<div class="tools" data-type=' + node.original.gType + '><i class="' + popoverClass + '"rel="popover" data-detail=' + node.original.gType + '></i></div>');
                            }
                        },
                        core: {
                            data: function(node, cb) {
                                if (node.id === "#") {
                                    cb(that.getGlossaryTree());
                                } else {
                                    that.getCategory({ "node": node.original, "callback": cb });
                                }
                            },
                            multiple: false
                        }
                    };
                };

            $el.jstree(
                    getEntityTreeConfig({
                        type: ""
                    })
                ).on("load_node.jstree", function(e, data) {}).on("open_node.jstree", function(e, data) {}).on("select_node.jstree", function(e, data) {
                    if (that.fromManualRender !== true) {
                        that.onNodeSelect(data);
                        if (that.glossaryId === data.node.original.id) {
                            //This condition is to reset the Glossary ID to null after clicking on the Logo.
                            that.glossaryId = null;
                        }
                    } else {
                        that.fromManualRender = false;
                    }
                    createAction(_.extend({}, options, data));
                })
                .on("open_node.jstree", function(e, data) {
                    createAction(_.extend({}, options, data));
                })
                .on("search.jstree", function(nodes, str, res) {
                    if (str.nodes.length === 0) {
                        $el.jstree(true).hide_all();
                        $el.parents(".panel").addClass("hide");
                    } else {
                        $el.parents(".panel").removeClass("hide");
                    }
                }).on('loaded.jstree', function() {
                    if (that.options.value) {
                        if (that.options.value.term) {
                            that.selectDefaultNode();
                        }
                        if (!that.isTermView) {
                            that.selectDefaultNode();
                            that.options.categoryEvent.trigger("Success:Category", true);
                        }
                    }
                    //Below condition is for switching the the Show Term/Show Category toggle button on switching from Old to New UI.
                    if (that.isTermView === false) {
                        that.glossarySwitchBtnUpdate();
                    }

                }).on("hover_node.jstree", function(nodes, str, res) {
                    var aTerm = that.$("#" + str.node.a_attr.id),
                        termOffset = aTerm.find(">.jstree-icon").offset();
                    that.$(".tree-tooltip").removeClass("show");
                    setTimeout(function() {
                        if (aTerm.hasClass("jstree-hovered") && termOffset.top && termOffset.left) {
                            aTerm.find(">span.tree-tooltip").css({
                                top: "calc(" + termOffset.top + "px - 45px)",
                                left: "24px"
                            }).addClass("show");
                        }
                    }, 1200);
                }).on("dehover_node.jstree", function(nodes, str, res) {
                    that.$(".tree-tooltip").removeClass("show");
                });
        },
        selectDefaultNode: function() {
            this.ui.termSearchTree.jstree(true).select_node(this.options.value.guid);
        },
        refresh: function(options) {
            this.glossaryTermId = null;
            this.fetchGlossary();
            this.isGlossaryTree = true;
        },
        onClickImportGlossary: function() {
            var that = this;
            require([
                'views/import/ImportLayoutView'
            ], function(ImportLayoutView) {
                var view = new ImportLayoutView({
                    callback: function() {
                        that.refresh();
                    },
                    isGlossary: true
                });
            });
        }
    });
    return GlossaryTreeLayoutView;
});