661 lines
32 KiB
JavaScript
661 lines
32 KiB
JavaScript
/**
|
|
* 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',
|
|
'hbs!tmpl/business_catalog/TreeLayoutView_tmpl',
|
|
'utils/Utils',
|
|
'collection/VCatalogList',
|
|
'utils/CommonViewFunction',
|
|
'utils/Messages',
|
|
'utils/UrlLinks'
|
|
], function(require, Backbone, TreeLayoutView_tmpl, Utils, VCatalogList, CommonViewFunction, Messages, UrlLinks) {
|
|
'use strict';
|
|
|
|
var TreeLayoutView = Backbone.Marionette.LayoutView.extend(
|
|
/** @lends TreeLayoutView */
|
|
{
|
|
_viewName: 'TreeLayoutView',
|
|
|
|
template: TreeLayoutView_tmpl,
|
|
|
|
/** Layout sub regions */
|
|
regions: {},
|
|
/** ui selector cache */
|
|
ui: {
|
|
Parent: '[data-id="Parent"]',
|
|
childList: '[data-id="childList"]',
|
|
liClick: 'li a[data-href]',
|
|
backTaxanomy: '[data-id="backTaxanomy"]',
|
|
expandArrow: '[data-id="expandArrow"]',
|
|
searchTermInput: '[data-id="searchTermInput"]',
|
|
refreshTaxanomy: '[data-id="refreshTaxanomy"]',
|
|
descriptionAssign: '[data-id="descriptionAssign"]',
|
|
},
|
|
/** ui events hash */
|
|
events: function() {
|
|
var events = {};
|
|
events['dblclick ' + this.ui.liClick] = function(e) {
|
|
this.changeArrowState(e);
|
|
};
|
|
events['click ' + this.ui.liClick] = function(e) {
|
|
var that = this;
|
|
that.addActiveClass(e);
|
|
that.url = $(e.currentTarget).data('href');
|
|
if (this.viewBased) {
|
|
Utils.setUrl({
|
|
url: '#!/taxonomy/detailCatalog' + that.url,
|
|
mergeBrowserUrl: false,
|
|
updateTabState: function() {
|
|
return { taxonomyUrl: this.url, stateChanged: true };
|
|
},
|
|
trigger: true
|
|
});
|
|
}
|
|
};
|
|
events['click ' + this.ui.backTaxanomy] = 'backButtonTaxanomy';
|
|
events['click ' + this.ui.refreshTaxanomy] = 'refreshButtonTaxanomy';
|
|
events['click ' + this.ui.expandArrow] = 'changeArrowState';
|
|
events["change " + this.ui.searchTermInput] = function() {
|
|
var termUrl = this.termCollection.url.split("/", 5).join("/") + "/" + this.ui.searchTermInput.val().split(".").join("/terms/");
|
|
this.fetchCollection(termUrl, true);
|
|
if (this.viewBased) {
|
|
Utils.setUrl({
|
|
url: "#!/taxonomy/detailCatalog" + termUrl,
|
|
mergeBrowserUrl: false,
|
|
trigger: true,
|
|
updateTabState: function() {
|
|
return { taxonomyUrl: this.url, stateChanged: true };
|
|
}
|
|
});
|
|
}
|
|
};
|
|
return events;
|
|
},
|
|
/**
|
|
* intialize a new TreeLayoutView Layout
|
|
* @constructs
|
|
*/
|
|
initialize: function(options) {
|
|
_.extend(this, _.pick(options, 'url', 'viewBased'));
|
|
this.parentCollection = new VCatalogList();
|
|
this.childCollection = new VCatalogList();
|
|
this.taxanomy = new VCatalogList();
|
|
this.termCollection = new VCatalogList();
|
|
},
|
|
bindEvents: function() {
|
|
var that = this;
|
|
this.listenTo(this.parentCollection, 'reset', function() {
|
|
if (this.parentCollection.fullCollection.models.length) {
|
|
this.generateTree(true);
|
|
} else {
|
|
if (Utils.getUrlState.isTaxonomyTab() || Utils.getUrlState.isInitial()) {
|
|
this.createDefaultTaxonomy();
|
|
}
|
|
}
|
|
}, this);
|
|
this.listenTo(this.childCollection, 'reset', function() {
|
|
this.generateTree();
|
|
}, this);
|
|
this.listenTo(this.taxanomy, 'reset', function() {
|
|
this.searchResult();
|
|
}, this);
|
|
this.listenTo(this.termCollection, 'reset', function() {
|
|
this.termSearchData();
|
|
}, this);
|
|
this.listenTo(this.childCollection, 'error', function(model, response) {
|
|
this.hideLoader();
|
|
}, this);
|
|
this.listenTo(this.parentCollection, 'error', function(model, response) {
|
|
this.hideLoader();
|
|
}, this);
|
|
},
|
|
onRender: function() {
|
|
var that = this;
|
|
this.bindEvents();
|
|
that.ui.backTaxanomy.hide();
|
|
this.fetchCollection(this.url, true);
|
|
this.$el.on("click", '.termPopoverList li', function(e) {
|
|
that[$(this).find("a").data('fn')](e);
|
|
});
|
|
$('body').click(function(e) {
|
|
if (that.$('.termPopoverList').length) {
|
|
if ($(e.target).hasClass('termPopover')) {
|
|
return;
|
|
}
|
|
that.$('.termPopover').popover('hide');
|
|
}
|
|
});
|
|
this.fetchTaxanomyCollections();
|
|
if (!this.viewBased) {
|
|
this.ui.descriptionAssign.show();
|
|
} else {
|
|
this.ui.descriptionAssign.hide();
|
|
}
|
|
},
|
|
backButtonTaxanomy: function(e) {
|
|
var that = this;
|
|
this.backButton = true;
|
|
var dataURL = this.$('.taxonomyTree').find('li[data-id="Parent"]').find("a").data('href').split("/terms");
|
|
var backUrl = dataURL.pop();
|
|
if (dataURL.join("/terms").length) {
|
|
this.ui.backTaxanomy.show();
|
|
var currentURL = "#!/taxonomy/detailCatalog" + dataURL.join("/terms");
|
|
this.fetchCollection(dataURL.join("/terms"), true);
|
|
this.url = dataURL.join("/terms");
|
|
if (this.viewBased) {
|
|
Utils.setUrl({
|
|
url: currentURL,
|
|
mergeBrowserUrl: false,
|
|
trigger: true,
|
|
updateTabState: function() {
|
|
return { taxonomyUrl: this.url, stateChanged: true };
|
|
}
|
|
});
|
|
}
|
|
}
|
|
},
|
|
manualRender: function(url) {
|
|
var splitUrl = this.url.split('/terms');
|
|
if (url && this.url != url) {
|
|
if (splitUrl.length > 1 && splitUrl[splitUrl.length - 1] == "") {
|
|
var checkUrl = splitUrl;
|
|
checkUrl.pop();
|
|
if (url != checkUrl) {
|
|
this.fetchCollection(url, true);
|
|
}
|
|
} else if (Utils.getUrlState.getQueryParams() && Utils.getUrlState.getQueryParams().load == "true") {
|
|
if (this.viewBased) {
|
|
Utils.setUrl({
|
|
url: "#!/taxonomy/detailCatalog" + url,
|
|
mergeBrowserUrl: false,
|
|
trigger: false,
|
|
updateTabState: function() {
|
|
return { taxonomyUrl: this.url, stateChanged: true };
|
|
}
|
|
});
|
|
}
|
|
this.fetchCollection(url, true);
|
|
} else {
|
|
this.fetchCollection(url, true);
|
|
}
|
|
}
|
|
if (!url && Utils.getUrlState.isTaxonomyTab()) {
|
|
this.selectFirstElement();
|
|
}
|
|
},
|
|
changeArrowState: function(e) {
|
|
var scope = this.$('[data-id="expandArrow"]');
|
|
if (e) {
|
|
scope = $(e.currentTarget);
|
|
}
|
|
if (scope.is('a')) {
|
|
var url = scope.data('href');
|
|
scope = scope.parent().find("i.toggleArrow");
|
|
} else if (scope.is('i')) {
|
|
var url = scope.parent().find("a").data('href');
|
|
}
|
|
if (scope.hasClass('fa-angle-down')) {
|
|
scope.toggleClass('fa-angle-right fa-angle-down');
|
|
this.ui.childList.hide();
|
|
} else {
|
|
if (e && $(e.currentTarget).parents('li.parentChild').length) {
|
|
scope.parent('li').find('.tools .taxanomyloader').show();
|
|
this.url = url;
|
|
this.fetchCollection(url, true);
|
|
if (this.viewBased) {
|
|
Utils.setUrl({
|
|
url: "#!/taxonomy/detailCatalog" + url,
|
|
mergeBrowserUrl: false,
|
|
trigger: true,
|
|
updateTabState: function() {
|
|
return { taxonomyUrl: this.url, stateChanged: true };
|
|
}
|
|
});
|
|
}
|
|
} else {
|
|
scope.toggleClass('fa-angle-right fa-angle-down');
|
|
this.ui.childList.show();
|
|
}
|
|
}
|
|
},
|
|
fetchCollection: function(url, isParent) {
|
|
if (url) {
|
|
this.url = url;
|
|
} else {
|
|
var parentURL = this.ui.Parent.find('a').data('href');
|
|
if (parentURL) {
|
|
this.url = parentURL;
|
|
} else {
|
|
this.url = UrlLinks.taxonomiesApiUrl();
|
|
}
|
|
}
|
|
this.showLoader();
|
|
if (isParent) {
|
|
this.parentCollection.url = this.url;
|
|
this.parentCollection.fullCollection.reset(undefined, { silent: true });
|
|
this.parentCollection.fetch({ reset: true, cache: true });
|
|
} else {
|
|
this.childCollection.url = this.url + "?hierarchy/path:.";
|
|
this.childCollection.fullCollection.reset(undefined, { silent: true });
|
|
this.childCollection.fetch({ reset: true, cache: true });
|
|
}
|
|
},
|
|
showLoader: function() {
|
|
this.$('.taxonomyTree').find('li.active .tools .taxanomyloader').show();
|
|
this.$('.contentLoading').show();
|
|
},
|
|
hideLoader: function() {
|
|
this.$('.taxanomyloader').hide();
|
|
this.$('.contentLoading').hide();
|
|
},
|
|
addActiveClass: function(e) {
|
|
this.$('ul.taxonomyTree').find('li').removeClass('active');
|
|
if (e.jquery) {
|
|
e.parent('li').addClass('active');
|
|
} else {
|
|
if (e.currentTarget) {
|
|
$(e.currentTarget).parent('li').addClass('active');
|
|
} else {
|
|
if ($(e).parent.length) {
|
|
$(e).parent('li').addClass('active');
|
|
} else {
|
|
$(e).parents('li').addClass('active');
|
|
}
|
|
}
|
|
}
|
|
},
|
|
fetchTaxanomyCollections: function() {
|
|
this.taxanomy.fetch({ reset: true });
|
|
},
|
|
refreshButtonTaxanomy: function() {
|
|
this.fetchTaxanomyCollections();
|
|
var url = "";
|
|
if (this.$('.taxonomyTree').find('.active').parents('.parentChild').length) {
|
|
url = this.$('.taxonomyTree').find('.active a').data('href').split("/").slice(0, -2).join("/");
|
|
this.refresh = this.$('.taxonomyTree').find('.active a').data('href');
|
|
} else {
|
|
url = this.$('.taxonomyTree').find('.active a').data('href');
|
|
this.refresh = this.$('.taxonomyTree').find('.active a').data('href');
|
|
}
|
|
this.fetchCollection(url, true);
|
|
},
|
|
searchResult: function() {
|
|
var that = this;
|
|
_.each(this.taxanomy.models, function(model, key) {
|
|
var name = model.get('name');
|
|
that.termCollection.url = UrlLinks.taxonomiesTermsApiUrl(name)
|
|
});
|
|
this.termCollection.fetch({ reset: true });
|
|
},
|
|
termSearchData: function() {
|
|
var that = this;
|
|
var str = '<option></option>';
|
|
this.termCollection.fullCollection.comparator = function(model) {
|
|
return model.get('name');
|
|
};
|
|
this.termCollection.fullCollection.sort().each(function(model) {
|
|
str += '<option>' + model.get('name') + '</option>';
|
|
});
|
|
this.ui.searchTermInput.html(str);
|
|
// this.ui.searchTermInput.setAttribute('data-href' : that.termCollection.url);
|
|
this.ui.searchTermInput.select2({
|
|
placeholder: "Search Term",
|
|
allowClear: true
|
|
});
|
|
},
|
|
onSearchTerm: function() {
|
|
Utils.setUrl({
|
|
url: '#!/search/searchResult',
|
|
urlParams: {
|
|
query: this.$('.taxonomyTree').find('li.active').find("a").data('name'),
|
|
searchType: "dsl",
|
|
dslChecked: true
|
|
},
|
|
updateTabState: function() {
|
|
return { searchUrl: this.url, stateChanged: true };
|
|
},
|
|
mergeBrowserUrl: false,
|
|
trigger: true
|
|
});
|
|
},
|
|
selectFirstElement: function() {
|
|
var dataURL = this.$('.taxonomyTree').find('li[data-id="Parent"]').find("a").data('href');
|
|
if (dataURL) {
|
|
this.url = dataURL;
|
|
if (this.viewBased && Utils.getUrlState.isTaxonomyTab()) {
|
|
Utils.setUrl({
|
|
url: "#!/taxonomy/detailCatalog" + dataURL,
|
|
mergeBrowserUrl: false,
|
|
trigger: true,
|
|
updateTabState: function() {
|
|
return { taxonomyUrl: this.url, stateChanged: true };
|
|
}
|
|
});
|
|
}
|
|
}
|
|
},
|
|
generateTree: function(isParent) {
|
|
var parentLi = "",
|
|
childLi = "",
|
|
that = this;
|
|
|
|
function createTaxonomy(url) {
|
|
var href = false;
|
|
_.each(that.parentCollection.fullCollection.models, function(model, key) {
|
|
|
|
if (model.get('terms')) {
|
|
href = model.get('terms').href;
|
|
} else if (model.get('href')) {
|
|
href = model.get('href') + "/terms";
|
|
}
|
|
var hrefUrl = "/api" + model.get('href').split("/api")[1];
|
|
if (hrefUrl) {
|
|
var backUrlCheck = hrefUrl.split("taxonomies/");
|
|
if (backUrlCheck.length > 1) {
|
|
if (backUrlCheck[1].split("/terms").length <= 1) {
|
|
that.ui.backTaxanomy.hide();
|
|
} else {
|
|
that.ui.backTaxanomy.show();
|
|
}
|
|
}
|
|
}
|
|
var name = Utils.checkTagOrTerm(model.get('name'), true);
|
|
if (name.name) {
|
|
// data-name="<space>'<tagName>'" Space is required for DSL search Input
|
|
if (that.viewBased) {
|
|
parentLi = '<div class="tools"><i class="fa fa-refresh fa-spin-custom taxanomyloader"></i><i class="fa fa-ellipsis-h termPopover"></i></div><i class="fa fa-angle-right toggleArrow" data-id="expandArrow" data-href="' + hrefUrl + '"></i><a href="javascript:void(0)" data-href="' + hrefUrl + '" data-name="`' + model.get('name') + '`">' + name.name + '</a>';
|
|
} else {
|
|
parentLi = '<div class="tools"><i class="fa fa-refresh fa-spin-custom taxanomyloader"></i></div><i class="fa fa-angle-right toggleArrow" data-id="expandArrow" data-href="' + hrefUrl + '"></i><a href="javascript:void(0)" data-href="' + hrefUrl + '" data-name="`' + model.get('name') + '`">' + name.name + '</a>';
|
|
}
|
|
}
|
|
});
|
|
if (href) {
|
|
var hrefUrl = "/api" + href.split("/api")[1];
|
|
that.fetchCollection(hrefUrl);
|
|
}
|
|
that.ui.childList.html('');
|
|
that.ui.Parent.addClass('active');
|
|
that.ui.Parent.html(parentLi);
|
|
}
|
|
|
|
function createTerm() {
|
|
that.childCollection.fullCollection.comparator = function(model) {
|
|
return model.get('name').toLowerCase();
|
|
};
|
|
that.childCollection.fullCollection.sort().each(function(model, key) {
|
|
var name = Utils.checkTagOrTerm(model.get('name'), true);
|
|
var hrefUrl = "/api" + model.get('href').split("/api")[1];
|
|
if (name.name) {
|
|
if (that.viewBased) {
|
|
childLi += '<li class="children"><div class="tools"><i class="fa fa-refresh fa-spin-custom taxanomyloader"></i><i class="fa fa-ellipsis-h termPopover" ></i></div><i class="fa fa-angle-right toggleArrow" data-id="expandArrow" data-href="' + hrefUrl + '"></i><a href="javascript:void(0)" data-href="' + hrefUrl + '" data-name="`' + model.get('name') + '`">' + name.name + '</a></li>';
|
|
} else {
|
|
childLi += '<li class="children"><div class="tools"><i class="fa fa-refresh fa-spin-custom taxanomyloader"></i></div><i class="fa fa-angle-right toggleArrow" data-id="expandArrow" data-href="' + hrefUrl + '"></i><a href="javascript:void(0)" data-href="' + hrefUrl + '" data-name="`' + model.get('name') + '`">' + name.name + '</a></li>';
|
|
}
|
|
}
|
|
});
|
|
that.ui.childList.html(childLi);
|
|
}
|
|
if (isParent) {
|
|
createTaxonomy();
|
|
} else {
|
|
this.changeArrowState();
|
|
createTerm();
|
|
if (Utils.getUrlState.isInitial() || Utils.getUrlState.getQueryUrl().lastValue == "taxonomy") {
|
|
this.selectFirstElement();
|
|
}
|
|
if (this.refresh) {
|
|
this.addActiveClass(this.$('.taxonomyTree').find('a[data-href="' + this.refresh + '"]'));
|
|
this.refresh = undefined;
|
|
}
|
|
}
|
|
this.hideLoader();
|
|
if (this.viewBased) {
|
|
this.$('.termPopover').popover({
|
|
placement: 'bottom',
|
|
html: true,
|
|
trigger: 'manual',
|
|
container: this.$el,
|
|
template: '<div class="popover fixedPopover fade bottom in"><div class="arrow"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>',
|
|
content: function() {
|
|
var li = "<li class='listTerm'><i class='fa fa-plus'></i> <a href='javascript:void(0)' data-fn='onAddTerm'>Create Subterm</a></li>";
|
|
/* "<li class='listTerm' ><i class='fa fa-arrow-right'></i> <a href='javascript:void(0)' data-fn='moveTerm'>Move Term</a></li>" +
|
|
"<li class='listTerm' ><i class='fa fa-edit'></i> <a href='javascript:void(0)' data-fn='onEditTerm'>Edit Term</a></li>" +*/
|
|
var termDataURL = Utils.getUrlState.getQueryUrl().hash.split("terms");
|
|
if (termDataURL.length > 1) {
|
|
li = "<li class='listTerm' ><i class='fa fa-search'></i> <a href='javascript:void(0)' data-fn='onSearchTerm'>Search Assets</a></li>" + li;
|
|
li += "<li class='listTerm'><i class='fa fa-trash'></i> <a href='javascript:void(0)' data-fn='deleteTerm'>Delete Term</a></li>";
|
|
}
|
|
return "<ul class='termPopoverList'>" + li + "</ul>";
|
|
}
|
|
});
|
|
this.$('.termPopover').off('click').on('click', function(e) {
|
|
// if any other popovers are visible, hide them
|
|
e.preventDefault();
|
|
that.$('.termPopover').not(this).popover('hide');
|
|
$(this).popover('show');
|
|
});
|
|
}
|
|
},
|
|
onAddTerm: function(e) {
|
|
var that = this;
|
|
require([
|
|
'views/business_catalog/AddTermLayoutView',
|
|
'modules/Modal'
|
|
], function(AddTermLayoutView, Modal) {
|
|
var view = new AddTermLayoutView({
|
|
url: that.$('.taxonomyTree').find('li.active').find("a").data("href"),
|
|
model: new that.parentCollection.model()
|
|
});
|
|
var modal = new Modal({
|
|
title: 'Create Sub-term',
|
|
content: view,
|
|
okCloses: true,
|
|
showFooter: true,
|
|
allowCancel: true,
|
|
okText: 'Create',
|
|
}).open();
|
|
modal.$el.find('button.ok').attr('disabled', true);
|
|
modal.on('ok', function() {
|
|
that.saveAddTerm(view);
|
|
});
|
|
view.ui.termName.on('keyup', function() {
|
|
if (this.value.indexOf(' ') >= 0) {
|
|
modal.$el.find('button.ok').prop('disabled', true);
|
|
view.ui.termName.addClass("addTermDisable");
|
|
view.$('.alertTerm').show();
|
|
} else {
|
|
modal.$el.find('button.ok').prop('disabled', false);
|
|
view.ui.termName.removeClass("addTermDisable");
|
|
view.$('.alertTerm').hide();
|
|
}
|
|
});
|
|
view.on('closeModal', function() {
|
|
modal.trigger('cancel');
|
|
});
|
|
|
|
});
|
|
},
|
|
saveAddTerm: function(view) {
|
|
var that = this;
|
|
var url = view.url;
|
|
view.model.url = url + "/terms/" + view.ui.termName.val();
|
|
this.showLoader();
|
|
view.model.set({ description: view.ui.termDetail.val() }).save(null, {
|
|
success: function(model, response) {
|
|
that.create = true;
|
|
that.fetchTaxanomyCollections();
|
|
that.fetchCollection(url, true);
|
|
Utils.notifySuccess({
|
|
content: "Term " + view.ui.termName.val() + Messages.addSuccessMessage
|
|
});
|
|
},
|
|
complete: function() {
|
|
that.hideLoader();
|
|
}
|
|
});
|
|
},
|
|
deleteTerm: function(e) {
|
|
var termName = this.$('.taxonomyTree').find('li.active a').data("name"),
|
|
assetName = $(e.target).data("assetname"),
|
|
that = this,
|
|
modal = CommonViewFunction.deleteTagModel({
|
|
msg: "<div class='ellipsis'>Delete: " + "<b>" + _.escape(termName) + "?</b></div>" +
|
|
"<p class='termNote'>Assets mapped to this term will be unclassified.</p>",
|
|
titleMessage: Messages.deleteTerm,
|
|
buttonText: "Delete"
|
|
});
|
|
modal.on('ok', function() {
|
|
that.deleteTermData(e);
|
|
});
|
|
modal.on('closeModal', function() {
|
|
modal.trigger('cancel');
|
|
});
|
|
},
|
|
deleteTermData: function(e) {
|
|
var that = this;
|
|
this.showLoader();
|
|
require(['models/VCatalog'], function(VCatalog) {
|
|
var termModel = new VCatalog(),
|
|
url = that.$('.taxonomyTree').find('li.active a').data('href');
|
|
var termName = that.$('.taxonomyTree').find('li.active a').text();
|
|
termModel.deleteTerm(url, {
|
|
skipDefaultError: true,
|
|
success: function(data) {
|
|
Utils.notifySuccess({
|
|
content: "Term " + termName + Messages.deleteSuccessMessage
|
|
});
|
|
var termURL = url.split("/").slice(0, -2).join("/");
|
|
if (that.viewBased) {
|
|
Utils.setUrl({
|
|
url: "#!/taxonomy/detailCatalog" + termURL,
|
|
mergeBrowserUrl: false,
|
|
trigger: true,
|
|
updateTabState: function() {
|
|
return { taxonomyUrl: this.url, stateChanged: true };
|
|
}
|
|
});
|
|
}
|
|
that.fetchCollection(termURL, true);
|
|
},
|
|
cust_error: function(model, response) {
|
|
var message = "Term " + termName + Messages.deleteErrorMessage;
|
|
if (response && response.responseJSON) {
|
|
message = response.responseJSON.errorMessage;
|
|
}
|
|
Utils.notifyError({
|
|
content: message
|
|
});
|
|
},
|
|
complete: function() {
|
|
that.hideLoader();
|
|
}
|
|
});
|
|
});
|
|
},
|
|
moveTerm: function() {
|
|
var that = this;
|
|
require([
|
|
'views/business_catalog/MoveTermLayoutView',
|
|
'modules/Modal'
|
|
], function(MoveTermLayoutView, Modal) {
|
|
var view = new MoveTermLayoutView({
|
|
taxanomyCollection: that.collection
|
|
});
|
|
var modal = new Modal({
|
|
title: 'Move Term',
|
|
content: view,
|
|
okCloses: true,
|
|
showFooter: true,
|
|
allowCancel: true,
|
|
okText: 'Move',
|
|
}).open();
|
|
// modal.on('ok', function() {
|
|
// that.saveAddTerm(view);
|
|
// });
|
|
view.on('closeModal', function() {
|
|
modal.trigger('cancel');
|
|
});
|
|
});
|
|
},
|
|
createDefaultTaxonomy: function() {
|
|
var that = this;
|
|
require([
|
|
'views/business_catalog/AddTermLayoutView',
|
|
'modules/Modal'
|
|
], function(AddTermLayoutView, Modal) {
|
|
var view = new AddTermLayoutView({
|
|
url: UrlLinks.taxonomiesApiUrl(),
|
|
model: new that.parentCollection.model(),
|
|
defaultTerm: true
|
|
});
|
|
var modal = new Modal({
|
|
title: 'Taxonomy',
|
|
content: view,
|
|
okCloses: true,
|
|
showFooter: true,
|
|
allowCancel: true,
|
|
okText: 'Create',
|
|
}).open();
|
|
modal.$el.find('button.ok').attr('disabled', true);
|
|
modal.on('ok', function() {
|
|
that.saveDefaultTaxonomy(view);
|
|
});
|
|
view.ui.termName.on('keyup', function() {
|
|
if (this.value.indexOf(' ') >= 0) {
|
|
modal.$el.find('button.ok').prop('disabled', true);
|
|
view.ui.termName.addClass("addTermDisable");
|
|
view.$('.alertTerm').show();
|
|
} else {
|
|
modal.$el.find('button.ok').prop('disabled', false);
|
|
view.ui.termName.removeClass("addTermDisable");
|
|
view.$('.alertTerm').hide();
|
|
}
|
|
});
|
|
view.on('closeModal', function() {
|
|
modal.trigger('cancel');
|
|
});
|
|
});
|
|
},
|
|
saveDefaultTaxonomy: function(view) {
|
|
var that = this;
|
|
var url = view.url;
|
|
view.model.url = url + "/" + view.ui.termName.val();
|
|
this.showLoader();
|
|
view.model.set({ description: view.ui.termDetail.val() }).save(null, {
|
|
skipDefaultError: true,
|
|
success: function(model, response) {
|
|
that.fetchCollection(view.model.url, true);
|
|
Utils.notifySuccess({
|
|
content: "Default taxonomy " + view.ui.termName.val() + Messages.addSuccessMessage
|
|
});
|
|
},
|
|
cust_error: function(model, response) {
|
|
Utils.notifyError({
|
|
content: "Default taxonomy " + view.ui.termName.val() + Messages.addErrorMessage
|
|
});
|
|
},
|
|
complete: function() {
|
|
that.hideLoader();
|
|
}
|
|
});
|
|
}
|
|
});
|
|
return TreeLayoutView;
|
|
});
|