first commit

wp-content/plugins/sitepress-multilingual-cms/res/js/taxonomy-translation/models/taxonomy.js

@@ -0,0 +1,257 @@
+/*globals labels, ajaxurl, TaxonomyTranslation, Backbone, jQuery, _, WPML_Translate_taxonomy */
+
+(function () {
+	"use strict";
+	
+	TaxonomyTranslation.models.Taxonomy = Backbone.Model.extend({
+
+		defaults: function () {
+			return {
+				name: false,
+				taxonomy: false,
+				terms: {},
+				parents: {},
+				termNames: {},
+				showSlugTranslationField: true
+			};
+		},
+
+		initialize: function () {
+			TaxonomyTranslation.data.termRowsCollection = new TaxonomyTranslation.collections.TermRows();
+			this.setTaxonomy(this.get("taxonomy"));
+		},
+
+		setTaxonomy: function (taxonomy) {
+			this.set("taxonomy", taxonomy, {silent: true});
+			TaxonomyTranslation.data.termRowsCollection.reset();
+
+			if (taxonomy !== undefined) {
+				this.getTaxonomyTerms(taxonomy);
+			} else {
+				this.trigger('newTaxonomySet');
+			}
+		},
+
+		getTaxonomyTerms: function (taxonomy) {
+			var self = this;
+
+			jQuery.ajax({
+				url: ajaxurl,
+				type: "POST",
+				data: {
+					action: 'wpml_get_terms_and_labels_for_taxonomy_table',
+					nonce: labels.wpml_taxonomy_translation_nonce,
+					taxonomy: taxonomy
+				},
+				success: function (response) {
+					var termsData = response.terms;
+					var labelsData = response.taxLabelTranslations;
+
+					if (response.defaultLanguage) {
+						self.set('defaultLang', response.defaultLanguage);
+					}
+
+					if (labelsData) {
+						TaxonomyTranslation.data.translatedTaxonomyLabels = labelsData;
+						TaxonomyTranslation.data.langSelector             = response.taxLangSelector;
+						if (labelsData.st_default_lang) {
+							self.set('stDefaultLang', labelsData.st_default_lang);
+							self.set('showSlugTranslationField', labelsData[ labelsData.st_default_lang ]['showSlugTranslationField']);
+						}
+					} else {
+						TaxonomyTranslation.data.translatedTaxonomyLabels = false;
+					}
+
+					if (response.bottomContent) {
+						self.set('bottomContent', response.bottomContent);
+					}
+
+					TaxonomyTranslation.data.resultsTruncated = response.resultsTruncated;
+
+					if (termsData) {
+						self.processData(termsData);
+					} else {
+						self.trigger('newTaxonomySet');
+					}
+
+				}
+			});
+		},
+
+		processData: function (termsData) {
+
+			var parentTermIDs = [],
+				parents = {},
+				termNames = {};
+
+			_.each(termsData, function (tridGroup) {
+				var termsObject = {};
+				_.each(TaxonomyTranslation.data.activeLanguages, function (lang, code) {
+					var term;
+					if (tridGroup[code] !== undefined && tridGroup[code].term_taxonomy_id) {
+						term = new TaxonomyTranslation.models.Term(tridGroup[code]);
+						var parent = term.get("parent");
+						if (parent > 0) {
+							parentTermIDs.push(parent);
+						}
+						termsObject[code] = term;
+						termNames[tridGroup[code].term_taxonomy_id] = tridGroup[code].name;
+					}
+				});
+				TaxonomyTranslation.data.termRowsCollection.add(new TaxonomyTranslation.models.TermRow({
+					trid: tridGroup.trid,
+					terms: termsObject
+				}));
+			});
+
+			_.each(termsData, function (tridGroup) {
+				_.each(TaxonomyTranslation.data.activeLanguages, function (lang, code) {
+					if (tridGroup[code] !== undefined && parentTermIDs.indexOf(tridGroup[code].term_id) !== -1) {
+						parents[tridGroup[code].term_id] = tridGroup[code].name;
+					}
+
+				});
+			});
+
+			this.set("parents", parents, {silent: true});
+			this.set("termNames", termNames, {silent: true});
+
+			this.trigger('newTaxonomySet');
+		},
+
+		getOriginalTerm: function ( trid ) {
+			var row = TaxonomyTranslation.data.termRowsCollection.get(trid);
+			var originalTerm = null;
+			var terms = row.get("terms");
+			_.each( terms, function ( term ) {
+				if ( term.get( "source_language_code") === null ) {
+					originalTerm = term;
+				}
+			});
+			return originalTerm;
+		},
+		getOriginalTermMeta: function( trid ) {
+			var originalTerm = this.getOriginalTerm(trid),
+				term_metas = [],
+				original_meta_data;
+
+			original_meta_data = originalTerm.get('meta_data');
+			_.each( original_meta_data, function ( meta_data, meta_key ) {
+				term_metas.push({
+					'meta_key': meta_key,
+					'meta_value': meta_data
+				});
+			});
+
+			return term_metas;
+		},
+		getTermName: function (termID) {
+
+			var res = "";
+			if (termID > 0) {
+				var termNames = this.get("termNames");
+				res = termID in termNames ? termNames[termID] : "";
+			}
+
+			return res;
+		},
+		saveLabel: function (singular, plural, slug, lang) {
+			var self = this;
+
+			jQuery.ajax({
+				url: ajaxurl,
+				type: "POST",
+				data: {
+					action: 'wpml_tt_save_labels_translation',
+					nonce: labels.wpml_taxonomy_translation_nonce,
+					singular: singular,
+					plural: plural,
+					slug: slug,
+					taxonomy_language_code: lang,
+					taxonomy: self.get('taxonomy')
+				},
+				success: function (response) {
+					if (response.data) {
+						var newLabelData = response.data;
+						if (newLabelData.singular && newLabelData.general && newLabelData.lang) {
+							TaxonomyTranslation.data.translatedTaxonomyLabels[newLabelData.lang] = {
+								singular: newLabelData.singular,
+								general: newLabelData.general,
+								slug: newLabelData.slug
+							};
+							WPML_Translate_taxonomy.callbacks.fire('wpml_tt_save_term_translation', self.get('taxonomy'));
+							self.trigger("labelTranslationSaved");
+
+							return self;
+						}
+					}
+					self.trigger("saveFailed");
+					return self;
+				},
+				error: function () {
+					self.trigger("saveFailed");
+					return self;
+				}
+			});
+		},
+		isHierarchical: function(){
+			var self = this;
+
+			return TaxonomyTranslation.data.taxonomies[self.get("taxonomy")].hierarchical;
+		},
+		loadSyncData: function (lang) {
+			var self = this;
+
+			jQuery.ajax({
+				url: ajaxurl,
+				type: "POST",
+				data: {
+					action: 'wpml_tt_sync_hierarchy_preview',
+					_icl_nonce: labels.wpml_tt_sync_hierarchy_nonce,
+					taxonomy: self.get('taxonomy'),
+					ref_lang: lang
+				},
+				success: function (response) {
+					TaxonomyTranslation.data.syncData = response.data;
+					self.trigger('syncDataLoaded');
+				}
+			});
+		},
+		doSync: function (lang) {
+			var self = this;
+			var tax = self.get('taxonomy');
+			jQuery.ajax({
+				url: ajaxurl,
+				type: "POST",
+				data: {
+					action: 'wpml_tt_sync_hierarchy_save',
+					_icl_nonce: labels.wpml_tt_sync_hierarchy_nonce,
+					taxonomy: tax,
+					ref_lang: lang
+				},
+				success: function (response) {
+					TaxonomyTranslation.data.syncData = response.data;
+					self.setTaxonomy(tax);
+				}
+			});
+		},
+
+		changeTaxStringsLanguage: function(sourceLang) {
+			var self = this;
+			var tax = self.get('taxonomy');
+			jQuery.ajax({
+				url: ajaxurl,
+				type: "POST",
+				data: {
+					action: 'wpml_tt_change_tax_strings_language',
+					nonce: labels.wpml_taxonomy_translation_nonce,
+					taxonomy: tax,
+					source_lang: sourceLang
+				},
+				success: function () {
+					self.setTaxonomy(tax);
+				}
+			});
+		}
+	});
+})(TaxonomyTranslation);

