https://www.religionstatue.com/wp-content/plugins/unlimited-elemen…/filters/ue_filters.js?ver=2.0.10

1//UE Filters Version 1.27
2
3function UEDynamicFilters(){
4
5	var g_objFilters, g_filtersData, g_urlBase;
6	var g_urlAjax, g_lastGridAjaxCall, g_cache = {}, g_objBody;
7	var g_remote = null, g_lastSyncGrids, g_initFiltersCounter = 0;
8	
9	var t = this;
10	
11	var g_showDebug = false;
12	var g_debugInitMode = false;
13	
14	var g_debugBeforeRefreshMode = false;	//debug filters state before refresh
15	
16	var g_isGutenberg = false;
17	
18	var g_types = {
19		PAGINATION:"pagination",
20		LOADMORE:"loadmore",
21		TERMS_LIST:"terms_list",
22		SEARCH: "search",
23		SELECT: "select",
24		SUMMARY: "summary",
25		GENERAL: "general",
26		GENERAL_MOBILE_DRAWER: "mobilefilters"
27	};
28
29	var g_vars = {
30		CLASS_DIV_DEBUG:"uc-div-ajax-debug",
31		CLASS_GRID:"uc-filterable-grid",
32		CLASS_GRID_NOREFRESH:"uc-grid-norefresh",	//grid that will not refresh
33		DEBUG_AJAX_OPTIONS: false,
34		CLASS_CLICKED:"uc-clicked",
35		CLASS_HIDDEN: "uc-filter-hidden",	//don't refresh with this class
36		CLASS_INITING: "uc-filter-initing",
37		CLASS_INITING_HIDDEN: "uc-initing-filter-hidden",
38		CLASS_SKIP_REFRESH: "uc-filters-norefresh",		//on some grid parent
39		CLASS_REFRESH_SOON: "uc-ajax-refresh-soon",
40		EVENT_SET_HTML_ITEMS: "uc_ajax_sethtml",
41		CLASS_FILTER_INITED:"ucfilters--filter-inited",
42		ATTRIBUTE_URLADD:"ajaxurladd",
43		GRID_DATA_SKIP_HTML: "skip_set_html",
44		
45		//grid events
46
47		EVENT_BEFORE_REFRESH: "uc_before_ajax_refresh",	   //on grid
48		EVENT_AJAX_REFRESHED: "uc_ajax_refreshed",	   //on grid
49		EVENT_AJAX_REFRESHED_BODY: "uc_ajax_refreshed_body",	   //on body
50		EVENT_UPDATE_ACTIVE_FILTER_ITEMS: "update_active_filter_items",	   //on grid
51		EVENT_UNSELECT_FILTER: "uc_unselect_filter",   //on grid
52		EVENT_SILENT_FILTER_CHANGE: "uc_silent_filter_change",   //on grid
53
54		EVENT_DOM_UPDATED: "uc_dom_updated",   //on body
55
56		//events on filters
57
58		EVENT_INIT_FILTER:"init_filter",
59		EVENT_INIT_FILTER_TYPE:"init_filter_type",
60		EVENT_GET_FILTER_DATA:"get_filter_data",
61		EVENT_FILTER_RELOADED: "uc_ajax_reloaded",
62
63		//grid actions
64
65		ACTION_CLEAR_FILTERS: "clear_filters",	   //on grid
66		ACTION_REFRESH_GRID: "uc_refresh",	//listen on grid
67		ACTION_GET_FILTERS_URL: "uc_get_filters_url",	//listen on grid
68		ACTION_FILTER_CHANGE: "uc_filter_change",		//listen on grid
69		ACTION_FILTER_UNSELECT_BY_KEY: "unselect_by_key",	//listen on grid
70		
71		REFRESH_MODE_PAGINATION: "pagination",
72		REFRESH_MODE_LOADMORE: "loadmore",
73		trashold_handle:null,
74		class_widget_wrapper:"elementor-widget",
75		current_postid:null,
76		ucpage_url:null
77	};
78
79	var g_options = {
80		is_cache_enabled:true,
81		urlkey_taxsap:"~"
82	};
83	
84	/**
85	 * console log some string
86	 */
87	function trace(str){
88		console.log(str);
89	}
90
91	function ________GENERAL_______________(){}
92
93
94
95	/**
96	 * add url param
97	 */
98	function addUrlParam(url, param, value){
99
100		if(url){
101			if(url.indexOf("?") == -1)
102				url += "?";
103			else
104				url += "&";
105		}
106
107		if(typeof value == "undefined")
108			url += param;
109		else
110			url += param + "=" + value;
111
112		return(url);
113	}
114
115
116	/**
117	 * get object property
118	 */
119	function getVal(obj, name, defaultValue){
120
121		if(!defaultValue)
122			var defaultValue = "";
123
124		var val = "";
125
126		if(!obj || typeof obj != "object")
127			val = defaultValue;
128		else if(obj.hasOwnProperty(name) == false){
129			val = defaultValue;
130		}else{
131			val = obj[name];
132		}
133
134		return(val);
135	}
136
137	/**
138	 * turn string value ("true", "false") to string
139	 */
140	function strToBool(str){
141
142		switch(typeof str){
143			case "boolean":
144				return(str);
145			break;
146			case "undefined":
147				return(false);
148			break;
149			case "number":
150				if(str == 0)
151					return(false);
152				else
153					return(true);
154			break;
155			case "string":
156				str = str.toLowerCase();
157
158				if(str == "true" || str == "1")
159					return(true);
160				else
161					return(false);
162
163			break;
164		}
165
166		return(false);
167	};
168
169	/**
170	 * get offsets distance
171	 */
172	function getOffsetsDistance(offset1, offset2){
173
174	  var dx = offset2.left-offset1.left;
175	  var dy = offset2.top-offset1.top;
176
177	  return Math.sqrt(dx*dx+dy*dy);
178	}
179
180	/**
181	 * round number to one decimal
182	 */
183	function roundToOneDecimal(num) {
184	    if (num % 1 !== 0) {
185	        return num.toFixed(1); // Round to 1 decimal place
186	    } else {
187	        return num.toFixed(0); // Keep the whole number
188	    }
189	}
190
191
192	/**
193	 * get closest object by offset
194	 */
195	function getClosestByOffset(objParents, objElement, isVertical){
196
197		if(objParents.length == 0){
198			throw new Error("get closest by offset error - grids not found");
199		}
200
201		if(g_showDebug == true){
202
203			trace("get closest grids for");
204			trace(objElement)
205			trace("parents");
206			trace(objParents);
207		}
208
209		var objClosest = null;
210		var minDiff = 1000000;
211
212		var elementOffset = objElement.offset();
213
214		jQuery.each(objParents, function(index, parent){
215
216			var objParent = jQuery(parent);
217
218			var objGrid = jQuery(parent);	//return this one
219
220			var distance = 0;
221
222			var isVisible = objParent.is(":visible");
223			
224			var constantHeight = null;
225
226			if(isVisible == false){
227				objParent = objParent.parent();
228			}
229
230			var parentOffset = objParent.offset();
231
232			if(isVertical == true){
233
234				var offsetY = elementOffset.top;
235				var parentY = parentOffset.top;
236
237				//get bottom of the parent
238
239				if(parentY < offsetY)
240					parentY += objParent.height();
241
242				var distance = Math.abs(offsetY - parentY);
243
244			}else{
245
246				var parentOffset = objParent.offset();
247
248				var distance = getOffsetsDistance(parentOffset, elementOffset);
249			}
250
251			if(g_showDebug == true){
252
253				trace(objParent);
254				trace("distance: " + distance);
255
256				trace("is vertical: " + isVertical);
257			}
258
259			if(distance < minDiff){
260				minDiff = distance;
261				objClosest = objGrid;
262			}
263
264		});
265
266		if(g_showDebug == true){
267
268			trace("filter: ");
269			trace(objElement);
270
271			trace("Closest grid found:");
272			trace(objClosest);
273		}
274
275
276		return(objClosest);
277	}
278
279	/**
280	 * get all grids
281	 */
282	function getAllGrids(type){
283
284		if(type == "loaded_only")
285			var objGrids = jQuery("."+ g_vars.CLASS_GRID).not(".ucfilters--grid-inited");
286		else
287			var objGrids = jQuery("."+ g_vars.CLASS_GRID);
288
289		return(objGrids);
290	}
291
292
293  /**
294   * get grid from parents containers
295   */
296  function getGridFromParentContainers(objSource){
297
298    var objParents = objSource.parents();
299    var objGrid = null;
300
301    if(g_showDebug == true){
302
303		trace("get from parent containers");
304		trace(objParents);
305	}
306
307    objParents.each(function(){
308
309      var objParent = jQuery(this);
310
311      objGrid = objParent.find("."+ g_vars.CLASS_GRID);
312
313      //if grid found return it and exit loop
314      if(objGrid.length >= 1)
315        return(false);
316
317    });
318
319
320    return(objGrid);
321  }
322
323

324	/**
325	 * get closest grid to some object
326	 */
327	function getClosestGrid(objSource){
328
329		//in case there are nothing:
330		var objGrids = getAllGrids();
331
332		if(objGrids.length == 0)
333			return(null);
334
335		if(g_showDebug == true){
336
337			trace("get closest grids");
338			trace(objSource);
339			trace(objGrids);
340		}
341
342		//get grid from parents
343
344		if(objGrids.length == 1)
345			return(objGrids);
346
347		//narrow by group
348		var group = objSource.data("connectgroup");
349
350		if(group){
351			var objGridsGroup = objGrids.filter("[data-filtergroup="+group+"]");
352			
353			if(objGridsGroup.length > 0){
354
355				if(objGridsGroup.length == 1)
356					return(objGridsGroup);
357
358				objGrids = objGridsGroup;
359			}
360
361		}else{
362
363			//get from same container - if group not set
364
365		    var objGrid = getGridFromParentContainers(objSource);
366
367		    if(objGrid && objGrid.length == 1)
368		        return(objGrid);
369		}
370
371
372		//get closest by offset
373
374	    if(objGrid && objGrid.length > 1)
375	    	objGrids = objGrid;
376
377		var objSingleGrid = getClosestByOffset(objGrids, objSource, true);
378
379		if(objSingleGrid && objSingleGrid.length == 1)
380			return(objSingleGrid);
381
382		//return first grid in the list
383
384		var objFirstGrid = jQuery(objGrids[0]);
385
386		return(objFirstGrid);
387	}
388
389	
390	
391	/**
392	 * add filter object to grid
393	 */
394	function bindFilterToGrid(objGrid, objFilter){
395		
396		if(g_showDebug){
397			trace("bind filter to grid");
398			
399			trace(objFilter);
400		}
401		
402		var arrFilters = objGrid.data("filters");
403		var objTypes = objGrid.data("filter_types");
404
405		if(!arrFilters)
406			arrFilters = [];
407
408		if(!objTypes)
409			objTypes = {};
410
411		var type = getFilterType(objFilter);
412
413		//validate double types
414
415		if(objTypes.hasOwnProperty(type)){
416
417			switch(type){
418				case g_types.LOADMORE:
419
420					trace("Double filter not allowed");
421					trace("existing Filters:");
422					trace(arrFilters);
423
424					trace("Second Filter");
425					trace(objFilter);
426
427					trace("Grid:");
428					trace(objGrid);
429
430					showElementError(objFilter, "Double load more button for one grid not allowed")
431					return(false);
432				break;
433			}
434
435		}
436
437		objTypes[type] = true;
438
439		var filterID = objFilter.attr("id");
440
441		//handle sticky
442		
443		var objElementorStickySpacer = objFilter.closest(".elementor-sticky__spacer");
444		if(objElementorStickySpacer.length)
445			return(true);
446		
447		
448		//----- validate existing -----
449		
450		var objExistingFilter = arrFilters.filter(function(objFilterInArray){
451			return objFilterInArray.attr("id") == filterID;
452		});
453		
454		if(objExistingFilter && objExistingFilter.length)
455				throw new Error("Can't bind filter to grid, it's already exists: " + filterID);			
456		
457		arrFilters.push(objFilter);
458
459		//add init after filters
460		var isInitAfter = objFilter.data("initafter");
461				
462		if(!isInitAfter)
463			isInitAfter = isSpecialFilterInitAfter(objFilter, objGrid);
464		
465		if(g_showDebug){
466			trace("init after: "+isInitAfter);
467		}
468				
469		if(isInitAfter === true){
470			addFilterToInitAfter(objFilter, objGrid);
471		}
472		
473		objGrid.data("filters", arrFilters);
474		
475		objGrid.data("filter_types", objTypes);
476
477	}
478
479	/**
480	 *
481	 * get element widget id from parent wrapper
482	 */
483	function getElementWidgetID(objElement){
484		
485		if (!objElement || objElement.length === 0)
486			throw new Error("Element not found");
487				
488		var objWidget = objElement.closest("."+g_vars.class_widget_wrapper);
489
490		if (objWidget.length === 0)
491			throw new Error("Element parent not found with class: "+g_vars.class_widget_wrapper);
492		
493		var widgetID = objWidget.data("id");
494
495		if (!widgetID)
496			throw new Error("widget id not found");
497
498		return widgetID;
499	}
500	
501
502	/**
503	 * get the grid widget object from elementor element id
504	 */
505	function getGridFromElementorElementID(elementID, group, showDebug){
506		
507		var selector = "."+g_vars.class_widget_wrapper+"[data-id='"+elementID+"']";
508		
509		var objElement = g_objBody.find(selector);
510		
511		if(showDebug == true){
512			trace("selector: "+selector);
513			trace("element: ");
514			trace(objElement);
515		}
516		
517		if(objElement.length == 0)
518			return(null);
519		
520		var selectorGrid = "."+g_vars.CLASS_GRID;
521		
522		var objGrid = objElement.find(selectorGrid);
523
524		if(showDebug == true){
525			trace("selector grid: "+selectorGrid);
526			trace("grid: ");
527			trace(objGrid);
528		}
529		
530		if(objGrid.length == 1)
531			return(objGrid);
532		
533		if(objGrid.length == 0)
534			return(null);
535
536		//more then one, filter by group
537		if(group){
538			objGrid = objGrid.filter("[data-filtergroup="+group+"]");
539		}
540
541		if(showDebug == true){
542			trace("after group filter: "+group);
543			trace(objGrid);
544		}
545		
546		if(objGrid.length != 1)
547			return(null);
548		
549		
550		return(objGrid);
551	}
552	
553	
554
555	/**
556	 * get another group widgets
557	 */
558	function getGroupWidgets(arrSyncedGrids, objElement){
559
560		var group = objElement.data("filtergroup");
561
562		if(!group)
563			return(arrSyncedGrids);
564
565		var objGrids = jQuery("."+ g_vars.CLASS_GRID);
566
567		if(objGrids.length < 2)
568			return(arrSyncedGrids);
569
570		var elementID = objElement.attr("id");
571
572		var objDataGrids = objGrids.filter("[data-filtergroup='"+group+"']:not(#" + elementID + ")");
573
574		if(objDataGrids.length == 0)
575			return(arrSyncedGrids);
576
577		jQuery.each(objDataGrids, function(index, grid){
578
579			var objGrid = jQuery(grid);
580
581			arrSyncedGrids.push(objGrid);
582		});
583
584
585
586		return(arrSyncedGrids);
587	}
588
589	/**
590	 * get synced widget IDs
591	 */
592	function getSyncedWidgetData(objElement){
593
594		var arrSyncedGrids = [];
595
596		if(g_remote)
597			arrSyncedGrids = g_remote.getSyncedElements(objElement);
598
599		if(!arrSyncedGrids)
600			arrSyncedGrids = [];
601
602		arrSyncedGrids = getGroupWidgets(arrSyncedGrids, objElement);
603
604		if(!arrSyncedGrids || arrSyncedGrids.length == 0)
605			return(false);
606
607		var arrWidgetIDs = [];
608
609		var objGrids = null;
610
611		for(var index in arrSyncedGrids){
612
613			var objGrid = arrSyncedGrids[index];
614
615			if(objGrid.hasClass(g_vars.CLASS_GRID) == false){
616
617				var message = "Please enable ajax on all synced widgets";
618				var message2 = "Please enable ajax on this synced widget, it's missing class: "+g_vars.CLASS_GRID;
619
620				showElementError(objGrid, message2);
621
622				showAjaxError(message);
623				throw new Error(message);
624				return(false);
625			}
626
627			var objWidgetID = getElementWidgetID(objGrid);
628
629			//add to jquery collection
630
631			if(!objGrids)
632				objGrids = objGrid;
633			else
634				objGrids = objGrids.add(objGrid);
635
636			arrWidgetIDs.push(objWidgetID);
637		}
638
639		var strWidgetIDs = arrWidgetIDs.toString();
640
641		var objOutput = {};
642		objOutput["ids"] = strWidgetIDs;
643		objOutput["grids"] = objGrids;
644
645		return(objOutput);
646	}
647
648
649	/**
650	 * get element layout data
651	 */
652	function getElementLayoutData(objElement, addSyncedGrids){
653		
654		//get widget id
655		var widgetID = getElementWidgetID(objElement);
656		var objWidget = objElement.parents("."+g_vars.class_widget_wrapper);
657
658		//get synced grids
659		var objSyncedData = null;
660

661		//add sync if allowed and available
662
663		if(addSyncedGrids){
664
665			var objSyncedData = getSyncedWidgetData(objElement);
666
667			if(g_showDebug && objSyncedData){
668
669				trace("sync data");
670				trace(objSyncedData);
671			}
672		}else{
673
674			if(g_showDebug)
675				trace("skip sync grid");
676
677		}
678		
679		//get layout id
680		
681		if(g_isGutenberg == false){
682		
683			var objLayout = objWidget.parents(".elementor");
684	
685			if(objLayout.length == 0)
686				throw new Error("layout not found");
687			
688			var layoutID = objLayout.data("elementor-id");
689	
690			if(!layoutID)
691				layoutID = objLayout.data("id");
692			
693		}else{	//gutenberg
694			
695			var layoutID = g_vars.current_postid;			
696		}
697		
698		
699		var output = {};
700
701		output["widgetid"] = widgetID;
702		output["layoutid"] = layoutID;
703
704		if(objSyncedData){
705			output["synced_widgetids"] = objSyncedData["ids"];
706			output["synced_grids"] = objSyncedData["grids"];
707		}
708
709		return(output);
710	}
711
712	/**
713	 * show element error above it
714	 */
715	function showElementError(objElement, error){
716
717		var objParent = objElement.parent();
718		
719		if(g_showDebug == true){
720			trace("Show Error Message for: ");
721			trace(objElement);
722			trace(error);
723		}
724		
725		var objError = objParent.find(".uc-filers-error-message");
726		if(objError.length == 0){
727			objParent.append("<div class='uc-filers-error-message' style='color:red;position:absolute;top:-24px;left:0px;background-color:rgba(230, 230, 230, 0.8);padding:3px;font-size:12px;border:5px solid white;'></div>");
728			var objError = objParent.find(".uc-filers-error-message");
729			objParent.css("border","1px solid red !important");
730		}
731		
732		objError.append(error);
733
734		objError.css("top",-objError.height()-5);
735		
736	}
737
738	/**
739	 * get grid empty message
740	 */
741	function getGridEmptyMessage(objGrid){
742
743		var gridID = objGrid.attr("id");
744
745		if(!gridID)
746			return(null);
747
748		var objEmptyMessage = jQuery("#"+gridID+"_empty_message");
749
750		if(objEmptyMessage.length == 0)
751			return(null);
752
753		return(objEmptyMessage);
754	}
755
756	/**
757	 * get active filter items, if no items - return 0
758	 */
759	function getGridActiveFilterItems(objGrid){
760		
761		var arrActiveItems = objGrid.data("active_filters_items");
762
763		if(!arrActiveItems)
764			return(null);
765
766		if(arrActiveItems.length == 0)
767			return(null);
768
769		return(arrActiveItems);
770	}
771
772
773	/**
774	 * get filters that are selected
775	 */
776	function getSelectedFilters(objFilters, roleArg){
777
778		if(!objFilters)
779			var objFilters = objGrid.data("filters");
780
781		if(!objFilters)
782			return(false);
783
784		var arrSelectedFilters = [];
785
786		jQuery.each(objFilters, function(index, filter){
787
788			var objFilter = jQuery(filter);
789			var isSelected = objFilter.hasClass("uc-has-selected");
790
791			if(!roleArg && isSelected == true){
792				arrSelectedFilters.push(objFilter);
793				return(true);
794			}
795
796			var role = objFilter.data("role");
797
798			if(role == roleArg){
799				var isSelected = objFilter.hasClass("uc-has-selected");
800				if(isSelected)
801					arrSelectedFilters.push(objFilter);
802			}
803
804		});
805
806		return(arrSelectedFilters);
807	}
808
809
810	function ________FILTERS_______________(){}
811
812
813	/**
814	 * get the parent
815	 */
816	function getFiltersParent(objFilters){
817
818		//init the events
819		var objParent = objFilters.parents(".elementor");
820
821		if(objFilters.length > 1 && objParent.length > 1)
822			objParent = objFilters.parents("body");
823
824		if(objParent.length > 1){
825			objParent = jQuery(objParent[0]);
826		}
827
828		if(objParent.length == 0)
829			objParent = objFilters.parents("body");
830
831		return(objParent);
832	}
833	
834	/**
835	 * get filter wrapper
836	 */
837	function getFilterWrapper(objFilter){
838		
839		var objParent = objFilter.parent();		
840		
841		if(objParent.hasClass("uc-checkbox-filter-accordion-container"))
842			objParent = objParent.parent();
843		
844		return(objParent);
845	}
846
847	
848	/**
849	 * get filter type
850	 */
851	function getFilterType(objFilter, getGeneralType){
852		
853		if(objFilter.hasClass("uc-filter-pagination"))
854			return(g_types.PAGINATION);
855
856		if(objFilter.hasClass("uc-filter-load-more"))
857			return(g_types.LOADMORE);
858
859		var filterType = objFilter.data("filtertype")
860
861		if(filterType == g_types.GENERAL && getGeneralType === true){
862			
863			var generalType = objFilter.data("generaltype");
864			return(generalType);
865		}
866		
867		if(filterType)
868			return(filterType);
869		
870		//if not found - throw error
871		
872		trace("Filter type not found: ");
873		trace(objFilter);
874		
875		throw new Error("wrong filter type");
876		
877	}
878
879
880	/**
881	 * clear all filters
882	 */
883	function clearAllFilters(objGrid){
884		

885		clearChildFilters(objGrid, null, true, null, true);
886	}
887
888	/**
889	 * get grid filters or null
890	 */
891	function getGridFilters(objGrid){
892
893		var objFilters = objGrid.data("filters");
894
895		if(!objFilters)
896			return(null);
897
898		if(objFilters.length == 0)
899			return(null);
900
901		return(objFilters);
902	}
903
904
905	/**
906	 * clear non main grid filters
907	 * hide children and just clear the main filters
908	 */
909	function clearChildFilters(objGrid, objCurrentFilter, isHideChildren, termID, isClearAll){
910		
911		var objFilters = getGridFilters(objGrid);
912		
913		if(!objFilters)
914			return(false);
915
916		var currentFilterID = null;
917
918		if(objCurrentFilter)
919			var currentFilterID = objCurrentFilter.attr("id");
920						
921		jQuery.each(objFilters, function(index, filter){
922						
923			var objFilter = jQuery(filter);
924			var filterID = objFilter.attr("id");
925
926			if(filterID == currentFilterID)
927				return(true);
928
929			var role = objFilter.data("role");
930			
931			//clear all others if that option selected
932			
933			if(role != "child" && role != "main" && role != "term_child"){
934				
935				if(isClearAll == true){
936					clearFilter(objFilter);
937				}
938				
939				return(true);
940			}
941
942			var isHide = false;

943			var isShow = false;
944
945			switch(role){
946				case "term_child":
947					if(isHideChildren == true)
948						isHide = true;
949
950					var linkedTermID = objFilter.data("childterm");
951
952					if(linkedTermID == termID){		//show the filter
953
954						objFilter.removeClass(g_vars.CLASS_HIDDEN);
955						objFilter.removeClass(g_vars.CLASS_INITING);
956						objFilter.removeClass(g_vars.CLASS_INITING_HIDDEN);
957					}else{
958						isHide = true;
959					}
960
961				break;
962				case "child":
963
964					if(isHideChildren == true)
965						isHide = true;
966					else{
967						//hide the filters and refresh
968
969						objFilter.removeClass(g_vars.CLASS_HIDDEN);
970
971						objFilter.addClass(g_vars.CLASS_INITING);
972						objFilter.addClass(g_vars.CLASS_INITING_HIDDEN);
973
974					}
975
976				break;
977				default:
978					
979					if(isClearAll == true){
980						clearFilter(objFilter);
981					}
982					
983					return(true);
984				break;
985			}
986
987			//hide the child filters and not refresh
988
989			if(isHide == true)
990				objFilter.addClass(g_vars.CLASS_HIDDEN);
991			
992			clearFilter(objFilter);
993
994		});
995
996	}
997
998	/**
999	 * clear some filter
1000	 */
1001	function clearFilter(objFilter){
1002		
1003		var type = getFilterType(objFilter);
1004
1005		switch(type){
1006			case g_types.TERMS_LIST:
1007				var objSelectedItems = objFilter.find(".ue_taxonomy_item.uc-selected");
1008				objSelectedItems.removeClass("uc-selected");
1009
1010				var objAll = objFilter.find(".ue_taxonomy_item.uc-item-all");
1011				objAll.addClass("uc-selected");
1012
1013			break;
1014			case g_types.SELECT:
1015				
1016				var objSelect = objFilter.find("select");
1017				objSelect.val("");
1018				
1019				//must leave one selected
1020				var objSelected = objFilter.find("option:selected");
1021				
1022				if(objSelected.length == 0)
1023					objFilter.find("option:first-child").prop("selected","selected");
1024				
1025			break;
1026			default:
1027			case g_types.SEARCH:
1028			case g_types.GENERAL:
1029				objFilter.trigger("clear_filter");
1030			break;
1031		}
1032
1033	}
1034
1035	/**
1036	 * unselect filter item
1037	 */
1038	function unselectFilterItem(objGrid, key){
1039
1040		var objFilters = getGridFilters(objGrid);
1041
1042		if(!objFilters)
1043			return(false);
1044		
1045		jQuery.each(objFilters, function(index, filter){
1046
1047			var objFilter = jQuery(filter);
1048			
1049			objFilter.trigger(g_vars.ACTION_FILTER_UNSELECT_BY_KEY, [key]);
1050			
1051		});
1052
1053	}
1054
1055	/**
1056	 * return true if the filter skip's it's action - like under mobile drawer
1057	 */
1058	function isFilterSkipAction(objFilter){
1059
1060		var objParentSkipRefresh = objFilter.parents("." + g_vars.CLASS_SKIP_REFRESH);
1061		
1062		if(objParentSkipRefresh.length)
1063			return(true);
1064
1065		return(false);
1066	}
1067	
1068	/**
1069	 * return if the grid has some child filters
1070	 */
1071	function hasChildFilters(objGrid){
1072		
1073		var objFilters = getGridFilters(objGrid);
1074		
1075		if(!objFilters)
1076			return(false);
1077		
1078		for(var index in objFilters){
1079			
1080			var objFilter = objFilters[index];
1081			var role = objFilter.data("role");
1082			if(role == "child")
1083				return(true);
1084		}
1085		
1086		return(false);
1087	}
1088	
1089	/**
1090	 * check and trigger skip action to the grid if needed 
1091	 * run before the refresh on some filter click
1092	 * for the mobile drawer (off canvas)
1093	 */
1094	function checkTriggerSkipAction(objFilter, objGrid){
1095		
1096		var isSkipAction = isFilterSkipAction(objFilter);
1097		if(isSkipAction == false)
1098			return(false);
1099		
1100		if(g_showDebug == true)
1101			trace("skip refresh - silent change triggered");
1102		
1103		var filterRole = objFilter.data("role");
1104		
1105		objGrid.trigger(g_vars.EVENT_SILENT_FILTER_CHANGE);
1106		
1107		initGrid_setActiveFiltersData(objGrid);
1108		
1109		//refresh children only main / children available
1110		if(filterRole == "main" && hasChildFilters(objGrid)){
1111			
1112			if(g_showDebug == true)
1113				trace("refresh children only");
1114			
1115			objGrid.data(g_vars.GRID_DATA_SKIP_HTML, true);
1116			refreshAjaxGrid(objGrid);
1117		}
1118		
1119		
1120		return(true);
1121	}
1122	
1123	function ________PAGINATION_FILTER______(){}
1124
1125
1126	/**
1127	 * get pagination selected url or null if is current
1128	 */
1129	function getPaginationSelectedData(objPagination){
1130				
1131		var objCurrentLink = objPagination.find("a.current,span.current");
1132			
1133		if(objCurrentLink.length == 0)
1134			return(null);
1135
1136		var url = objCurrentLink.attr("href");
1137				
1138		var numPage = objCurrentLink.text();
1139		
1140		if(jQuery.isNumeric(numPage) == false)
1141			numPage = null;
1142
1143		numPage = Number(numPage);
1144
1145		if(numPage === 1)
1146			numPage = null;
1147
1148		var output = {};
1149		output["url"] = url;
1150		output["page"] = numPage;
1151
1152		return(output);
1153	}
1154
1155
1156	/**
1157	 * on ajax pagination click
1158	 */
1159	function onAjaxPaginationLinkClick(event){
1160		
1161		var objLink = jQuery(this);
1162		
1163		//if no grid attached - act like a regular link
1164		
1165		var objPagination = objLink.parents(".uc-filter-pagination");
1166		
1167		var objGrid = objPagination.data("grid");
1168		
1169		if(!objGrid || objGrid.length == 0 || objPagination.hasClass("uc-no-ajax")){
1170						
1171			return(true);
1172		}
1173		

1174		//run the ajax, prevent default
1175		event.preventDefault();
1176		
1177		var objLinkCurrent = objPagination.find(".current");
1178
1179		
1180		//on next button click
1181
1182		if(objLink.hasClass("next")){
1183
1184			var nextLink = objLinkCurrent.next();
1185
1186			var objNextLink = jQuery(nextLink);
1187
1188			objNextLink.trigger("click");
1189
1190			return(false);
1191		}
1192
1193
1194		//on prev button click
1195
1196		if(objLink.hasClass("prev")){
1197
1198			var prevLink = objLinkCurrent.prev();
1199
1200			var objPrevLink = jQuery(prevLink);
1201
1202			objPrevLink.trigger("click");
1203
1204			return(false);
1205		}
1206
1207		objLinkCurrent.removeClass("current");
1208
1209		objLink.addClass("current");
1210
1211		var objGrid = objPagination.data("grid");
1212		
1213		objPagination.addClass(g_vars.CLASS_CLICKED);
1214
1215		if(g_showDebug == true){
1216
1217			trace("click on pagination!!!, no grid refresh");
1218			trace(objLink);
1219
1220		}else{
1221
1222			refreshAjaxGrid(objGrid, g_vars.REFRESH_MODE_PAGINATION);
1223
1224		}
1225
1226		return(false);
1227	}
1228
1229
1230	function ________LOAD_MORE_______________(){}
1231
1232
1233	/**
1234	 * get current load more page
1235	 */
1236	function getLoadMoreUrlData(objFilter){
1237
1238		var objData = objFilter.find(".uc-filter-load-more__data");
1239
1240		var nextOffset = objData.data("nextoffset");
1241		if(!nextOffset)
1242			nextOffset = null;
1243
1244		var numItems = objFilter.data("numitems");
1245
1246		if(!numItems)
1247			numItems = null;
1248
1249		//affect only single grids
1250
1251		var isSingleGridOnly = objFilter.data("affect_single_grid");
1252
1253
1254		var data = {};
1255		data.offset = nextOffset;
1256		data.numItems = numItems;
1257		data.singlegrid = isSingleGridOnly;
1258
1259		return(data);
1260	}
1261
1262
1263	/**
1264	 * do the load more operation
1265	 */
1266	function onLoadMoreClick(){
1267
1268		var objLink = jQuery(this);
1269
1270		var objLoadMore = objLink.parents(".uc-filter-load-more");
1271
1272		var objData = objLoadMore.find(".uc-filter-load-more__data");
1273
1274		var isMore = objData.data("more");
1275
1276		if(isMore == false)
1277			return(false);
1278
1279		var objGrid = objLoadMore.data("grid");
1280
1281		if(!objGrid || objGrid.length == 0)
1282			throw new Error("Grid not found!");
1283
1284		//run the ajax, prevent default
1285
1286		objLoadMore.addClass(g_vars.CLASS_CLICKED);
1287
1288		refreshAjaxGrid(objGrid, g_vars.REFRESH_MODE_LOADMORE);
1289
1290	}
1291
1292	function ________SELECT_______________(){}
1293
1294	/**
1295	 * init select filter, select the selected item (avoid cache)
1296	 */
1297	function initSelectFilter(objFilter){
1298		
1299		var objSelected = objFilter.find(".uc-selected");
1300
1301		if(objSelected.length == 0)
1302			return(false);
1303
1304		var value = objSelected.attr("value");
1305
1306		var objSelect = objFilter.find("select");
1307
1308		objSelect.val(value);
1309
1310	}
1311
1312
1313	function ________TERMS_LIST_______________(){}
1314
1315	/**
1316	 * unselect by key terms list and select
1317	 */
1318	function termsFilterUnselectByKey(event,key){
1319				
1320		var objFilter = jQuery(this);
1321		
1322		var selectedTerm = getTermsListSelectedTerm(objFilter);
1323		
1324		if(!selectedTerm)
1325			return(false);
1326		
1327		var selectedKey = getVal(selectedTerm,"key");
1328		
1329		if(selectedKey != key)
1330			return(false);
1331		
1332		//if key match - clear filter and set no refresh.
1333
1334		clearFilter(objFilter);	
1335		
1336		setNoRefreshFilter(objFilter);
1337	}
1338
1339
1340	/**
1341	 * on terms list click
1342	 */
1343	function onTermsLinkClick(event){
1344		
1345		var className = "uc-selected";
1346
1347		event.preventDefault();
1348
1349		var objLink = jQuery(this);
1350 
1351		if(objLink.hasClass("uc-grid-filter")){
1352
1353			var objTermsFilter = objLink;
1354
1355		}else{
1356
1357			var objTermsFilter = objLink.parents(".uc-grid-filter");
1358		}
1359
1360		var filterType = getFilterType(objTermsFilter);
1361
1362		if(filterType == g_types.SELECT){
1363
1364			var objLink = objTermsFilter.find("option:selected");
1365		}
1366
1367		if(filterType == g_types.TERMS_LIST){
1368
1369			var objActiveLinks = objLink.siblings("."+className).not(objLink);
1370
1371			objActiveLinks.removeClass(className);
1372			objLink.addClass(className);
1373
1374		}
1375
1376		var objGrid = objTermsFilter.data("grid");
1377
1378		if(!objGrid || objGrid.length == 0)
1379			throw new Error("Grid not found");
1380
1381		//if main filter - clear other filters
1382
1383		var filterRole = objTermsFilter.data("role");
1384
1385		var termID = objLink.data("id");
1386
1387		//set refresh - if all and there are hidden items - refresh
1388		var isRefresh = false;
1389
1390		if(!termID){
1391			var objHiddenItems = objTermsFilter.find(".uc-item-hidden");
1392			if(objHiddenItems.length)
1393				isRefresh = true;
1394		}
1395
1396		var isHideChildren = false;

1397		if(!termID)
1398			isHideChildren = true;
1399		
1400		//set not refresh next iteration, because of the clicked
1401		if(isRefresh == false)
1402			setNoRefreshFilter(objTermsFilter);
1403
1404		if(filterRole == "main")
1405			clearChildFilters(objGrid, objTermsFilter, isHideChildren, termID);
1406
1407		//skip action
1408		
1409		var isSkipAction = checkTriggerSkipAction(objTermsFilter, objGrid);
1410		
1411		if(isSkipAction == true)
1412			return(false);
1413		
1414		
1415		if(g_showDebug == true){
1416			trace("refresh grid - on term click");
1417		}
1418		
1419		//refresh grid
1420		refreshAjaxGrid(objGrid);
1421
1422	}
1423
1424
1425	/**
1426	 * get terms list term id
1427	 */
1428	function getTermsListSelectedTerm(objFilter){
1429
1430		if(!objFilter)
1431			return(null);
1432
1433		var filterType = getFilterType(objFilter);
1434
1435		var objSelected = objFilter.find(".uc-selected");
1436
1437		if(filterType == g_types.SELECT){
1438
1439			var objSelected = objFilter.find("option:selected");
1440
1441		}else{
1442
1443			var objSelected = objFilter.find(".uc-selected");
1444		}
1445
1446		if(objSelected.length == 0){
1447
1448			if(g_showDebug == true){
1449				trace("no selected found, skipping...");
1450			}
1451
1452			return(null);
1453		}
1454
1455		//check for hidden
1456
1457		if(filterType == g_types.TERMS_LIST && objSelected.hasClass("uc-item-hidden") == true){
1458
1459			if(g_showDebug == true){
1460
1461				trace("the selected object");
1462				trace(objSelected);
1463				trace("the term is hidden, skipping...");
1464
1465			}
1466
1467			return(null);
1468		}
1469
1470		if(objSelected.length > 1)
1471			objSelected = jQuery(objSelected[0]);
1472
1473		var objTerm = getFilterElementData(objSelected);
1474
1475		return(objTerm);
1476	}
1477
1478	/**
1479	 * select items in terms list by terms
1480	 */
1481	function termListSelectItems(objFilter, arrTerms){
1482
1483		//deselect
1484		var objSelected = objFilter.find(".uc-selected");
1485
1486		objSelected.removeClass("uc-selected");
1487
1488		//select by term
1489
1490		jQuery.each(arrTerms, function(index, term){
1491
1492			var termID = getVal(term,"id");
1493			var objItem = objFilter.find("a.ue_taxonomy_item[data-id='"+termID+"']");
1494
1495			if(objItem.length == 0)
1496				return(true);
1497
1498			objItem.addClass("uc-selected");
1499		});
1500
1501
1502	}
1503
1504	function ________GENERAL_FILTER_______________(){}
1505
1506	/**
1507	 * init general filter
1508	 */
1509	function initGeneralFilter(objFilter){
1510		
1511		objFilter.on(g_vars.ACTION_FILTER_CHANGE, onGeneralFilterChange);
1512
1513	}
1514
1515
1516
1517	/**
1518	 * on general filter change
1519	 */
1520	function onGeneralFilterChange(event, params){
1521			
1522		event.stopPropagation();
1523
1524		var isRefresh = getVal(params, "refresh");
1525
1526		var objFilter = jQuery(this);
1527		
1528		var filterType = objFilter.data("filtertype");
1529
1530		if(filterType != "general"){
1531			
1532			trace(objFilter);
1533
1534			throw new Error("Not a general filter on action: " + g_vars.ACTION_FILTER_CHANGE);
1535			return(false);
1536		}
1537				
1538		if(isRefresh !== true)
1539			setNoRefreshFilter(objFilter);
1540
1541		var objGrid = objFilter.data("grid");
1542
1543		if(!objGrid || objGrid.length == 0){
1544
1545			trace(objGrid);
1546
1547			throw new Error("Wrong filter change");
1548			return(false);
1549		}
1550		
1551		var filterRole = objFilter.data("role");
1552		
1553		if(filterRole == "main"){
1554			
1555			var isHideChildren = false;
1556			
1557			//if no items selected - hide all children			
1558			var objData = getGeneralFilterData(objFilter);
1559			if(!objData)
1560				isHideChildren = true;
1561			
1562			clearChildFilters(objGrid, objFilter, isHideChildren);
1563		}
1564		
1565		//check for skip action
1566
1567		var isSkipAction = checkTriggerSkipAction(objFilter, objGrid);
1568		
1569		if(isSkipAction == true)
1570			return(false);
1571
1572
1573		if(g_showDebug == true){
1574
1575			trace("refresh grid - on general filter change");
1576			trace(objFilter);
1577
1578		}
1579		
1580		refreshAjaxGrid(objGrid);
1581
1582		return(false);
1583	}
1584
1585
1586	/**
1587	 * select filter items by terms, without refresh, just set selected
1588	 */
1589	function selectFilterItemsByTerms(objFilters, arrTerms){
1590
1591		if(!objFilters || objFilters.length == 0)
1592			return(false);
1593
1594		if(!arrTerms || arrTerms.length == 0)
1595			return(false);
1596		
1597		jQuery.each(objFilters,function(index, filter){
1598
1599			var objFilter = jQuery(filter);
1600
1601			selectFilterItems(objFilter, arrTerms);
1602
1603		});
1604
1605	}
1606
1607	/**
1608	 * select filter items
1609	 */
1610	function selectFilterItems(objFilter, arrTerms){
1611
1612		var type = getFilterType(objFilter);
1613
1614		switch(type){
1615			//case g_types.SELECT:
1616			case g_types.TERMS_LIST:
1617
1618				termListSelectItems(objFilter, arrTerms);
1619
1620			break;
1621			case g_types.GENERAL:
1622
1623				objFilter.trigger("uc_select_items", arrTerms);
1624
1625			break;
1626		}
1627
1628	}
1629

1630	/**
1631	 * get filter data
1632	 */
1633	function getGeneralFilterData(objFilter){
1634		
1635		var filterDataObj = {};
1636		objFilter.trigger(g_vars.EVENT_GET_FILTER_DATA, filterDataObj);
1637		
1638		var filterData = getVal(filterDataObj, "output");
1639		
1640		return(filterData);
1641	}
1642
1643
1644	function ________INIT_FILTERS_______________(){}
1645
1646	/**
1647	 * init terms related filer (terms list and select)
1648	 */
1649	function initTermsRelatedFilter(objFilter){
1650		
1651		objFilter.on(g_vars.ACTION_FILTER_UNSELECT_BY_KEY, termsFilterUnselectByKey);
1652
1653	}
1654
1655
1656	/**
1657	 * get filter taxonomy id's
1658	 */
1659	function getFilterTaxIDs(objFilter, objIDs){
1660
1661		var type = getFilterType(objFilter);
1662
1663		//skip the if
1664		if(type == g_types.SELECT)
1665			var objItems = objFilter.find(".uc-select-filter__option");
1666		else
1667			var objItems = objFilter.find(".ue_taxonomy_item");
1668
1669		if(objItems.length == 0)
1670			return(objIDs);
1671
1672		jQuery.each(objItems, function(index, item){
1673
1674			var objItem = jQuery(item);
1675			var taxID = objItem.data("id");
1676
1677			if(!taxID)
1678				return(true);
1679
1680			objIDs[taxID] = true;
1681		});
1682
1683
1684		return(objIDs);
1685	}
1686
1687	/**
1688	 * get tax id's list string from assoc object
1689	 */
1690	function getTermDsList(objIDs){
1691
1692		var strIDs = "";
1693		for(var id in objIDs){
1694
1695			if(jQuery.isNumeric(id) == false)
1696				continue;
1697
1698			if(strIDs)
1699				strIDs += ",";
1700
1701			strIDs += id;
1702		}
1703
1704		return(strIDs);
1705	}
1706
1707
1708	function ________DATA_______________(){}
1709
1710
1711	/**
1712	 * handle term, add to taxonomy array
1713	 */
1714	function buildTermsQuery_handleTerm(objTerm, arrTax1){
1715
1716		var taxonomy = objTerm["taxonomy"];
1717		var slug = objTerm["slug"];
1718
1719		var objTax = getVal(arrTax1, taxonomy);
1720		if(!objTax)
1721			objTax = {};
1722
1723		objTax[slug] = true;
1724		arrTax1[taxonomy] = objTax;
1725
1726		return(arrTax1);
1727	}
1728
1729	/**
1730	 * get slugs string
1731	 */
1732	function buildTermsQuery_getStrSlugs(objSlugs, isGroup){
1733		
1734		var isDebug = false;
1735		
1736		if(isDebug == true){
1737			trace("get str slugs");
1738			trace(objSlugs);
1739			trace("is group:" + isGroup);
1740		}
1741		
1742		var strSlugs = "";
1743
1744		var moreThenOne = false;

1745		var isEndSlugFound = false;
1746		var isOrSlugFound = false;
1747		
1748		for (var slug in objSlugs){
1749				
1750			if(slug === "__ucand__"){
1751				isEndSlugFound = true;
1752				continue
1753			}
1754			
1755			if(slug === "__ucor__"){
1756				isOrSlugFound = true;
1757				continue
1758			}
1759
1760			if(strSlugs){
1761				moreThenOne = true;
1762				strSlugs += ".";
1763			}
1764
1765			strSlugs += slug;
1766		}
1767
1768		//add "and"
1769		if(isDebug == true){
1770			trace("more then one: "+moreThenOne);
1771			trace("is end found: "+isEndSlugFound);
1772		}
1773		
1774		var addAnd = (moreThenOne == true && isGroup !== true || isEndSlugFound);
1775		
1776		if(isOrSlugFound === true)
1777			addAnd = false;
1778		
1779		if(addAnd)
1780			strSlugs += ".*";
1781
1782		if(isDebug)
1783			trace("str slugs: "+strSlugs);
1784		
1785		return(strSlugs);
1786	}
1787
1788
1789	/**
1790	 * build terms query
1791	 * ucterms=product_cat~shoes.dress;cat~123.43;
1792	 */
1793	function buildTermsQuery(arrTerms){
1794		
1795		var isDebug = false;
1796
1797		var query = "";
1798
1799		//break by taxonomy
1800
1801		var arrTax = {};
1802		var arrGroupTax = [];
1803
1804		if(isDebug == true){
1805			trace("arr terms");
1806			trace(arrTerms);
1807		}
1808		
1809		jQuery.each(arrTerms, function(index, objTerm){
1810
1811			//group term
1812			if(jQuery.isArray(objTerm) && objTerm.length != 0){
1813				
1814				if(objTerm.length == 1){
1815					arrTax = buildTermsQuery_handleTerm(objTerm[0], arrTax);
1816					return;
1817				}
1818
1819				var arrGroupTaxonomy = {};
1820				
1821				jQuery.each(objTerm, function(index, groupTerm){
1822					
1823					arrGroupTaxonomy = buildTermsQuery_handleTerm(groupTerm, arrGroupTaxonomy);
1824				});
1825
1826				arrGroupTax.push(arrGroupTaxonomy);
1827
1828			}else{	//single term
1829
1830				arrTax = buildTermsQuery_handleTerm(objTerm, arrTax);
1831			}
1832
1833		});
1834		
1835		if(isDebug == true){
1836			trace("first arr tax");
1837			trace(arrTax);
1838		}
1839
1840		//combine the query
1841
1842		if(jQuery.isEmptyObject(arrTax) && jQuery.isEmptyObject(arrGroupTax))
1843			return(null);
1844
1845		if(isDebug == true){
1846			trace("group tax");
1847			trace(arrGroupTax);
1848		}
1849		
1850		//build group slugs, in case that there is a group
1851		
1852		jQuery.each(arrGroupTax, function(index, objGroupTaxonomies){
1853			
1854			jQuery.each(objGroupTaxonomies, function(taxonomy, objSlugs){
1855				
1856			var strSlugs = buildTermsQuery_getStrSlugs(objSlugs, true);
1857			
1858			var strAdd = strSlugs;
1859			if(strSlugs.indexOf(".") !== -1){
1860				strAdd = "|"+strSlugs+"|";	//OR inside the group
1861			}
1862				
1863				var objTax = getVal(arrTax, taxonomy);
1864				if(!objTax)
1865					objTax = {};
1866		
1867				objTax[strAdd] = true;
1868		
1869				arrTax[taxonomy] = objTax;
1870			});
1871		});
1872
1873		
1874		if(isDebug == true){
1875			trace("The result taxonomy after grouping");
1876			trace(arrTax);
1877		}
1878
1879		//add group to tax
1880
1881		jQuery.each(arrTax, function(taxonomy, objSlugs){
1882			
1883			var strSlugs = buildTermsQuery_getStrSlugs(objSlugs);
1884				
1885			var strTax = taxonomy + g_options.urlkey_taxsap + strSlugs;
1886			
1887			if(query)
1888				query += ";";
1889
1890			query += strTax;
1891
1892		});
1893
1894		if(isDebug == true){
1895			trace("query");
1896			trace(query);
1897		}
1898
1899		return(query);
1900	}
1901
1902	/**
1903	 * get selected filter element data
1904	 */
1905	function getFilterElementData(objElement){
1906				
1907		var id = objElement.data("id");
1908		var title = objElement.data("title");
1909		var key = objElement.data("key");
1910		var type = objElement.data("type");
1911		
1912		if(!id && !key)
1913			return(null);
1914		
1915		
1916		switch(type){
1917		case "taxonomy":
1918		default:
1919			var slug = objElement.data("slug");
1920			var taxonomy = objElement.data("taxonomy");
1921			
1922			var objTerm = {
1923				"type": type,
1924				"id": id,
1925				"slug": slug,
1926				"taxonomy": taxonomy,
1927				"title": title,
1928				"key": key
1929			};
1930			return(objTerm);
1931			
1932		break;
1933		case "author":
1934			
1935			var username = objElement.data("username");
1936			
1937			var objAuthor = {
1938					"type": type,
1939					"id": id,
1940					"username": username,
1941					"title": title,
1942					"key": key
1943				};
1944				return(objAuthor);
1945			
1946		break;
1947		}
1948		
1949	}
1950
1951
1952	function ________AJAX_CACHE_________(){}
1953
1954	/**
1955	 * get ajax url
1956	 */
1957	function getAjaxCacheKeyFromUrl(ajaxUrl){
1958
1959		var key = ajaxUrl;
1960
1961		key = key.replace(g_urlAjax, "");
1962		key = key.replace(g_urlBase, "");
1963
1964		//replace special signs
1965		key = replaceAll(key, "/","");
1966		key = replaceAll(key, "?","_");
1967		key = replaceAll(key, "&","_");
1968		key = replaceAll(key, "=","_");
1969
1970		return(key);
1971	}
1972
1973	/**
1974	 * get ajax cache key
1975	 */
1976	function getAjaxCacheKey(ajaxUrl, action, objData){
1977
1978	    if(g_options.is_cache_enabled == false)
1979	    	return(false);
1980
1981	    //cache only by url meanwhile
1982
1983	    if(jQuery.isEmptyObject(objData) == false)
1984	    	return(false);
1985
1986	    if(action)
1987	    	return(false);
1988
1989	    var cacheKey = getAjaxCacheKeyFromUrl(ajaxUrl);
1990
1991	    if(!cacheKey)
1992	    	return(false);
1993
1994	    return(cacheKey);
1995	}
1996
1997
1998	/**
1999	 * cache ajax response
2000	 */
2001	function cacheAjaxResponse(ajaxUrl, action, objData, response){
2002
2003	    var cacheKey = getAjaxCacheKey(ajaxUrl, action, objData);
2004
2005	    if(!cacheKey)
2006	    	return(false);
2007
2008	    //some precoutions for overload
2009	    if(g_cache.length > 100)
2010	    	return(false);
2011
2012	    g_cache[cacheKey] = response;
2013
2014	}
2015
2016
2017	function ________AJAX_RESPONSE_______________(){}
2018

2019	/**
2020	 * replace the grid debug
2021	 */
2022	function operateAjax_setHtmlDebug(response, objGrid){
2023
2024		//replace the debug
2025		var htmlDebug = getVal(response, "html_debug");
2026
2027		if(!htmlDebug)
2028			return(false);
2029		
2030		var gridParent = objGrid.parents("." + g_vars.class_widget_wrapper);
2031		
2032		var objDebug = gridParent.find(".uc-debug-query-wrapper");
2033
2034		if(objDebug.length == 0)
2035			return(false);
2036
2037		objDebug.replaceWith(htmlDebug);
2038	}
2039
2040
2041	/**
2042	 * set html grid from ajax response
2043	 */
2044	function operateAjax_setHtmlGrid(response, objGrid, isLoadMore){
2045		
2046		if(g_showDebug == true){
2047			trace("set html grid, response: ");
2048			trace(response);
2049
2050			trace("obj grid:");
2051			trace(objGrid);
2052		}
2053
2054		if(objGrid.length == 0)
2055			return(false);
2056		
2057		//skip set html if exists
2058		if(objGrid.data(g_vars.GRID_DATA_SKIP_HTML) === true){
2059			
2060			if(g_showDebug == true)
2061				trace("skip set html");
2062			
2063			objGrid.data(g_vars.GRID_DATA_SKIP_HTML,false);
2064			return(false);
2065		}
2066		
2067		var objItemsWrapper = getGridItemsWrapper(objGrid);
2068		var objItemsWrapper2 = getGridItemsWrapper(objGrid, true);
2069
2070		if(g_showDebug == true){
2071			trace("items wrapper 1: ");
2072			trace(objItemsWrapper);
2073
2074			trace("items wrapper 2:");
2075			trace(objItemsWrapper2);
2076		}
2077
2078
2079		if(!objItemsWrapper || objItemsWrapper.length == 0)
2080			throw new Error("Missing items wrapper: .uc-items-wrapper");
2081
2082		operateAjax_setHtmlDebug(response, objGrid);
2083
2084		//set grid items
2085
2086		//if init filters mode, and no items response - don't set
2087		if(response.hasOwnProperty("html_items") == false)
2088			return(false);
2089		
2090		var htmlItems = getVal(response, "html_items");
2091				
2092		var htmlItems2 = null;
2093
2094		if(objItemsWrapper2)
2095			htmlItems2 = getVal(response, "html_items2");
2096
2097		//replace widget id
2098		var gridID = objGrid.attr("id");
2099
2100		htmlItems = replaceAll(htmlItems, "%uc_widget_id%", gridID);
2101		
2102		if(htmlItems2)
2103			htmlItems2 = replaceAll(htmlItems2, "%uc_widget_id%", gridID);
2104
2105		var isCustomRefresh = objGrid.data("custom-sethtml");
2106
2107		//show / hide empty message if available and empty response
2108		var objEmptyMessage = getGridEmptyMessage(objGrid);
2109
2110		if(objEmptyMessage){
2111			if(htmlItems == "")
2112				objEmptyMessage.show();
2113			else
2114				objEmptyMessage.hide();
2115		}
2116
2117		//set the query data
2118		var queryDataOriginal = getVal(response, "query_data");
2119		var queryIDs = getVal(response,"query_ids");
2120
2121		var queryData = jQuery.extend({}, queryDataOriginal);
2122
2123		//add to old data
2124
2125		if(isLoadMore == true){
2126
2127			var currentQueryData = objGrid.attr("querydata");
2128
2129			var objCurrentData = jQuery.parseJSON(currentQueryData);
2130			var currentNumPosts = getVal(objCurrentData, "count_posts");
2131
2132			queryData.count_posts += currentNumPosts;
2133
2134			var currentQueryIDs = objGrid.data("postids");
2135
2136			if(queryIDs && currentQueryIDs)
2137				queryIDs = currentQueryIDs + "," + queryIDs;
2138		}
2139
2140		//query data replace
2141
2142		if(queryData){
2143
2144			objGrid.removeAttr("querydata");
2145
2146			var jsonData = JSON.stringify(queryData);
2147			objGrid.attr("querydata", jsonData);
2148
2149			objGrid.data("querydata", queryData);
2150		}
2151
2152		//post id's replace
2153
2154		objGrid.removeAttr("data-postids");
2155		objGrid.attr("data-postids", queryIDs);
2156		objGrid.data("postids", queryIDs);
2157
2158
2159		//if custom refresh - just save the new html in data
2160		if(isCustomRefresh == true){
2161
2162			objGrid.trigger(g_vars.EVENT_SET_HTML_ITEMS,[htmlItems, isLoadMore, htmlItems2]);
2163			return(false);
2164		}
2165
2166
2167		if(!htmlItems2)
2168			htmlItems2 = "";
2169
2170		if(isLoadMore === true){
2171
2172			if(g_showDebug == true){
2173				trace("append load more");
2174			}
2175
2176			objItemsWrapper.append(htmlItems);
2177
2178			if(objItemsWrapper)
2179				objItemsWrapper.append(htmlItems2);
2180
2181		}else{
2182						
2183			objItemsWrapper.html(htmlItems);
2184
2185			if(objItemsWrapper2 && objItemsWrapper2.length)
2186				objItemsWrapper2.html(htmlItems2);
2187
2188		}
2189		
2190		
2191		return(true);
2192	}
2193
2194
2195	/**
2196	 * refresh synced grids
2197	 */
2198	function operateAjax_setHtmlSyngGrids(response, objGrid, isLoadMore){
2199		
2200		var objSyncWidgetsResponse = getVal(response, "html_sync_widgets");
2201
2202		if(g_showDebug == true){
2203			trace("set html sync grids");
2204			trace(objSyncWidgetsResponse);
2205		}
2206
2207		var queryData = getVal(response,"query_data");
2208
2209		if(!objSyncWidgetsResponse){
2210			
2211			if(g_showDebug == true){
2212				trace("no sync widgets response");
2213			}
2214			
2215			return(false);
2216		}
2217		
2218		var group = objGrid.data("filtergroup");
2219		
2220		jQuery.each(objSyncWidgetsResponse, function(elementID, childResponse){
2221			
2222			var objGridWidget = getGridFromElementorElementID(elementID, group);
2223			
2224			if(!objGridWidget){
2225				
2226				if(g_showDebug == true){
2227					trace("no grid widget found: "+elementID);
2228					
2229					getGridFromElementorElementID(elementID,group,true);	//for debug
2230				}
2231				
2232				return(true);
2233			}
2234
2235			if(g_showDebug == true){
2236				trace("set sync grid!");
2237				trace(objGridWidget);
2238				trace(childResponse);
2239			}
2240			
2241			
2242			objGridWidget.removeClass(g_vars.CLASS_REFRESH_SOON);
2243			
2244			childResponse.query_data = queryData;
2245			
2246			operateAjax_setHtmlGrid(childResponse, objGridWidget, isLoadMore);
2247			
2248			objGridWidget.trigger(g_vars.EVENT_AJAX_REFRESHED);
2249			g_objBody.trigger(g_vars.EVENT_AJAX_REFRESHED_BODY, [objGridWidget]);
2250
2251		});
2252
2253	}
2254
2255
2256	/**
2257	 * replace filters html
2258	 */
2259	function operateAjax_setHtmlWidgets(response, objFilters){
2260
2261		if(!objFilters)
2262			return(false);
2263
2264		if(objFilters.length == 0)
2265			return(false);
2266
2267		var objHtmlWidgets = getVal(response, "html_widgets");
2268
2269		if(!objHtmlWidgets)
2270			return(false);
2271
2272		if(objHtmlWidgets.length == 0)
2273			return(false);
2274
2275		var objHtmlDebug = getVal(response, "html_widgets_debug");
2276
2277		jQuery.each(objFilters, function(index, objFilter){
2278
2279			var widgetID = getElementWidgetID(objFilter);
2280
2281			if(!widgetID)
2282				return(true);
2283
2284			var html = getVal(objHtmlWidgets, widgetID);
2285
2286			if(!html)
2287				return(true);
2288
2289			var objHtml = jQuery(html);
2290
2291			var htmlInner = objHtml.html();
2292
2293			//set the class
2294
2295			var filterClassName = objHtml.attr("class");
2296
2297			filterClassName += " "+g_vars.CLASS_FILTER_INITED;
2298
2299			objFilter.attr("class", filterClassName);
2300
2301			objFilter.removeClass(g_vars.CLASS_INITING);
2302			objFilter.removeClass(g_vars.CLASS_REFRESH_SOON);
2303
2304			objFilter.html(htmlInner);
2305
2306
2307
2308			//---- put the debug if exists
2309
2310			var htmlDebug = null;
2311
2312			if(objHtmlDebug)
2313				var htmlDebug = getVal(objHtmlDebug, widgetID);
2314
2315			if(htmlDebug){
2316				var objParent = objFilter.parents("." + g_vars.class_widget_wrapper);
2317				var objDebug = objParent.find(".uc-div-ajax-debug");
2318
2319				if(objDebug.length)
2320					objDebug.replaceWith(htmlDebug);
2321			}
2322			
2323			objFilter.trigger(g_vars.EVENT_FILTER_RELOADED);
2324
2325		});
2326
2327	}
2328

2329	/**
2330	 * scroll to grid top
2331	 */
2332	function scrollToGridTop(objGrid){
2333
2334		var gapTop = 150;
2335
2336		var gridOffset = objGrid.offset().top;
2337
2338		var gridTop = gridOffset - gapTop;
2339
2340		if(gridTop < 0)
2341			gridTop = 0;
2342
2343		//check if the grid top is visible
2344
2345		var currentPos = jQuery(window).scrollTop();
2346
2347		if(currentPos <= gridOffset)
2348			return(false);
2349
2350		window.scrollTo({ top: gridTop, behavior: 'smooth' });
2351
2352	}
2353
2354
2355	/**
2356	 * operate the response
2357	 */
2358	function operateAjaxRefreshResponse(response, objGrid, objFilters, isLoadMore, isNoScroll){
2359		
2360		var isGridRefreshed = operateAjax_setHtmlGrid(response, objGrid, isLoadMore);
2361		
2362		operateAjax_setHtmlWidgets(response, objFilters);
2363		
2364		operateAjax_setHtmlSyngGrids(response, objGrid, isLoadMore);
2365		
2366		objGrid.trigger(g_vars.EVENT_AJAX_REFRESHED,[{isLoadMore:isLoadMore}]);
2367		g_objBody.trigger(g_vars.EVENT_AJAX_REFRESHED_BODY, [objGrid]);
2368		
2369		//trigger body as well
2370
2371		//scroll to grid top
2372		if(isLoadMore == false && isGridRefreshed == true && isNoScroll !== true){
2373						
2374			setTimeout(function(){
2375				
2376				scrollToGridTop(objGrid);
2377					
2378			},200);
2379
2380		}
2381
2382	}
2383
2384
2385	/**
2386	 * replace all occurances
2387	 */
2388	function replaceAll(text, from, to){
2389
2390		return text.split(from).join(to);
2391	};
2392
2393
2394
2395
2396	/**
2397	 * get response from ajax cache
2398	 */
2399	function getResponseFromAjaxCache(ajaxUrl, action, objData){
2400
2401	    var cacheKey = getAjaxCacheKey(ajaxUrl, action, objData);
2402
2403	    if(!cacheKey)
2404	    	return(false);
2405
2406	    var response = getVal(g_cache, cacheKey);
2407
2408	    return(response);
2409	}
2410
2411
2412	function ________AJAX_______________(){}
2413
2414	/**
2415	 * set this filter not to refresh next time
2416	 */
2417	function setNoRefreshFilter(objFilter){
2418
2419		objFilter.data("uc_norefresh",true);
2420
2421	}
2422
2423	/**
2424	 * show ajax error, should be something visible
2425	 */
2426	function showAjaxError(message){
2427
2428		alert(message);
2429
2430	}
2431
2432	/**
2433	 * get the debug object
2434	 */
2435	function getDebugObject(){
2436
2437		var objGrid = g_lastGridAjaxCall;
2438
2439		if(!objGrid)
2440			return(null);
2441
2442		var objDebug = objGrid.find("."+g_vars.CLASS_DIV_DEBUG);
2443
2444		if(objDebug.length)
2445			return(objDebug);
2446
2447		//insert if not exists
2448
2449		objGrid.after("<div class='"+g_vars.CLASS_DIV_DEBUG+"' style='padding:10px;display:none;background-color:#D8FCC6'></div>");
2450
2451		var objDebug = jQuery("body").find("."+g_vars.CLASS_DIV_DEBUG);
2452
2453		return(objDebug);
2454	}
2455
2456
2457	/**
2458	 * show ajax debug
2459	 */
2460	function showAjaxDebug(str){
2461
2462		trace("Ajax Error! - Check the debug");
2463
2464		str = jQuery.trim(str);
2465
2466		if(!str || str.length == 0)
2467			return(false);
2468
2469		var objStr = jQuery(str);
2470
2471		if(objStr.find("header").length || objStr.find("body").length){
2472			str = "Wrong ajax response!";
2473		}
2474
2475		var objDebug = getDebugObject();
2476
2477		if(!objDebug || objDebug.length == 0){
2478
2479			alert(str);
2480
2481			throw new Error("debug not found");
2482		}
2483
2484		objDebug.show();
2485		objDebug.html(str);
2486
2487	}
2488
2489
2490	/**
2491	 * small ajax request
2492	 */
2493	function ajaxRequest(ajaxUrl, action, objData, onSuccess){
2494				
2495		if(g_debugInitMode === true){
2496
2497			trace("debug init mode - skip request");
2498			return(false);
2499		}
2500
2501		if(g_showDebug == true){
2502			trace("ajax request");
2503			trace(ajaxUrl);
2504		}
2505
2506		if(!objData)
2507			var objData = {};
2508
2509		if(typeof objData != "object")
2510			throw new Error("wrong ajax param");
2511
2512		//check response from cache
2513		var responseFromCache = getResponseFromAjaxCache(ajaxUrl, action, objData);
2514
2515		if(responseFromCache){
2516
2517			//simulate ajax request
2518			setTimeout(function(){
2519				onSuccess(responseFromCache);
2520			}, 300);
2521
2522			return(false);
2523		}
2524
2525		var ajaxData = {};
2526		ajaxData["action"] = "unlimitedelements_ajax_action";
2527		ajaxData["client_action"] = action;
2528
2529		var ajaxtype = "get";
2530
2531		if(jQuery.isEmptyObject(objData) == false){
2532			ajaxData["data"] = objData;
2533			ajaxtype = "post";
2534		}
2535
2536
2537		var ajaxOptions = {
2538				type:ajaxtype,
2539				url:ajaxUrl,
2540				success:function(response){
2541
2542					if(!response){
2543						showAjaxError("Empty ajax response!");
2544						return(false);
2545					}
2546
2547					if(typeof response != "object"){
2548
2549						try{
2550
2551							response = jQuery.parseJSON(response);
2552
2553						}catch(e){
2554
2555							showAjaxDebug(response);
2556
2557							showAjaxError("Ajax Error!!! not ajax response");
2558							return(false);
2559						}
2560					}
2561
2562					if(response == -1){
2563						showAjaxError("ajax error!!!");
2564						return(false);
2565					}
2566
2567					if(response == 0){
2568						showAjaxError("ajax error, action: <b>"+action+"</b> not found");
2569						return(false);
2570					}
2571
2572					if(response.success == undefined){
2573						showAjaxError("The 'success' param is a must!");
2574						return(false);
2575					}
2576
2577
2578					if(response.success == false){
2579						showAjaxError(response.message);
2580						return(false);
2581					}
2582
2583					cacheAjaxResponse(ajaxUrl, action, objData, response);
2584
2585					if(typeof onSuccess == "function"){
2586
2587						onSuccess(response);
2588					}
2589
2590				},
2591				error:function(jqXHR, textStatus, errorThrown){
2592
2593					switch(textStatus){
2594						case "parsererror":
2595						case "error":
2596
2597							//showAjaxError("parse error");
2598
2599							showAjaxDebug(jqXHR.responseText);
2600
2601						break;
2602					}
2603				}
2604		}
2605
2606		if(ajaxtype == "post"){
2607			ajaxOptions.dataType = 'json';
2608			ajaxOptions.data = ajaxData
2609		}
2610
2611		var handle = jQuery.ajax(ajaxOptions);
2612
2613		return(handle);
2614	}
2615
2616
2617
2618	/**
2619	 * get grid items wrapper
2620	 */
2621	function getGridItemsWrapper(objGrid, isSecond){
2622
2623		var classItems = "uc-items-wrapper";
2624
2625		if(isSecond == true)
2626			classItems = "uc-items-wrapper2";
2627
2628		if(objGrid.hasClass(classItems))
2629			return(objGrid);
2630
2631		var objItemsWrapper = objGrid.find("."+classItems);
2632
2633		if(objItemsWrapper.length == 0 && isSecond == false)
2634			throw new Error("Missing items wrapper - with class: uc-items-wrapper");
2635
2636		if(objItemsWrapper.length == 0)
2637			return(null);
2638
2639		return(objItemsWrapper);
2640	}
2641
2642
2643	/**
2644	 * set ajax loader
2645	 */
2646	function showAjaxLoader(objElement){
2647
2648		objElement.addClass("uc-ajax-loading");
2649	}
2650
2651	/**
2652	 * hide ajax loader
2653	 */
2654	function hideAjaxLoader(objElement){
2655
2656		objElement.removeClass("uc-ajax-loading");
2657	}
2658
2659
2660	/**
2661	 * show multiple ajax loader
2662	 */
2663	function showMultipleAjaxLoaders(objElements, isShow){
2664
2665		if(!objElements)
2666			return(false);
2667
2668		if(objElements.length == 0)
2669			return(false);
2670
2671		jQuery.each(objElements,function(index, objElement){
2672
2673			objElement = jQuery(objElement);
2674
2675			if(isShow == true){
2676
2677				showAjaxLoader(objElement);
2678			}
2679			else
2680				hideAjaxLoader(objElement);
2681		});
2682
2683	}
2684
2685
2686	/**
2687	 * refresh ajax grid
2688	 */
2689	function refreshAjaxGrid(objGrid, refreshType){
2690				
2691		var isLoadMore = (refreshType == g_vars.REFRESH_MODE_LOADMORE);	 //for the output
2692		var isFiltersInit = (refreshType == "filters" || refreshType == "filters_children");
2693		
2694		//for the options - not refresh other filters
2695		var isLoadMoreMode = (refreshType == g_vars.REFRESH_MODE_LOADMORE || refreshType == g_vars.REFRESH_MODE_PAGINATION);
2696		
2697		//get all grid filters
2698		var objFilters = objGrid.data("filters");
2699
2700		if(!objFilters)
2701			return(false);
2702
2703		if(objFilters.length == 0)
2704			return(false);
2705
2706		if(objGrid.hasClass(g_vars.CLASS_GRID_NOREFRESH))
2707			return(false);
2708
2709		var params = {};
2710		if(refreshType == "filters_children")
2711			params["filters_init_type"] = "children";
2712		
2713		params["refresh_type"] = refreshType;
2714		
2715		var objAjaxOptions = getGridAjaxOptions(objFilters, objGrid, isFiltersInit, isLoadMoreMode, params);
2716		
2717		if(!objAjaxOptions){
2718
2719			trace("ajax options are null");
2720			return(false);
2721		}
2722
2723		var ajaxUrl = objAjaxOptions["ajax_url"];
2724		var urlReplace = objAjaxOptions["url_replace"];
2725		var arrTerms = objAjaxOptions["terms"];
2726
2727		if(g_vars.DEBUG_AJAX_OPTIONS == true){
2728
2729			trace("DEBUG AJAX OPTIONS");