text: /**
   * 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',
      'backbone',
      'table-dragger',
      'hbs!tmpl/search/SearchResultLayoutView_tmpl',
      'modules/Modal',
      'models/VEntity',
      'utils/Utils',
      'utils/Globals',
      'collection/VSearchList',
      'models/VCommon',
      'utils/CommonViewFunction',
      'utils/Messages',
      'utils/Enums',
      'utils/UrlLinks',
      'moment',
      'platform'
  ], function(require, Backbone, tableDragger, SearchResultLayoutViewTmpl, Modal, VEntity, Utils, Globals, VSearchList, VCommon, CommonViewFunction, Messages, Enums, UrlLinks, moment, platform) {
      'use strict';
  
      var SearchResultLayoutView = Backbone.Marionette.LayoutView.extend(
          /** @lends SearchResultLayoutView */
          {
              _viewName: 'SearchResultLayoutView',
  
              template: SearchResultLayoutViewTmpl,
  
              /** Layout sub regions */
              regions: {
                  REntityTableLayoutView: "#r_searchResultTableLayoutView",
                  RSearchQuery: '#r_searchQuery'
              },
  
              /** ui selector cache */
              ui: {
                  tagClick: '[data-id="tagClick"]',
                  termClick: '[data-id="termClick"]',
                  addTag: '[data-id="addTag"]',
                  addTerm: '[data-id="addTerm"]',
                  paginationDiv: '[data-id="paginationDiv"]',
                  previousData: "[data-id='previousData']",
                  nextData: "[data-id='nextData']",
                  pageRecordText: "[data-id='pageRecordText']",
                  addAssignTag: "[data-id='addAssignTag']",
                  addAssignTerm: "[data-id='addAssignTerm']",
                  createEntity: "[data-id='createEntity']",
                  checkDeletedEntity: "[data-id='checkDeletedEntity']",
                  checkSubClassification: "[data-id='checkSubClassification']",
                  checkSubType: "[data-id='checkSubType']",
                  colManager: "[data-id='colManager']",
                  containerCheckBox: "[data-id='containerCheckBox']",
                  columnEmptyInfo: "[data-id='columnEmptyInfo']",
                  showPage: "[data-id='showPage']",
                  gotoPage: "[data-id='gotoPage']",
                  gotoPagebtn: "[data-id='gotoPagebtn']",
                  activePage: "[data-id='activePage']",
                  saveFilter: "[data-id='saveFilter']"
              },
              templateHelpers: function() {
                  return {
                      entityCreate: Globals.entityCreate,
                      searchType: this.searchType,
                      fromView: this.fromView,
                      isGlossaryView: this.fromView == "glossary",
                      isSearchTab: Utils.getUrlState.isSearchTab()
                  };
              },
              /** ui events hash */
              events: function() {
                  var events = {},
                      that = this;
                  events["click " + this.ui.tagClick] = function(e) {
                      var scope = $(e.currentTarget);
                      if (e.target.nodeName.toLocaleLowerCase() == "i") {
                          this.onClickTagCross(e);
                      } else {
                          this.triggerUrl({
                              url: '#!/tag/tagAttribute/' + scope.text(),
                              urlParams: null,
                              mergeBrowserUrl: false,
                              trigger: true,
                              updateTabState: true
                          });
                          console.log(Globals)
                      }
                  };
                  events["click " + this.ui.termClick] = function(e) {
                      var scope = $(e.currentTarget);
                      if (e.target.nodeName.toLocaleLowerCase() == "i") {
                          this.onClickTermCross(e);
                      } else {
                          this.triggerUrl({
                              url: '#!/glossary/' + scope.find('i').data('termguid'),
                              urlParams: { gType: "term", viewType: "term", fromView: "entity" },
                              mergeBrowserUrl: false,
                              trigger: true,
                              updateTabState: null
                          });
                      }
                  };
                  events["keyup " + this.ui.gotoPage] = function(e) {
                      var code = e.which,
                          goToPage = parseInt(e.currentTarget.value);
                      if (e.currentTarget.value) {
                          that.ui.gotoPagebtn.attr('disabled', false);
                      } else {
                          that.ui.gotoPagebtn.attr('disabled', true);
                      }
                      if (code == 13) {
                          if (e.currentTarget.value) {
                              that.gotoPagebtn();
                          }
                      }
                  };
                  events["change " + this.ui.showPage] = 'changePageLimit';
                  events["click " + this.ui.gotoPagebtn] = 'gotoPagebtn';
                  events["click " + this.ui.addTag] = 'onClickAddTag';
                  events["click " + this.ui.addTerm] = 'onClickAddTermBtn';
                  events["click " + this.ui.addAssignTag] = 'onClickAddTag';
                  events["click " + this.ui.addAssignTerm] = 'onClickAddTermBtn';
                  events["click " + this.ui.nextData] = "onClicknextData";
                  events["click " + this.ui.previousData] = "onClickpreviousData";
                  events["click " + this.ui.createEntity] = 'onClickCreateEntity';
                  events["click " + this.ui.checkDeletedEntity] = 'onCheckExcludeIncludeResult';
                  events["click " + this.ui.checkSubClassification] = 'onCheckExcludeIncludeResult';
                  events["click " + this.ui.checkSubType] = 'onCheckExcludeIncludeResult';
                  events["click " + this.ui.saveFilter] = function() {
                      if (this.searchVent) {
                          this.searchVent.trigger("Save:Filter");
                      }
                  };
                  return events;
              },
              /**
               * intialize a new SearchResultLayoutView Layout
               * @constructs
               */
              initialize: function(options) {
                  _.extend(this, _.pick(options, 'value', 'guid', 'initialView', 'isTypeTagNotExists', 'classificationDefCollection', 'entityDefCollection', 'typeHeaders', 'searchVent', 'enumDefCollection', 'tagCollection', 'searchTableColumns', 'isTableDropDisable', 'fromView', 'glossaryCollection', 'termName'));
                  this.entityModel = new VEntity();
                  this.searchCollection = new VSearchList();
                  this.limit = 25;
                  this.asyncFetchCounter = 0;
                  this.offset = 0;
                  this.bindEvents();
                  this.multiSelectEntity = [];
                  this.searchType = 'Basic Search';
                  this.columnOrder = null;
                  if (this.value) {
                      if (this.value.searchType && this.value.searchType == 'dsl') {
                          this.searchType = 'Advanced Search';
                      }
                      if (this.value.pageLimit) {
                          var pageLimit = parseInt(this.value.pageLimit, 10);
                          if (_.isNaN(pageLimit) || pageLimit == 0 || pageLimit <= -1) {
                              this.value.pageLimit = this.limit;
                              this.triggerUrl();
                          } else {
                              this.limit = pageLimit;
                          }
                      }
                      if (this.value.pageOffset) {
                          var pageOffset = parseInt(this.value.pageOffset, 10);
                          if (_.isNaN(pageOffset) || pageLimit <= -1) {
                              this.value.pageOffset = this.offset;
                              this.triggerUrl();
                          } else {
                              this.offset = pageOffset;
                          }
                      }
                  };
                  if (platform.name === "IE") {
                      this.isTableDropDisable = true;
                  }
              },
              bindEvents: function() {
                  var that = this;
                  this.onClickLoadMore();
                  this.listenTo(this.searchCollection, 'backgrid:selected', function(model, checked) {
                      this.multiSelectEntity = [];
                      if (checked === true) {
                          model.set("isEnable", true);
                      } else {
                          model.set("isEnable", false);
                      }
                      this.searchCollection.find(function(item) {
                          if (item.get('isEnable')) {
                              var obj = item.toJSON();
                              that.multiSelectEntity.push({
                                  id: obj.guid,
                                  model: obj
                              });
                          }
                      });
                      this.updateMultiSelect();
                  });
                  this.listenTo(this.searchCollection, "error", function(model, response) {
                      this.hideLoader({ type: 'error' });
                      var responseJSON = response && response.responseJSON ? response.responseJSON : null,
                          errorText = (responseJSON && (responseJSON.errorMessage || responseJSON.message || responseJSON.error)) || 'Invalid Expression';
                      if (errorText) {
                          Utils.notifyError({
                              content: errorText
                          });
                          this.$('.searchTable > .well').html('<center>' + errorText + '</center>')
                      }
                  }, this);
                  this.listenTo(this.searchCollection, "state-changed", function(state) {
                      if (Utils.getUrlState.isSearchTab()) {
                          this.updateColumnList(state);
                          var excludeDefaultColumn = [];
                          if (this.value && this.value.type) {
                              excludeDefaultColumn = _.without(this.searchTableColumns[this.value.type], "selected", "name", "description", "typeName", "owner", "tag", "term");
                              if (this.searchTableColumns[this.value.type] === null) {
                                  this.ui.columnEmptyInfo.show();
                              } else {
                                  this.ui.columnEmptyInfo.hide();
                              }
                          }
                          this.columnOrder = this.getColumnOrder(this.REntityTableLayoutView.$el.find('.colSort th.renderable'));
                          this.triggerUrl();
                          var attributes = this.searchCollection.filterObj.attributes;
                          if ((excludeDefaultColumn && attributes) && (excludeDefaultColumn.length > attributes.length || _.difference(excludeDefaultColumn, attributes).length)) {
                              this.fetchCollection(this.value);
                          }
                      }
                  }, this);
                  this.listenTo(this.searchVent, "search:refresh", function(model, response) {
                      this.fetchCollection();
                  }, this);
                  this.listenTo(this.searchCollection, "backgrid:sorted", function(model, response) {
                      this.checkTableFetch();
                  }, this)
              },
              onRender: function() {
                  var that = this;
                  if (Utils.getUrlState.isSearchTab()) {
                      this.$(".action-box").hide();
                  }
                  this.commonTableOptions = {
                      collection: this.searchCollection,
                      includePagination: false,
                      includeFooterRecords: false,
                      includeColumnManager: (Utils.getUrlState.isSearchTab() && this.value && this.value.searchType === "basic" && !this.value.profileDBView ? true : false),
                      includeOrderAbleColumns: false,
                      includeSizeAbleColumns: false,
                      includeTableLoader: false,
                      includeAtlasTableSorting: true,
                      columnOpts: {
                          opts: {
                              initialColumnsVisible: null,
                              saveState: false
                          },
                          visibilityControlOpts: {
                              buttonTemplate: _.template("<button class='btn btn-action btn-sm pull-right'>Columns&nbsp<i class='fa fa-caret-down'></i></button>")
                          },
                          el: this.ui.colManager
                      },
                      gridOpts: {
                          emptyText: 'No Records found!',
                          className: 'table table-hover backgrid table-quickMenu colSort'
                      },
                      filterOpts: {},
                      paginatorOpts: {}
                  };
                  if (!this.initialView) {
                      var value = {},
                          that = this;
                      if (this.value) {
                          value = this.value;
                          if (value && value.includeDE) {
                              this.ui.checkDeletedEntity.prop('checked', true);
                          }
                          if (value && value.excludeSC) {
                              this.ui.checkSubClassification.prop('checked', true);
                          }
                          if (value && value.excludeST) {
                              this.ui.checkSubType.prop('checked', true);
                          }
  
                      } else {
                          value = {
                              'query': null,
                              'searchType': 'basic'
                          };
                      }
                      this.updateColumnList();
                      if (this.value && this.searchTableColumns && this.searchTableColumns[this.value.type] === null) {
                          this.ui.columnEmptyInfo.show();
                      } else {
                          this.ui.columnEmptyInfo.hide();
                      }
                      this.fetchCollection(value, _.extend({ 'fromUrl': true }, (this.value && this.value.pageOffset ? { 'next': true } : null)));
                      this.ui.showPage.select2({
                          data: _.sortBy(_.union([25, 50, 100, 150, 200, 250, 300, 350, 400, 450, 500], [this.limit])),
                          tags: true,
                          dropdownCssClass: "number-input",
                          multiple: false
                      });
                      if (this.value && this.value.pageLimit) {
                          this.ui.showPage.val(this.limit).trigger('change', { "skipViewChange": true });
                      }
                  } else {
                      if (Globals.entityTypeConfList) {
                          this.$(".entityLink").show();
                      }
                      if (this.isTypeTagNotExists) {
                          Utils.notifyError({
                              content: Messages.search.notExists
                          });
                      }
                  }
              },
              getColumnOrderWithPosition: function() {
                  var that = this;
                  return _.map(that.columnOrder, function(value, key) {
                      return key + "::" + value;
                  }).join(",");
              },
              triggerUrl: function(options) {
                  Utils.setUrl(_.extend({
                      url: Utils.getUrlState.getQueryUrl().queyParams[0],
                      urlParams: this.columnOrder ? _.extend(this.value, { 'uiParameters': this.getColumnOrderWithPosition() }) : this.value,
                      mergeBrowserUrl: false,
                      trigger: false,
                      updateTabState: true
                  }, options));
              },
              updateMultiSelect: function() {
                  if (this.multiSelectEntity.length > 0) {
                      this.$('.multiSelectTag,.multiSelectTerm').show();
                  } else {
                      this.$('.multiSelectTag,.multiSelectTerm').hide();
                  }
              },
              updateColumnList: function(updatedList) {
                  if (updatedList) {
                      var listOfColumns = [];
                      _.map(updatedList, function(obj) {
                          var key = obj.name;
                          if (obj.renderable) {
                              listOfColumns.push(obj.name);
                          }
                      });
                      listOfColumns = _.sortBy(listOfColumns);
                      this.value.attributes = listOfColumns.length ? listOfColumns.join(",") : null;
                      if (this.value && this.value.type && this.searchTableColumns) {
                          this.searchTableColumns[this.value.type] = listOfColumns.length ? listOfColumns : null;
                      }
                  } else if (this.value && this.value.type && this.searchTableColumns && this.value.attributes) {
                      this.searchTableColumns[this.value.type] = this.value.entityFilters ? this.value.attributes.split(",") : this.value.attributes.replace("namespace,", "").split(",");
                  }
              },
              fetchCollection: function(value, options) {
                  var that = this,
                      isPostMethod = (this.value && this.value.searchType === "basic"),
                      isSearchTab = Utils.getUrlState.isSearchTab(),
                      tagFilters = null,
                      entityFilters = null;
                  if (isSearchTab) {
                      tagFilters = CommonViewFunction.attributeFilter.generateAPIObj(this.value.tagFilters);
                      entityFilters = CommonViewFunction.attributeFilter.generateAPIObj(this.value.entityFilters);
                  }
  
                  if (isPostMethod && isSearchTab) {
                      var excludeDefaultColumn = this.value.type && this.searchTableColumns ? _.without(this.searchTableColumns[this.value.type], "selected", "name", "description", "typeName", "owner", "tag") : null,
                          filterObj = {
                              'entityFilters': entityFilters,
                              'tagFilters': tagFilters,
                              'attributes': excludeDefaultColumn ? excludeDefaultColumn : null
                          };
                  }
  
                  this.showLoader();
                  if (Globals.searchApiCallRef && Globals.searchApiCallRef.readyState === 1) {
                      Globals.searchApiCallRef.abort();
                  }
                  var apiObj = {
                      skipDefaultError: true,
                      sort: false,
                      success: function(dataOrCollection, response) {
                          if (that.isDestroyed) {
                              return;
                          }
                          Globals.searchApiCallRef = undefined;
                          var isFirstPage = that.offset === 0,
                              dataLength = 0,
                              goToPage = that.ui.gotoPage.val();
                          that.ui.gotoPage.val('');
                          that.ui.gotoPage.parent().removeClass('has-error');
                          that.ui.gotoPagebtn.prop("disabled", true);
                          if (!(that.ui.pageRecordText instanceof jQuery)) {
                              return;
                          }
                          if (isPostMethod && dataOrCollection && dataOrCollection.entities) {
                              dataLength = dataOrCollection.entities.length;
                          } else {
                              dataLength = dataOrCollection.length;
                          }
  
                          if (!dataLength && that.offset >= that.limit && ((options && options.next) || goToPage) && (options && !options.fromUrl)) {
                              /* User clicks on next button and server returns
                              empty response then disabled the next button without rendering table*/
  
                              that.hideLoader();
                              var pageNumber = that.activePage + 1;
                              if (goToPage) {
                                  pageNumber = goToPage;
                                  that.offset = (that.activePage - 1) * that.limit;
                              } else {
                                  that.finalPage = that.activePage;
                                  that.ui.nextData.attr('disabled', true);
                                  that.offset = that.offset - that.limit;
                              }
                              if (that.value) {
                                  that.value.pageOffset = that.offset;
                                  that.triggerUrl();
                              }
                              Utils.notifyInfo({
                                  html: true,
                                  content: Messages.search.noRecordForPage + '<b>' + Utils.getNumberSuffix({ number: pageNumber, sup: true }) + '</b> page'
                              });
                              return;
                          }
                          if (isPostMethod) {
                              Utils.findAndMergeRefEntity({
                                  attributeObject: dataOrCollection.entities,
                                  referredEntities: dataOrCollection.referredEntities
                              });
                              that.searchCollection.referredEntities = dataOrCollection.referredEntities;
                              that.searchCollection.entities = dataOrCollection.entities;
                              that.searchCollection.reset(dataOrCollection.entities, { silent: true });
                          }
  
  
                          /*Next button check.
                          It's outside of Previous button else condition
                          because when user comes from 2 page to 1 page than we need to check next button.*/
                          if (dataLength < that.limit) {
                              that.ui.nextData.attr('disabled', true);
                          } else {
                              that.ui.nextData.attr('disabled', false);
                          }
  
                          if (isFirstPage && (!dataLength || dataLength < that.limit)) {
                              that.ui.paginationDiv.hide();
                          } else {
                              that.ui.paginationDiv.show();
                          }
  
                          // Previous button check.
                          if (isFirstPage) {
                              that.ui.previousData.attr('disabled', true);
                              that.pageFrom = 1;
                              that.pageTo = that.limit;
                          } else {
                              that.ui.previousData.attr('disabled', false);
                          }
  
                          if (options && options.next) {
                              //on next click, adding "1" for showing the another records.
                              that.pageTo = that.offset + that.limit;
                              that.pageFrom = that.offset + 1;
                          } else if (!isFirstPage && options && options.previous) {
                              that.pageTo = that.pageTo - that.limit;
                              that.pageFrom = (that.pageTo - that.limit) + 1;
                          }
                          that.ui.pageRecordText.html("Showing  <u>" + that.searchCollection.models.length + " records</u> From " + that.pageFrom + " - " + that.pageTo);
                          that.activePage = Math.round(that.pageTo / that.limit);
                          that.ui.activePage.attr('title', "Page " + that.activePage);
                          that.ui.activePage.text(that.activePage);
                          that.renderTableLayoutView();
                          that.multiSelectEntity = [];
                          that.updateMultiSelect();
  
                          if (dataLength > 0) {
                              that.$('.searchTable').removeClass('noData')
                          }
  
                          if (Utils.getUrlState.isSearchTab() && value && !value.profileDBView) {
                              // var searchString = 'Results for: <span class="filterQuery">' + CommonViewFunction.generateQueryOfFilter(that.value, true) + "</span>";
                              var isCapsuleView = true;
                              var searchString = '<span class="filterQuery">' + CommonViewFunction.generateQueryOfFilter(that.value, isCapsuleView) + "</span>";
                              if (Globals.entityCreate && Globals.entityTypeConfList && Utils.getUrlState.isSearchTab()) {
                                  // searchString += "<p>If you do not find the entity in search result below then you can" + '<a href="javascript:void(0)" data-id="createEntity"> create new entity</a></p>';
                              }
                              that.$('.searchResult').html(searchString);
                          }
                      },
                      silent: true,
                      reset: true
                  }
                  if (this.value) {
                      var checkBoxValue = {
                          'excludeDeletedEntities': (this.value.includeDE ? false : true),
                          'includeSubClassifications': (this.value.excludeSC ? false : true),
                          'includeSubTypes': (this.value.excludeST ? false : true),
                          'includeClassificationAttributes': true // server will return classication details with guid
                      }
                  }
                  if (value) {
                      if (value.searchType) {
                          this.searchCollection.url = UrlLinks.searchApiUrl(value.searchType);
                      }
                      _.extend(this.searchCollection.queryParams, { 'limit': this.limit, 'offset': this.offset, 'query': _.trim(value.query), 'typeName': value.type || null, 'classification': value.tag || null, 'termName': value.term || null });
                      if (value.profileDBView && value.typeName && value.guid) {
                          var profileParam = {};
                          profileParam['guid'] = value.guid;
                          profileParam['relation'] = value.typeName === 'hive_db' ? '__hive_table.db' : '__hbase_table.namespace';
                          profileParam['sortBy'] = 'name';
                          profileParam['sortOrder'] = 'ASCENDING';
                          _.extend(this.searchCollection.queryParams, profileParam);
                      }
                      if (isPostMethod) {
                          this.searchCollection.filterObj = _.extend({}, filterObj);
                          apiObj['data'] = _.extend(checkBoxValue, filterObj, _.pick(this.searchCollection.queryParams, 'query', 'excludeDeletedEntities', 'limit', 'offset', 'typeName', 'classification', 'termName'))
                          Globals.searchApiCallRef = this.searchCollection.getBasicRearchResult(apiObj);
                      } else {
                          apiObj.data = null;
                          this.searchCollection.filterObj = null;
                          if (this.value.profileDBView) {
                              _.extend(this.searchCollection.queryParams, checkBoxValue);
                          }
                          Globals.searchApiCallRef = this.searchCollection.fetch(apiObj);
                      }
                  } else {
                      _.extend(this.searchCollection.queryParams, { 'limit': this.limit, 'offset': this.offset });
                      if (isPostMethod) {
                          apiObj['data'] = _.extend(checkBoxValue, filterObj, _.pick(this.searchCollection.queryParams, 'query', 'excludeDeletedEntities', 'limit', 'offset', 'typeName', 'classification', 'termName'));
                          Globals.searchApiCallRef = this.searchCollection.getBasicRearchResult(apiObj);
                      } else {
                          apiObj.data = null;
                          if (this.value.profileDBView) {
                              _.extend(this.searchCollection.queryParams, checkBoxValue);
                          }
                          Globals.searchApiCallRef = this.searchCollection.fetch(apiObj);
                      }
                  }
              },
              tableRender: function(options) {
                  var that = this,
                      savedColumnOrder = options.order,
                      TableLayout = options.table,
                      columnCollection = Backgrid.Columns.extend({
                          sortKey: "displayOrder",
                          className: "my-awesome-css-animated-grid",
                          comparator: function(item) {
                              return item.get(this.sortKey) || 999;
                          },
                          setPositions: function() {
                              _.each(this.models, function(model, index) {
                                  model.set("displayOrder", (savedColumnOrder == null ? index : parseInt(savedColumnOrder[model.get('label')])) + 1, { silent: true });
                              });
                              return this;
                          }
                      });
                  var columns = new columnCollection((that.searchCollection.dynamicTable ? that.getDaynamicColumns(that.searchCollection.toJSON()) : that.getFixedDslColumn()));
                  columns.setPositions().sort();
                  var table = new TableLayout(_.extend({}, that.commonTableOptions, {
                      columns: columns
                  }));
                  if (table.collection.length === 0) {
                      that.$(".searchTable").addClass('noData');
                  }
                  if (!that.REntityTableLayoutView) {
                      return;
                  }
                  if (!that.value) {
                      that.value = that.options.value;
                  }
                  that.REntityTableLayoutView.show(table);
                  if (that.value.searchType !== "dsl") {
                      that.ui.containerCheckBox.show();
                  } else {
                      that.ui.containerCheckBox.hide();
                  }
                  that.$(".ellipsis-with-margin .inputAssignTag").hide();
                  table.trigger("grid:refresh"); /*Event fire when table rendered*/
                  // that.REntityTableLayoutView.$el.find('.colSort thead tr th:not(:first)').addClass('dragHandler');
                  if (that.isTableDropDisable !== true) {
                      var tableDropFunction = function(from, to, el) {
                          tableDragger(document.querySelector(".colSort")).destroy();
                          that.columnOrder = that.getColumnOrder(el.querySelectorAll('th.renderable'));
                          that.triggerUrl();
                          that.tableRender({ "order": that.columnOrder, "table": TableLayout });
                          that.checkTableFetch();
                      }
                      that.REntityTableLayoutView.$el.find('.colSort thead tr th:not(.select-all-header-cell)').addClass('dragHandler');
                      tableDragger(document.querySelector(".colSort"), { dragHandler: ".dragHandler" }).on('drop', tableDropFunction);
                  }
              },
              renderTableLayoutView: function(col) {
                  var that = this;
                  require(['utils/TableLayout'], function(TableLayout) {
                      // displayOrder added for column manager
                      if (that.value.uiParameters) {
                          var savedColumnOrder = _.object(that.value.uiParameters.split(',').map(function(a) {
                              return a.split('::');
                          })); // get Column position from string to object
                      }
  
                      that.tableRender({ "order": savedColumnOrder, "table": TableLayout });
                      that.checkTableFetch();
                  });
              },
              getColumnOrder: function(arr) {
                  var obj = {};
                  for (var i = 0; i < arr.length; ++i) {
                      var innerText = arr[i].innerText.trim();
                      obj[(innerText == "" ? 'Select' : innerText)] = i;
                  }
                  return obj;
              },
              checkTableFetch: function() {
                  if (this.asyncFetchCounter <= 0) {
                      this.hideLoader();
                      Utils.generatePopover({
                          el: this.$('[data-id="showMoreLess"]'),
                          contentClass: 'popover-tag-term',
                          viewFixedPopover: true,
                          popoverOptions: {
                              container: null,
                              content: function() {
                                  return $(this).find('.popup-tag-term').children().clone();
                              }
                          }
                      });
                  }
              },
              getFixedDslColumn: function() {
                  var that = this,
                      nameCheck = 0,
                      columnToShow = null,
                      col = {},
                      namespaceRenderable = false;
                  this.value = Utils.getUrlState.getQueryParams() || this.value;
                  if (this.value && this.value.searchType === "basic" && this.searchTableColumns && (this.searchTableColumns[this.value.type] !== undefined)) {
                      columnToShow = this.searchTableColumns[this.value.type] == null ? [] : this.searchTableColumns[this.value.type];
                  }
                  col['Check'] = {
                      name: "selected",
                      label: "Select",
                      cell: "select-row",
                      resizeable: false,
                      orderable: false,
                      alwaysVisible: true, //Backgrid.ColumnManager.js -> render() to hide the name in dropdownlist
                      renderable: (columnToShow ? _.contains(columnToShow, 'selected') : true),
                      headerCell: "select-all"
                  };
  
  
                  col['name'] = {
                      label: this.value && this.value.profileDBView ? "Table Name" : "Name",
                      cell: "html",
                      editable: false,
                      resizeable: true,
                      orderable: false,
                      renderable: true,
                      className: "searchTableName",
                      formatter: _.extend({}, Backgrid.CellFormatter.prototype, {
                          fromRaw: function(rawValue, model) {
                              var obj = model.toJSON(),
                                  nameHtml = "",
                                  name = Utils.getName(obj);
                              if (obj.guid) {
                                  if (obj.guid == "-1") {
                                      nameHtml = '<span title="' + name + '">' + name + '</span>';
                                  } else {
                                      nameHtml = '<a title="' + name + '" href="#!/detailPage/' + obj.guid + (that.fromView ? "?from=" + that.fromView : "") + '">' + name + '</a>';
                                  }
                              } else {
                                  nameHtml = '<span title="' + name + '">' + name + '</span>';
                              }
                              if (obj.status && Enums.entityStateReadOnly[obj.status]) {
                                  nameHtml += '<button type="button" title="Deleted" class="btn btn-action btn-md deleteBtn"><i class="fa fa-trash"></i></button>';
                                  nameHtml = '<div class="readOnly readOnlyLink">' + nameHtml + '</div>';
                              }
                              var getImageData = function(options) {
                                  var imagePath = options.imagePath,
                                      returnImgUrl = null;
                                  $.ajax({
                                          "url": imagePath,
                                          "method": "get",
                                          "cache": true
                                      })
                                      .always(function(data, status, xhr) {
                                          if (data.status == 404) {
                                              returnImgUrl = getImageData({
                                                  "imagePath": Utils.getEntityIconPath({ entityData: obj, errorUrl: imagePath })
                                              });
                                          } else if (data) {
                                              returnImgUrl = imagePath;
                                              that.$("img[data-imgGuid='" + obj.guid + "']").removeClass("searchTableLogoLoader").attr("src", imagePath);
                                          }
                                      });
                              }
                              var img = "",
                                  isIncompleteClass = "isIncomplete search-result-page";
                              if (obj.isIncomplete === true) {
                                  isIncompleteClass += " show";
                              }
                              img = "<div class='" + isIncompleteClass + "'><img data-imgGuid='" + obj.guid + "' class='searchTableLogoLoader'><i class='fa fa-hourglass-half'></i></div>";
                              getImageData({ imagePath: Utils.getEntityIconPath({ entityData: obj }) });
                              return (img + nameHtml);
                          }
                      })
                  };
  
                  col['owner'] = {
                      label: "Owner",
                      cell: "String",
                      editable: false,
                      resizeable: true,
                      orderable: true,
                      renderable: true,
                      formatter: _.extend({}, Backgrid.CellFormatter.prototype, {
                          fromRaw: function(rawValue, model) {
                              var obj = model.toJSON();
                              if (obj && obj.attributes && obj.attributes.owner) {
                                  return obj.attributes.owner;
                              }
                          }
                      })
                  };
  
  
                  if (this.value && this.value.profileDBView) {
                      col['createTime'] = {
                          label: "Date Created",
                          cell: "Html",
                          editable: false,
                          formatter: _.extend({}, Backgrid.CellFormatter.prototype, {
                              fromRaw: function(rawValue, model) {
                                  var obj = model.toJSON();
                                  if (obj && obj.attributes && obj.attributes.createTime) {
                                      return new Date(obj.attributes.createTime);
                                  } else {
                                      return '-'
                                  }
                              }
                          })
                      }
                  }
                  if (this.value && !this.value.profileDBView) {
  
                      col['description'] = {
                          label: "Description",
                          cell: "String",
                          editable: false,
                          resizeable: true,
                          orderable: true,
                          renderable: true,
                          formatter: _.extend({}, Backgrid.CellFormatter.prototype, {
                              fromRaw: function(rawValue, model) {
                                  var obj = model.toJSON();
                                  if (obj && obj.attributes && obj.attributes.description) {
                                      return obj.attributes.description;
                                  }
                              }
                          })
                      };
  
  
                      col['typeName'] = {
                          label: "Type",
                          cell: "Html",
                          editable: false,
                          resizeable: true,
                          orderable: true,
                          renderable: (columnToShow ? _.contains(columnToShow, 'typeName') : true),
                          formatter: _.extend({}, Backgrid.CellFormatter.prototype, {
                              fromRaw: function(rawValue, model) {
                                  var obj = model.toJSON();
                                  if (obj && obj.typeName) {
                                      return '<a title="Search ' + obj.typeName + '" href="#!/search/searchResult?type=' + obj.typeName + '&searchType=basic">' + obj.typeName + '</a>';
                                  }
                              }
                          })
                      };
                      col['namespace'] = {
                          label: "Namespaces",
                          cell: "Html",
                          editable: false,
                          resizeable: true,
                          orderable: true,
                          alwaysVisible: true, //Backgrid.ColumnManager.js -> render() to hide the name in dropdownlist
                          renderable: _.contains(columnToShow, 'namespace'),
                          formatter: _.extend({}, Backgrid.CellFormatter.prototype, {
                              fromRaw: function(rawValue, model) {
                                  var obj = model.toJSON(),
                                      namespaceStr = '';
                                  if (obj && obj.attributes) {
                                      _.each(obj.attributes, function(namespaceValue, attributeName) {
                                          if (attributeName.indexOf('.') != -1) {
                                              var isDate = false,
                                                  namespace = that.options.nameSpaceCollection.fullCollection.find({ "name": attributeName.split('.')[0] });
                                              if (namespace) {
                                                  var getAttributes = namespace.get('attributeDefs');
                                                  getAttributes.every(function(attrTypeCheck) {
                                                      if (attributeName.split('.')[1] === attrTypeCheck.name && attrTypeCheck.typeName.indexOf("date") > -1) {
                                                          isDate = true;
                                                      }
                                                      return !isDate;
                                                  });
                                              }
                                              if (isDate) {
                                                  namespaceValue = moment(namespaceValue).format("MM/DD/YYYY")
                                              }
                                              namespaceStr += '<label class="btn btn-action btn-xs btn-blue no-pointer">' + attributeName + ': ' + namespaceValue + '</label>';
                                          }
                                      })
                                      return namespaceStr;
                                  }
                              }
                          })
                      };
                      this.getTagCol({ 'col': col, 'columnToShow': columnToShow });
                      if ((!_.contains(["glossary"], this.fromView))) {
                          this.getTermCol({ 'col': col, 'columnToShow': columnToShow });
                      }
  
                      if (this.value && this.value.searchType === "basic") {
                          var def = this.entityDefCollection.fullCollection.find({ name: this.value.type }),
                              systemAttr = [];
                          if (def || Globals[this.value.type] || (
                                  this.value.tag ?
                                  Globals[this.value.tag] ?
                                  Globals[this.value.tag] :
                                  Globals[Enums.addOnClassification[0]] :
                                  undefined)) {
                              var attrObj = def ? Utils.getNestedSuperTypeObj({ data: def.toJSON(), collection: this.entityDefCollection, attrMerge: true }) : [];
                              if (this.value.type && (Globals[this.value.type] || Globals[Enums.addOnEntities[0]])) {
                                  systemAttr = (Globals[this.value.type] || Globals[Enums.addOnEntities[0]]).attributeDefs;
                              }
                              if (this.value.tag && (Globals[this.value.tag] || Globals[Enums.addOnClassification[0]])) {
                                  systemAttr = (Globals[this.value.tag] || Globals[Enums.addOnClassification[0]]).attributeDefs;
                              }
                              attrObj = attrObj.concat(systemAttr);
                              _.each(attrObj, function(obj, key) {
                                  var key = obj.name,
                                      isRenderable = _.contains(columnToShow, key),
                                      isSortable = obj.typeName.search(/(array|map)/i) == -1;
                                  if (key == "name" || key == "description" || key == "owner") {
                                      if (columnToShow) {
                                          col[key].renderable = isRenderable;
                                      }
                                      return;
                                  }
                                  if (key == "__historicalGuids" || key == "__classificationsText" || key == "__classificationNames" || key == "__propagatedClassificationNames") {
                                      return;
                                  }
                                  col[obj.name] = {
                                      label: Enums.systemAttributes[obj.name] ? Enums.systemAttributes[obj.name] : _.escape(obj.name).capitalize(),
                                      cell: "Html",
                                      headerCell: Backgrid.HeaderHTMLDecodeCell,
                                      editable: false,
                                      resizeable: true,
                                      orderable: true,
                                      sortable: isSortable,
                                      renderable: isRenderable,
                                      formatter: _.extend({}, Backgrid.CellFormatter.prototype, {
                                          fromRaw: function(rawValue, model) {
                                              var modelObj = model.toJSON();
                                              if (modelObj && modelObj.attributes && !_.isUndefined(modelObj.attributes[key])) {
                                                  var tempObj = {
                                                      'scope': that,
                                                      'attributeDefs': [obj],
                                                      'valueObject': {},
                                                      'isTable': false
                                                  };
                                                  if (key == "__labels") {
                                                      var values = modelObj.attributes[key] ? modelObj.attributes[key].split("|") : null,
                                                          valueOfArray = [];
                                                      if (values) {
                                                          if (values[values.length - 1] === "") { values.pop(); }
                                                          if (values[0] === "") { values.shift(); }
                                                          _.each(values, function(names) {
                                                              valueOfArray.push('<span class="json-string"><a class="btn btn-action btn-sm btn-blue btn-icon" ><span title="" data-original-title="' + names + '" >' + names + '</span></a></span>');
                                                          });
                                                          return valueOfArray.join(' ');
                                                      }
                                                  }
                                                  if (key == "__customAttributes") {
                                                      var customAttributes = modelObj.attributes[key] ? JSON.parse(modelObj.attributes[key]) : null,
                                                          valueOfArray = [];
                                                      if (customAttributes) {
                                                          _.each(Object.keys(customAttributes), function(value, index) {
                                                              valueOfArray.push('<span class="json-string"><a class="btn btn-action btn-sm btn-blue btn-icon" ><span title="" data-original-title="' + value + ' : ' + Object.values(customAttributes)[index] + '" ><span>' + value + '</span> : <span>' + Object.values(customAttributes)[index] + '</span></span></a></span>');
                                                          });
                                                          return valueOfArray.join(' ');
                                                      }
                                                  }
                                                  tempObj.valueObject[key] = modelObj.attributes[key];
                                                  var tablecolumn = CommonViewFunction.propertyTable(tempObj);
                                                  if (_.isArray(modelObj.attributes[key])) {
                                                      var column = $("<div>" + tablecolumn + "</div>")
                                                      if (tempObj.valueObject[key].length > 2) {
                                                          column.addClass("toggleList semi-collapsed").append("<span><a data-id='load-more-columns'>Show More</a></span>");
                                                      }
                                                      return column;
                                                  }
                                                  return tablecolumn;
                                              }
                                          }
                                      })
                                  };
                              });
                          }
                      }
                  }
                  return this.searchCollection.constructor.getTableCols(col, this.searchCollection);
              },
              onClickLoadMore: function() {
                  var that = this;
                  this.$el.on('click', "[data-id='load-more-columns']", function(event) {
                      event.stopPropagation();
                      event.stopImmediatePropagation();
                      var $this = $(this),
                          $toggleList = $(this).parents('.toggleList');
                      if ($toggleList.length) {
                          if ($toggleList.hasClass('semi-collapsed')) {
                              $toggleList.removeClass('semi-collapsed');
                              $this.text("Show Less");
                          } else {
                              $toggleList.addClass('semi-collapsed');
                              $this.text("Show More");
                          }
                      }
                  });
              },
              getDaynamicColumns: function(valueObj) {
                  var that = this,
                      col = {};
                  if (valueObj && valueObj.length) {
                      var firstObj = _.first(valueObj);
                      _.each(_.keys(firstObj), function(key) {
                          col[key] = {
                              label: key.capitalize(),
                              cell: "Html",
                              editable: false,
                              resizeable: true,
                              orderable: true,
                              formatter: _.extend({}, Backgrid.CellFormatter.prototype, {
                                  fromRaw: function(rawValue, model) {
                                      var modelObj = model.toJSON();
                                      if (key == "name") {
                                          var nameHtml = "",
                                              name = modelObj[key];
                                          if (modelObj.guid) {
                                              nameHtml = '<a title="' + name + '" href="#!/detailPage/' + modelObj.guid + (that.fromView ? "?from=" + that.fromView : "") + '">' + name + '</a>';
                                          } else {
                                              nameHtml = '<span title="' + name + '">' + name + '</span>';
                                          }
                                          if (modelObj.status && Enums.entityStateReadOnly[modelObj.status]) {
                                              nameHtml += '<button type="button" title="Deleted" class="btn btn-action btn-md deleteBtn"><i class="fa fa-trash"></i></button>';
                                              return '<div class="readOnly readOnlyLink">' + nameHtml + '</div>';
                                          }
                                          return nameHtml;
                                      } else if (modelObj && !_.isUndefined(modelObj[key])) {
                                          var tempObj = {
                                              'scope': that,
                                              // 'attributeDefs':
                                              'valueObject': {},
                                              'isTable': false
                                          };
                                          tempObj.valueObject[key] = modelObj[key];
                                          return CommonViewFunction.propertyTable(tempObj);
                                      }
                                  }
                              })
                          };
                      });
                  }
                  return this.searchCollection.constructor.getTableCols(col, this.searchCollection);
              },
              getTagCol: function(options) {
                  var that = this,
                      columnToShow = options.columnToShow,
                      col = options.col;
                  if (col) {
                      col['tag'] = {
                          label: "Classifications",
                          cell: "Html",
                          editable: false,
                          sortable: false,
                          resizeable: true,
                          orderable: true,
                          renderable: (columnToShow ? _.contains(columnToShow, 'tag') : true),
                          className: 'searchTag',
                          formatter: _.extend({}, Backgrid.CellFormatter.prototype, {
                              fromRaw: function(rawValue, model) {
                                  var obj = model.toJSON();
                                  if (obj.guid == "-1") {
                                      return
                                  }
                                  if (obj.status && Enums.entityStateReadOnly[obj.status]) {
                                      return '<div class="readOnly">' + CommonViewFunction.tagForTable(obj); + '</div>';
                                  } else {
                                      return CommonViewFunction.tagForTable(obj);
                                  }
  
                              }
                          })
                      };
                  }
              },
              getTermCol: function(options) {
                  var that = this,
                      columnToShow = options.columnToShow,
                      col = options.col;
                  if (col) {
                      col['term'] = {
                          label: "Term",
                          cell: "Html",
                          editable: false,
                          sortable: false,
                          resizeable: true,
                          orderable: true,
                          renderable: (columnToShow ? _.contains(columnToShow, 'term') : true),
                          className: 'searchTag',
                          formatter: _.extend({}, Backgrid.CellFormatter.prototype, {
                              fromRaw: function(rawValue, model) {
                                  var obj = model.toJSON();
                                  if (obj.guid == "-1") {
                                      return
                                  }
                                  if (obj.typeName && !(_.startsWith(obj.typeName, "AtlasGlossary"))) {
                                      if (obj.status && Enums.entityStateReadOnly[obj.status]) {
                                          return '<div class="readOnly">' + CommonViewFunction.termForTable(obj); + '</div>';
                                      } else {
                                          return CommonViewFunction.termForTable(obj);
                                      }
                                  }
                              }
                          })
                      };
                  }
              },
              addTagModalView: function(guid, multiple) {
                  var that = this;
                  require(['views/tag/AddTagModalView'], function(AddTagModalView) {
                      var view = new AddTagModalView({
                          guid: guid,
                          multiple: multiple,
                          callback: function() {
                              if (that.searchVent) {
                                  that.searchVent.trigger("Classification:Count:Update");
                              }
                              that.multiSelectEntity = [];
                              that.$('.multiSelectTag,.multiSelectTerm').hide();
                              that.fetchCollection();
                          },
                          tagList: that.getTagList(guid, multiple),
                          showLoader: that.showLoader.bind(that),
                          hideLoader: that.hideLoader.bind(that),
                          collection: that.classificationDefCollection,
                          enumDefCollection: that.enumDefCollection
                      });
                  });
              },
              getTagList: function(guid, multiple) {
                  var that = this;
                  if (!multiple || multiple.length === 0) {
                      var model = this.searchCollection.find(function(item) {
                          var obj = item.toJSON();
                          if (obj.guid === guid) {
                              return true;
                          }
                      });
                      if (model) {
                          var obj = model.toJSON();
                      } else {
                          return [];
                      }
                      return _.compact(_.map(obj.classifications, function(val) {
                          if (val.entityGuid == guid) {
                              return val.typeName
                          }
                      }));
                  } else {
                      return [];
                  }
              },
              showLoader: function() {
                  this.$('.fontLoader:not(.for-ignore)').addClass('show');
                  this.$('.tableOverlay').addClass('show');
              },
              hideLoader: function(options) {
                  this.$('.fontLoader:not(.for-ignore)').removeClass('show');
                  this.$('.ellipsis-with-margin').show();
                  options && options.type === 'error' ? $('.pagination-box').hide() : this.$('.pagination-box').show(); // only show for first time and hide when type is error
                  this.$('.tableOverlay').removeClass('show');
              },
              onClickAddTag: function(e) {
                  var guid = "",
                      that = this,
                      isTagMultiSelect = $(e.currentTarget).hasClass('multiSelectTag');
                  if (isTagMultiSelect && this.multiSelectEntity && this.multiSelectEntity.length) {
                      that.addTagModalView(guid, this.multiSelectEntity);
                  } else {
                      guid = that.$(e.currentTarget).data("guid");
                      that.addTagModalView(guid);
                  }
              },
              onClickAddTermBtn: function(e) {
                  var that = this,
                      guid = "",
                      entityGuid = $(e.currentTarget).data("guid"),
                      associatedTerms = undefined,
                      multiple = undefined,
                      isTermMultiSelect = $(e.currentTarget).hasClass('multiSelectTerm');
                  if (isTermMultiSelect && this.multiSelectEntity && this.multiSelectEntity.length) {
                      multiple = this.multiSelectEntity;
                  } else if (entityGuid) {
                      associatedTerms = this.searchCollection.find({ guid: entityGuid }).get('meanings');
                  }
                  require(['views/glossary/AssignTermLayoutView'], function(AssignTermLayoutView) {
                      var view = new AssignTermLayoutView({
                          guid: entityGuid,
                          multiple: multiple,
                          associatedTerms: associatedTerms,
                          callback: function() {
                              that.multiSelectEntity = [];
                              that.$('.multiSelectTag,.multiSelectTerm').hide();
                              that.fetchCollection();
  
                          },
                          glossaryCollection: that.glossaryCollection,
                      });
                  });
              },
              onClickTagCross: function(e) {
                  var that = this,
                      tagName = $(e.target).data("name"),
                      guid = $(e.target).data("guid"),
                      entityGuid = $(e.target).data("entityguid"),
                      assetName = $(e.target).data("assetname");
                  CommonViewFunction.deleteTag({
                      tagName: tagName,
                      guid: guid,
                      associatedGuid: guid != entityGuid ? entityGuid : null,
                      msg: "<div class='ellipsis-with-margin'>Remove: " + "<b>" + _.escape(tagName) + "</b> assignment from" + " " + "<b>" + assetName + " ?</b></div>",
                      titleMessage: Messages.removeTag,
                      okText: "Remove",
                      showLoader: that.showLoader.bind(that),
                      hideLoader: that.hideLoader.bind(that),
                      callback: function() {
                          if (that.searchVent) {
                              that.searchVent.trigger("Classification:Count:Update");
                          }
                          that.fetchCollection();
                      }
                  });
  
              },
              onClickTermCross: function(e) {
                  var $el = $(e.target),
                      termGuid = $el.data('termguid'),
                      guid = $el.data('guid'),
                      termName = $(e.currentTarget).text(),
                      assetname = $el.data('assetname'),
                      meanings = this.searchCollection.find({ "guid": guid }).get("meanings"),
                      that = this,
                      termObj = _.find(meanings, { termGuid: termGuid });
                  CommonViewFunction.removeCategoryTermAssociation({
                      termGuid: termGuid,
                      model: {
                          guid: guid,
                          relationshipGuid: termObj.relationGuid
                      },
                      collection: that.glossaryCollection,
                      msg: "<div class='ellipsis-with-margin'>Remove: " + "<b>" + _.escape(termName) + "</b> assignment from" + " " + "<b>" + assetname + "?</b></div>",
                      titleMessage: Messages.glossary.removeTermfromEntity,
                      isEntityView: true,
                      buttonText: "Remove",
                      callback: function() {
                          that.fetchCollection();
                      }
                  });
              },
              onClicknextData: function() {
                  this.offset = this.offset + this.limit;
                  _.extend(this.searchCollection.queryParams, {
                      offset: this.offset
                  });
                  if (this.value) {
                      this.value.pageOffset = this.offset;
                      this.triggerUrl();
                  }
                  this.fetchCollection(null, {
                      next: true
                  });
              },
              onClickpreviousData: function() {
                  this.offset = this.offset - this.limit;
                  if (this.offset <= -1) {
                      this.offset = 0;
                  }
                  _.extend(this.searchCollection.queryParams, {
                      offset: this.offset
                  });
                  if (this.value) {
                      this.value.pageOffset = this.offset;
                      this.triggerUrl();
                  }
                  this.fetchCollection(null, {
                      previous: true
                  });
              },
              onClickCreateEntity: function(e) {
                  var that = this;
                  $(e.currentTarget).blur();
                  require([
                      'views/entity/CreateEntityLayoutView'
                  ], function(CreateEntityLayoutView) {
                      var view = new CreateEntityLayoutView({
                          entityDefCollection: that.entityDefCollection,
                          typeHeaders: that.typeHeaders,
                          searchVent: that.searchVent,
                          callback: function() {
                              that.fetchCollection();
                          }
                      });
                  });
              },
              onCheckExcludeIncludeResult: function(e) {
                  var flag = false,
                      val = $(e.currentTarget).attr('data-value');
                  if (e.target.checked) {
                      flag = true;
                  }
                  if (this.value) {
                      this.value[val] = flag;
                      this.triggerUrl();
                  }
                  _.extend(this.searchCollection.queryParams, { limit: this.limit, offset: this.offset });
                  this.fetchCollection();
  
              },
              changePageLimit: function(e, obj) {
                  if (!obj || (obj && !obj.skipViewChange)) {
                      var limit = parseInt(this.ui.showPage.val());
                      if (limit == 0) {
                          this.ui.showPage.data('select2').$container.addClass('has-error');
                          return;
                      } else {
                          this.ui.showPage.data('select2').$container.removeClass('has-error');
                      }
                      this.limit = limit;
                      this.offset = 0;
                      if (this.value) {
                          this.value.pageLimit = this.limit;
                          this.value.pageOffset = this.offset;
                          this.triggerUrl();
                      }
                      _.extend(this.searchCollection.queryParams, { limit: this.limit, offset: this.offset });
                      this.fetchCollection();
                  }
              },
              gotoPagebtn: function(e) {
                  var that = this;
                  var goToPage = parseInt(this.ui.gotoPage.val());
                  if (!(_.isNaN(goToPage) || goToPage <= -1)) {
                      if (this.finalPage && this.finalPage < goToPage) {
                          Utils.notifyInfo({
                              html: true,
                              content: Messages.search.noRecordForPage + '<b>' + Utils.getNumberSuffix({ number: goToPage, sup: true }) + '</b> page'
                          });
                          return;
                      }
                      this.offset = (goToPage - 1) * this.limit;
                      if (this.offset <= -1) {
                          this.offset = 0;
                      }
                      _.extend(this.searchCollection.queryParams, { limit: this.limit, offset: this.offset });
                      if (this.offset == (this.pageFrom - 1)) {
                          Utils.notifyInfo({
                              content: Messages.search.onSamePage
                          });
                      } else {
                          if (this.value) {
                              this.value.pageOffset = this.offset;
                              this.triggerUrl();
                          }
                          // this.offset is updated in gotoPagebtn function so use next button calculation.
                          this.fetchCollection(null, { 'next': true });
                      }
                  }
              }
          });
      return SearchResultLayoutView;
  });