wp-content/plugins/sitepress-multilingual-cms/res/js/taxonomy-translation/models/term-row.js

@@ -0,0 +1,124 @@
+/*globals TaxonomyTranslation, _, Backbone */
+
+(function () {
+	"use strict";
+
+	TaxonomyTranslation.models.TermRow = Backbone.Model.extend({
+
+		defaults: function () {
+			return {
+				terms: {},
+				trid: false,
+				allTranslated: false,
+				parents: {}
+			};
+		},
+
+		idAttribute: "trid",
+
+		initialize: function (data, options) {
+			var self = this;
+			self.updateAllTranslated();
+			var parents = {};
+			_.each(data.terms, function (term, lang) {
+				parents[lang] = term.get("parent");
+			});
+
+			self.set("parents", parents);
+		},
+
+		parentOf: function (parentID) {
+			var self = this;
+			var parents = self.get("parents");
+			var res = false;
+			_.each(parents, function (parent, lang) {
+				if (parent == parentID) {
+					res = true;
+					return res;
+				}
+			});
+
+			return res;
+		},
+
+		add: function (term) {
+
+			if (!this.get("trid") && term.get("trid")) {
+				this.set("trid", term.get("trid"), {silent: true});
+			}
+
+			if (term.get("trid") == this.get("trid") && term.get("language_code") && term.get("name")) {
+				var terms = this.get("terms");
+				terms[term.get("language_code")] = term;
+				this.set("terms", terms, {silent: true});
+			}
+			this.updateAllTranslated();
+		},
+
+		updateAllTranslated: function () {
+			var self = this;
+			var terms = self.get("terms");
+			self.set("allTranslated", true, {silent: true});
+			_.each(TaxonomyTranslation.util.langCodes, function (lang) {
+				if (terms === undefined || terms[lang] === undefined || !terms[lang].get("name")) {
+					self.set("allTranslated", false, {silent: true});
+				}
+			});
+			return self;
+		},
+
+		allTermsTranslated: function () {
+			this.updateAllTranslated();
+			return this.get("allTranslated");
+		},
+		translatedIn: function (lang) {
+			var self = this;
+			var terms = self.get("terms");
+			var res = true;
+			if (terms === undefined || terms[lang] === undefined || !terms[lang].get("name")) {
+				res = false;
+			}
+			return res;
+		},
+		matches: function (search) {
+			var self = this;
+			var res = false;
+			_.each(TaxonomyTranslation.util.langCodes, function (lang) {
+				if (self.matchesInLang(search, lang) === true) {
+					res = true;
+					return true;
+				}
+			});
+			return res;
+		},
+		matchesInLang: function (search, lang) {
+			var self = this;
+			var terms = self.get("terms");
+			var res = false;
+			if (
+				terms !== undefined &&
+				terms[lang] !== undefined &&
+				terms[lang].get("name") &&
+				terms[lang].get("name").toLowerCase().indexOf(search.toLowerCase()) > -1
+			) {
+				res = true;
+			}
+			return res;
+		},
+		unSyncFilter: function () {
+			var self = this;
+			var syncData = TaxonomyTranslation.data.syncData;
+			var terms = self.get("terms");
+			var res = false;
+			_.each(syncData, function (correction) {
+				_.each(TaxonomyTranslation.util.langCodes, function (lang) {
+					if (terms[lang] !== undefined && correction.translated_id == terms[lang].get('term_taxonomy_id')) {
+						res = true;
+					}
+				});
+			});
+
+			return res;
+		}
+	});
+})(TaxonomyTranslation);

wp-content/plugins/sitepress-multilingual-cms/res/js/taxonomy-translation/models/term.js

@@ -0,0 +1,97 @@
+(function () {
+	TaxonomyTranslation.models.Term = Backbone.Model.extend({
+
+		idAttribute: "term_taxonomy_id",
+
+		defaults: function () {
+			return {
+				name: false,
+				trid: false,
+				term_taxonomy_id: false,
+				language_code: false,
+				slug: false,
+				parent: false,
+				correctedParent: false,
+				description: false,
+				level: 0,
+				correctedLevel: 0,
+				source_language_code: false,
+				meta_data: false
+			};
+		},
+
+		save: function (name, slug, description, meta_data) {
+			var self = this;
+			slug = slug ? slug : '';
+			description = description ? description : '';
+
+			if (name) {
+				jQuery.ajax({
+					url: ajaxurl,
+					type: "POST",
+					data: {
+						action: 'wpml_save_term',
+						name: name,
+						slug: slug,
+						_icl_nonce: labels.wpml_save_term_nonce,
+						description: description,
+						trid: self.get("trid"),
+						term_language_code: self.get("language_code"),
+						taxonomy: TaxonomyTranslation.classes.taxonomy.get("taxonomy"),
+						meta_data: meta_data,
+						force_hierarchical_sync: true
+					},
+					success: function (response) {
+						var newTermData = response.data;
+
+						if (newTermData.language_code && newTermData.trid && newTermData.slug && newTermData.term_taxonomy_id) {
+							self.set(newTermData);
+							self.trigger("translationSaved");
+							WPML_Translate_taxonomy.callbacks.fire('wpml_tt_save_term_translation', TaxonomyTranslation.classes.taxonomy.get("taxonomy"));
+						} else {
+							self.trigger("saveFailed");
+						}
+						return self;
+					},
+					error: function(){
+						self.trigger("saveFailed");
+						return self;
+					}
+				});
+			}
+		},
+		
+		isOriginal: function() {
+			return this.get( 'source_language_code' ) === null;
+		},
+		getNameSlugAndDescription: function () {
+			var self = this;
+			var term = {};
+			term.slug = self.getSlug();
+
+			term.description = self.get("description");
+			if ( ! term.description ) {
+				term.description = "";
+			}
+			term.name = self.get("name");
+			if ( ! term.name) {
+				term.name = "";
+			}
+			return term;
+		},
+		getSlug: function () {
+			var self = this;
+
+			var slug = self.get("slug");
+			if (!slug) {
+				slug = "";
+			}
+			slug = decodeURIComponent(slug);
+
+			return slug;
+		},
+		getMetaData: function() {
+			return this.get('meta_data');
+		}
+	});
+})(TaxonomyTranslation);