https://teacherplus.org/wp-content/plugins/unlimited-elements-for-…/filters/ue_filters.js?ver=2.0.17

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 item, add to key->values map
1713	 * keyName/valueName: "taxonomy"/"slug" for terms, "meta_key"/"meta_value" for meta
1714	 */
1715	function buildGroupedValuesQuery_handleItem(objItem, arrGrouped, keyName, valueName){
1716
1717		var key = objItem[keyName];
1718		var value = objItem[valueName];
1719
1720		if(!key)
1721			return(arrGrouped);
1722
1723		if(value === null || typeof value === "undefined")
1724			value = "";
1725
1726		var objValues = getVal(arrGrouped, key);
1727		if(!objValues)
1728			objValues = {};
1729
1730		objValues[value] = true;
1731		arrGrouped[key] = objValues;
1732
1733		return(arrGrouped);
1734	}
1735
1736	/**
1737	 * get values string (dot separated)
1738	 * adds .* for AND relation when multiple values
1739	 */
1740	function buildGroupedValuesQuery_getStrValues(objValues, isGroup){
1741		
1742		var isDebug = false;
1743		
1744		if(isDebug == true){
1745			trace("get str values");
1746			trace(objValues);
1747			trace("is group:" + isGroup);
1748		}
1749		
1750		var strValues = "";
1751
1752		var moreThenOne = false;

1753		var isEndSlugFound = false;
1754		var isOrSlugFound = false;
1755		
1756		for (var value in objValues){
1757				
1758			if(value === "__ucand__"){
1759				isEndSlugFound = true;
1760				continue
1761			}
1762			
1763			if(value === "__ucor__"){
1764				isOrSlugFound = true;
1765				continue
1766			}
1767
1768			if(strValues){
1769				moreThenOne = true;
1770				strValues += ".";
1771			}
1772
1773			strValues += value;
1774		}
1775
1776		if(isDebug == true){
1777			trace("more then one: "+moreThenOne);
1778			trace("is end found: "+isEndSlugFound);
1779		}
1780		
1781		var addAnd = (moreThenOne == true && isGroup !== true || isEndSlugFound);
1782		
1783		if(isOrSlugFound === true)
1784			addAnd = false;
1785		
1786		if(addAnd)
1787			strValues += ".*";
1788
1789		if(isDebug)
1790			trace("str values: "+strValues);
1791		
1792		return(strValues);
1793	}
1794
1795
1796	/**
1797	 * build grouped values query string
1798	 * format: key:value1.value2.*;key2:value3
1799	 * used for ucterms (taxonomy:slugs) and ucmeta (meta_key:values)
1800	 */
1801	function buildGroupedValuesQuery(arrItems, keyName, valueName){
1802		
1803		var isDebug = false;
1804
1805		if(!keyName)
1806			keyName = "taxonomy";
1807
1808		if(!valueName)
1809			valueName = "slug";
1810
1811		var query = "";
1812
1813		var arrGrouped = {};
1814		var arrGroupItems = [];
1815
1816		if(isDebug == true){
1817			trace("arr items");
1818			trace(arrItems);
1819		}
1820		
1821		jQuery.each(arrItems, function(index, objItem){
1822
1823			//group
1824			if(jQuery.isArray(objItem) && objItem.length != 0){
1825				
1826				if(objItem.length == 1){
1827					arrGrouped = buildGroupedValuesQuery_handleItem(objItem[0], arrGrouped, keyName, valueName);
1828					return;
1829				}
1830
1831				var arrGroupMap = {};
1832				
1833				jQuery.each(objItem, function(index, groupItem){
1834					
1835					arrGroupMap = buildGroupedValuesQuery_handleItem(groupItem, arrGroupMap, keyName, valueName);
1836				});
1837
1838				arrGroupItems.push(arrGroupMap);
1839
1840			}else{	//single
1841
1842				arrGrouped = buildGroupedValuesQuery_handleItem(objItem, arrGrouped, keyName, valueName);
1843			}
1844
1845		});
1846		
1847		if(isDebug == true){
1848			trace("first arr grouped");
1849			trace(arrGrouped);
1850		}
1851
1852		if(jQuery.isEmptyObject(arrGrouped) && jQuery.isEmptyObject(arrGroupItems))
1853			return(null);
1854
1855		if(isDebug == true){
1856			trace("group items");
1857			trace(arrGroupItems);
1858		}
1859		
1860		var isMultipleGroups = (arrGroupItems.length > 1);
1861		
1862		jQuery.each(arrGroupItems, function(index, objGroupKeys){
1863			
1864			jQuery.each(objGroupKeys, function(key, objValues){
1865				
1866			var strValues = buildGroupedValuesQuery_getStrValues(objValues, true);
1867			
1868			var strAdd = strValues;
1869			if(isMultipleGroups === true && strValues.indexOf(".") !== -1){
1870				strAdd = "|"+strValues+"|";	//OR inside the group - only when multiple groups
1871			}
1872				
1873				var objKeyValues = getVal(arrGrouped, key);
1874				if(!objKeyValues)
1875					objKeyValues = {};
1876		
1877				objKeyValues[strAdd] = true;
1878		
1879				arrGrouped[key] = objKeyValues;
1880			});
1881
1882		});
1883
1884		
1885		if(isDebug == true){
1886			trace("The result after grouping");
1887			trace(arrGrouped);
1888		}
1889
1890		jQuery.each(arrGrouped, function(key, objValues){
1891			
1892			var strValues = buildGroupedValuesQuery_getStrValues(objValues);
1893				
1894			var strPart = key + g_options.urlkey_taxsap + strValues;
1895			
1896			if(query)
1897				query += ";";
1898
1899			query += strPart;
1900
1901		});
1902
1903		if(isDebug == true){
1904			trace("query");
1905			trace(query);
1906		}
1907
1908		return(query);
1909	}
1910
1911	/**
1912	 * build terms query
1913	 * ucterms=category:blog.cocktails.design.*
1914	 */
1915	function buildTermsQuery(arrTerms){
1916
1917		return buildGroupedValuesQuery(arrTerms, "taxonomy", "slug");
1918	}
1919
1920	/**
1921	 * build meta query - same format as terms
1922	 * ucmeta=meta_key:value1.value2.*
1923	 */
1924	function buildMetaQuery(arrMeta){
1925
1926		//normalize: ensure meta_key exists (fallback from slug)
1927		var arrNormalized = [];
1928
1929		jQuery.each(arrMeta, function(index, item){
1930
1931			if(jQuery.isArray(item)){
1932
1933				var arrGroup = [];
1934
1935				jQuery.each(item, function(groupIndex, groupItem){
1936
1937					if(!groupItem)
1938						return(true);
1939
1940					if(!groupItem.meta_key && groupItem.slug)
1941						groupItem.meta_key = groupItem.slug;
1942
1943					if(typeof groupItem.meta_value === "undefined" || groupItem.meta_value === null)
1944						groupItem.meta_value = "";
1945
1946					arrGroup.push(groupItem);
1947				});
1948
1949				arrNormalized.push(arrGroup);
1950
1951			}else{
1952
1953				if(!item)
1954					return(true);
1955
1956				if(!item.meta_key && item.slug)
1957					item.meta_key = item.slug;
1958
1959				if(typeof item.meta_value === "undefined" || item.meta_value === null)
1960					item.meta_value = "";
1961
1962				arrNormalized.push(item);
1963			}
1964
1965		});
1966
1967		return buildGroupedValuesQuery(arrNormalized, "meta_key", "meta_value");
1968	}
1969
1970	/**
1971	 * get selected filter element data
1972	 */
1973	function getFilterElementData(objElement){
1974				
1975		var id = objElement.data("id");
1976		var title = objElement.data("title");
1977		var key = objElement.data("key");
1978		var type = objElement.data("type");
1979		

1980		if(!id && !key)
1981			return(null);
1982		
1983		
1984		switch(type){
1985		case "taxonomy":
1986		default:
1987			var slug = objElement.data("slug");
1988			var taxonomy = objElement.data("taxonomy");
1989			
1990			var objTerm = {
1991				"type": type,
1992				"id": id,
1993				"slug": slug,
1994				"taxonomy": taxonomy,
1995				"title": title,
1996				"key": key
1997			};
1998			return(objTerm);
1999			
2000		break;
2001		case "author":
2002			
2003			var username = objElement.data("username");
2004			
2005			var objAuthor = {
2006					"type": type,
2007					"id": id,
2008					"username": username,
2009					"title": title,
2010					"key": key
2011				};
2012				return(objAuthor);
2013			
2014		break;
2015		case "meta":
2016
2017			var slug = objElement.data("slug");
2018			var metaKey = objElement.data("metakey");
2019			var metaValue = objElement.data("metavalue");
2020
2021			if(!metaKey)
2022				metaKey = slug;
2023
2024			if(!metaValue)
2025				metaValue = "";
2026
2027			var objMeta = {
2028				"type": type,
2029				"id": id,
2030				"slug": slug,
2031				"meta_key": metaKey,
2032				"meta_value": metaValue,
2033				"title": title,
2034				"key": key
2035			};
2036			return(objMeta);
2037
2038		break;
2039		}
2040		
2041	}
2042
2043
2044	function ________AJAX_CACHE_________(){}
2045
2046	/**
2047	 * get ajax url
2048	 */
2049	function getAjaxCacheKeyFromUrl(ajaxUrl){
2050
2051		var key = ajaxUrl;
2052
2053		key = key.replace(g_urlAjax, "");
2054		key = key.replace(g_urlBase, "");
2055
2056		//replace special signs
2057		key = replaceAll(key, "/","");
2058		key = replaceAll(key, "?","_");
2059		key = replaceAll(key, "&","_");
2060		key = replaceAll(key, "=","_");
2061
2062		return(key);
2063	}
2064
2065	/**
2066	 * get ajax cache key
2067	 */
2068	function getAjaxCacheKey(ajaxUrl, action, objData){
2069
2070	    if(g_options.is_cache_enabled == false)
2071	    	return(false);
2072
2073	    //cache only by url meanwhile
2074
2075	    if(jQuery.isEmptyObject(objData) == false)
2076	    	return(false);
2077
2078	    if(action)
2079	    	return(false);
2080
2081	    var cacheKey = getAjaxCacheKeyFromUrl(ajaxUrl);
2082
2083	    if(!cacheKey)
2084	    	return(false);
2085
2086	    return(cacheKey);
2087	}
2088
2089
2090	/**
2091	 * cache ajax response
2092	 */
2093	function cacheAjaxResponse(ajaxUrl, action, objData, response){
2094
2095	    var cacheKey = getAjaxCacheKey(ajaxUrl, action, objData);
2096
2097	    if(!cacheKey)
2098	    	return(false);
2099
2100	    //some precoutions for overload
2101	    if(g_cache.length > 100)
2102	    	return(false);
2103
2104	    g_cache[cacheKey] = response;
2105
2106	}
2107
2108
2109	function ________AJAX_RESPONSE_______________(){}
2110
2111	/**
2112	 * replace the grid debug
2113	 */
2114	function operateAjax_setHtmlDebug(response, objGrid){
2115
2116		//replace the debug
2117		var htmlDebug = getVal(response, "html_debug");
2118
2119		if(!htmlDebug)
2120			return(false);
2121		
2122		var gridParent = objGrid.parents("." + g_vars.class_widget_wrapper);
2123		
2124		var objDebug = gridParent.find(".uc-debug-query-wrapper");
2125
2126		if(objDebug.length == 0)
2127			return(false);
2128
2129		objDebug.replaceWith(htmlDebug);
2130	}
2131
2132
2133	/**
2134	 * set html grid from ajax response
2135	 */
2136	function operateAjax_setHtmlGrid(response, objGrid, isLoadMore){
2137		
2138		if(g_showDebug == true){
2139			trace("set html grid, response: ");
2140			trace(response);
2141
2142			trace("obj grid:");
2143			trace(objGrid);
2144		}
2145
2146		if(objGrid.length == 0)
2147			return(false);
2148		
2149		//skip set html if exists
2150		if(objGrid.data(g_vars.GRID_DATA_SKIP_HTML) === true){
2151			
2152			if(g_showDebug == true)
2153				trace("skip set html");
2154			
2155			objGrid.data(g_vars.GRID_DATA_SKIP_HTML,false);
2156			return(false);
2157		}
2158		
2159		var objItemsWrapper = getGridItemsWrapper(objGrid);
2160		var objItemsWrapper2 = getGridItemsWrapper(objGrid, true);
2161
2162		if(g_showDebug == true){
2163			trace("items wrapper 1: ");
2164			trace(objItemsWrapper);
2165
2166			trace("items wrapper 2:");
2167			trace(objItemsWrapper2);
2168		}
2169
2170
2171		if(!objItemsWrapper || objItemsWrapper.length == 0)
2172			throw new Error("Missing items wrapper: .uc-items-wrapper");
2173
2174		operateAjax_setHtmlDebug(response, objGrid);
2175
2176		//set grid items
2177
2178		//if init filters mode, and no items response - don't set
2179		if(response.hasOwnProperty("html_items") == false)
2180			return(false);
2181		
2182		var htmlItems = getVal(response, "html_items");
2183				
2184		var htmlItems2 = null;
2185
2186		if(objItemsWrapper2)
2187			htmlItems2 = getVal(response, "html_items2");
2188
2189		//replace widget id
2190		var gridID = objGrid.attr("id");
2191
2192		htmlItems = replaceAll(htmlItems, "%uc_widget_id%", gridID);
2193		
2194		if(htmlItems2)
2195			htmlItems2 = replaceAll(htmlItems2, "%uc_widget_id%", gridID);
2196
2197		var isCustomRefresh = objGrid.data("custom-sethtml");
2198
2199		//show / hide empty message if available and empty response
2200		var objEmptyMessage = getGridEmptyMessage(objGrid);
2201
2202		if(objEmptyMessage){
2203			if(htmlItems == "")
2204				objEmptyMessage.show();
2205			else
2206				objEmptyMessage.hide();
2207		}
2208
2209		//set the query data

2210		var queryDataOriginal = getVal(response, "query_data");
2211		var queryIDs = getVal(response,"query_ids");
2212
2213		var queryData = jQuery.extend({}, queryDataOriginal);
2214
2215		//add to old data
2216
2217		if(isLoadMore == true){
2218
2219			var currentQueryData = objGrid.attr("querydata");
2220
2221			var objCurrentData = jQuery.parseJSON(currentQueryData);
2222			var currentNumPosts = getVal(objCurrentData, "count_posts");
2223
2224			queryData.count_posts += currentNumPosts;
2225
2226			var currentQueryIDs = objGrid.data("postids");
2227
2228			if(queryIDs && currentQueryIDs)
2229				queryIDs = currentQueryIDs + "," + queryIDs;
2230		}
2231
2232		//query data replace
2233
2234		if(queryData){
2235
2236			objGrid.removeAttr("querydata");
2237
2238			var jsonData = JSON.stringify(queryData);
2239			objGrid.attr("querydata", jsonData);
2240
2241			objGrid.data("querydata", queryData);
2242		}
2243
2244		//post id's replace
2245
2246		objGrid.removeAttr("data-postids");
2247		objGrid.attr("data-postids", queryIDs);
2248		objGrid.data("postids", queryIDs);
2249
2250
2251		//if custom refresh - just save the new html in data
2252		if(isCustomRefresh == true){
2253
2254			objGrid.trigger(g_vars.EVENT_SET_HTML_ITEMS,[htmlItems, isLoadMore, htmlItems2]);
2255			return(false);
2256		}
2257
2258
2259		if(!htmlItems2)
2260			htmlItems2 = "";
2261
2262		if(isLoadMore === true){
2263
2264			if(g_showDebug == true){
2265				trace("append load more");
2266			}
2267
2268			objItemsWrapper.append(htmlItems);
2269
2270			if(objItemsWrapper)
2271				objItemsWrapper.append(htmlItems2);
2272
2273		}else{
2274						
2275			objItemsWrapper.html(htmlItems);
2276
2277			if(objItemsWrapper2 && objItemsWrapper2.length)
2278				objItemsWrapper2.html(htmlItems2);
2279
2280		}
2281		
2282		
2283		return(true);
2284	}
2285
2286
2287	/**
2288	 * refresh synced grids
2289	 */
2290	function operateAjax_setHtmlSyngGrids(response, objGrid, isLoadMore){
2291		
2292		var objSyncWidgetsResponse = getVal(response, "html_sync_widgets");
2293
2294		if(g_showDebug == true){
2295			trace("set html sync grids");
2296			trace(objSyncWidgetsResponse);
2297		}
2298
2299		var queryData = getVal(response,"query_data");
2300
2301		if(!objSyncWidgetsResponse){
2302			
2303			if(g_showDebug == true){
2304				trace("no sync widgets response");
2305			}
2306			
2307			return(false);
2308		}
2309		
2310		var group = objGrid.data("filtergroup");
2311		
2312		jQuery.each(objSyncWidgetsResponse, function(elementID, childResponse){
2313			
2314			var objGridWidget = getGridFromElementorElementID(elementID, group);
2315			
2316			if(!objGridWidget){
2317				
2318				if(g_showDebug == true){
2319					trace("no grid widget found: "+elementID);
2320					
2321					getGridFromElementorElementID(elementID,group,true);	//for debug
2322				}
2323				
2324				return(true);
2325			}
2326
2327			if(g_showDebug == true){
2328				trace("set sync grid!");
2329				trace(objGridWidget);
2330				trace(childResponse);
2331			}
2332			
2333			
2334			objGridWidget.removeClass(g_vars.CLASS_REFRESH_SOON);
2335			
2336			childResponse.query_data = queryData;
2337			
2338			operateAjax_setHtmlGrid(childResponse, objGridWidget, isLoadMore);
2339			
2340			objGridWidget.trigger(g_vars.EVENT_AJAX_REFRESHED);
2341			g_objBody.trigger(g_vars.EVENT_AJAX_REFRESHED_BODY, [objGridWidget]);
2342
2343		});
2344
2345	}
2346
2347
2348	/**
2349	 * replace filters html
2350	 */
2351	function operateAjax_setHtmlWidgets(response, objFilters){
2352
2353		if(!objFilters)
2354			return(false);
2355
2356		if(objFilters.length == 0)
2357			return(false);
2358
2359		var objHtmlWidgets = getVal(response, "html_widgets");
2360
2361		if(!objHtmlWidgets)
2362			return(false);
2363
2364		if(objHtmlWidgets.length == 0)
2365			return(false);
2366
2367		var objHtmlDebug = getVal(response, "html_widgets_debug");
2368
2369		jQuery.each(objFilters, function(index, objFilter){
2370
2371			var widgetID = getElementWidgetID(objFilter);
2372
2373			if(!widgetID)
2374				return(true);
2375
2376			var html = getVal(objHtmlWidgets, widgetID);
2377
2378			if(!html)
2379				return(true);
2380
2381			var objHtml = jQuery(html);
2382
2383			var htmlInner = objHtml.html();
2384
2385			//set the class
2386
2387			var filterClassName = objHtml.attr("class");
2388
2389			filterClassName += " "+g_vars.CLASS_FILTER_INITED;
2390
2391			objFilter.attr("class", filterClassName);
2392
2393			objFilter.removeClass(g_vars.CLASS_INITING);
2394			objFilter.removeClass(g_vars.CLASS_REFRESH_SOON);
2395
2396			objFilter.html(htmlInner);
2397
2398
2399
2400			//---- put the debug if exists
2401
2402			var htmlDebug = null;
2403
2404			if(objHtmlDebug)
2405				var htmlDebug = getVal(objHtmlDebug, widgetID);
2406
2407			if(htmlDebug){
2408				var objParent = objFilter.parents("." + g_vars.class_widget_wrapper);
2409				var objDebug = objParent.find(".uc-div-ajax-debug");
2410
2411				if(objDebug.length)
2412					objDebug.replaceWith(htmlDebug);
2413			}
2414			
2415			objFilter.trigger(g_vars.EVENT_FILTER_RELOADED);
2416
2417		});
2418
2419	}
2420

2421	/**
2422	 * scroll to grid top
2423	 */
2424	function scrollToGridTop(objGrid){
2425
2426		var gapTop = 150;
2427
2428		var gridOffset = objGrid.offset().top;
2429
2430		var gridTop = gridOffset - gapTop;
2431
2432		if(gridTop < 0)
2433			gridTop = 0;
2434
2435		//check if the grid top is visible
2436
2437		var currentPos = jQuery(window).scrollTop();
2438
2439		if(currentPos <= gridOffset)
2440			return(false);
2441
2442		window.scrollTo({ top: gridTop, behavior: 'smooth' });
2443
2444	}
2445
2446
2447	/**
2448	 * operate the response
2449	 */
2450	function operateAjaxRefreshResponse(response, objGrid, objFilters, isLoadMore, isNoScroll){
2451		
2452		var isGridRefreshed = operateAjax_setHtmlGrid(response, objGrid, isLoadMore);
2453		
2454		operateAjax_setHtmlWidgets(response, objFilters);
2455		
2456		operateAjax_setHtmlSyngGrids(response, objGrid, isLoadMore);
2457		
2458		objGrid.trigger(g_vars.EVENT_AJAX_REFRESHED,[{isLoadMore:isLoadMore}]);
2459		g_objBody.trigger(g_vars.EVENT_AJAX_REFRESHED_BODY, [objGrid]);
2460		
2461		//trigger body as well
2462
2463		//scroll to grid top
2464		if(isLoadMore == false && isGridRefreshed == true && isNoScroll !== true){
2465						
2466			setTimeout(function(){
2467				
2468				scrollToGridTop(objGrid);
2469					
2470			},200);
2471
2472		}
2473
2474	}
2475
2476
2477	/**
2478	 * replace all occurances
2479	 */
2480	function replaceAll(text, from, to){
2481
2482		return text.split(from).join(to);
2483	};
2484
2485
2486
2487
2488	/**
2489	 * get response from ajax cache
2490	 */
2491	function getResponseFromAjaxCache(ajaxUrl, action, objData){
2492
2493	    var cacheKey = getAjaxCacheKey(ajaxUrl, action, objData);
2494
2495	    if(!cacheKey)
2496	    	return(false);
2497
2498	    var response = getVal(g_cache, cacheKey);
2499
2500	    return(response);
2501	}
2502
2503
2504	function ________AJAX_______________(){}
2505
2506	/**
2507	 * set this filter not to refresh next time
2508	 */
2509	function setNoRefreshFilter(objFilter){
2510
2511		objFilter.data("uc_norefresh",true);
2512
2513	}
2514
2515	/**
2516	 * show ajax error, should be something visible
2517	 */
2518	function showAjaxError(message){
2519
2520		alert(message);
2521
2522	}
2523
2524	/**
2525	 * get the debug object
2526	 */
2527	function getDebugObject(){
2528
2529		var objGrid = g_lastGridAjaxCall;
2530
2531		if(!objGrid)
2532			return(null);
2533
2534		var objDebug = objGrid.find("."+g_vars.CLASS_DIV_DEBUG);
2535
2536		if(objDebug.length)
2537			return(objDebug);
2538
2539		//insert if not exists
2540
2541		objGrid.after("<div class='"+g_vars.CLASS_DIV_DEBUG+"' style='padding:10px;display:none;background-color:#D8FCC6'></div>");
2542
2543		var objDebug = jQuery("body").find("."+g_vars.CLASS_DIV_DEBUG);
2544
2545		return(objDebug);
2546	}
2547
2548
2549	/**
2550	 * show ajax debug
2551	 */
2552	function showAjaxDebug(str){
2553
2554		trace("Ajax Error! - Check the debug");
2555
2556		str = jQuery.trim(str);
2557
2558		if(!str || str.length == 0)
2559			return(false);
2560
2561		var objStr = jQuery(str);
2562
2563		if(objStr.find("header").length || objStr.find("body").length){
2564			str = "Wrong ajax response!";
2565		}
2566
2567		var objDebug = getDebugObject();
2568
2569		if(!objDebug || objDebug.length == 0){
2570
2571			alert(str);
2572
2573			throw new Error("debug not found");
2574		}
2575
2576		objDebug.show();
2577		objDebug.html(str);
2578
2579	}
2580
2581
2582	/**
2583	 * small ajax request
2584	 */
2585	function ajaxRequest(ajaxUrl, action, objData, onSuccess){
2586				
2587		if(g_debugInitMode === true){
2588
2589			trace("debug init mode - skip request");
2590			return(false);
2591		}
2592
2593		if(g_showDebug == true){
2594			trace("ajax request");
2595			trace(ajaxUrl);
2596		}
2597
2598		if(!objData)
2599			var objData = {};
2600
2601		if(typeof objData != "object")
2602			throw new Error("wrong ajax param");
2603
2604		//check response from cache
2605		var responseFromCache = getResponseFromAjaxCache(ajaxUrl, action, objData);
2606
2607		if(responseFromCache){
2608
2609			//simulate ajax request
2610			setTimeout(function(){
2611				onSuccess(responseFromCache);
2612			}, 300);
2613
2614			return(false);
2615		}
2616
2617		var ajaxData = {};
2618		ajaxData["action"] = "unlimitedelements_ajax_action";
2619		ajaxData["client_action"] = action;
2620
2621		var ajaxtype = "get";
2622
2623		if(jQuery.isEmptyObject(objData) == false){
2624			ajaxData["data"] = objData;
2625			ajaxtype = "post";
2626		}
2627
2628
2629		var ajaxOptions = {
2630				type:ajaxtype,
2631				url:ajaxUrl,
2632				success:function(response){
2633
2634					if(!response){
2635						showAjaxError("Empty ajax response!");
2636						return(false);
2637					}
2638
2639					if(typeof response != "object"){
2640
2641						try{
2642
2643							response = jQuery.parseJSON(response);
2644
2645						}catch(e){
2646
2647							showAjaxDebug(response);
2648
2649							showAjaxError("Ajax Error!!! not ajax response");
2650							return(false);
2651						}
2652					}
2653
2654					if(response == -1){
2655						showAjaxError("ajax error!!!");
2656						return(false);
2657					}
2658
2659					if(response == 0){
2660						showAjaxError("ajax error, action: <b>"+action+"</b> not found");
2661						return(false);
2662					}
2663
2664					if(response.success == undefined){
2665						showAjaxError("The 'success' param is a must!");
2666						return(false);
2667					}
2668
2669
2670					if(response.success == false){
2671						showAjaxError(response.message);
2672						return(false);
2673					}
2674
2675					cacheAjaxResponse(ajaxUrl, action, objData, response);
2676
2677					if(typeof onSuccess == "function"){
2678
2679						onSuccess(response);
2680					}
2681
2682				},
2683				error:function(jqXHR, textStatus, errorThrown){
2684
2685					switch(textStatus){
2686						case "parsererror":
2687						case "error":
2688
2689							//showAjaxError("parse error");
2690
2691							showAjaxDebug(jqXHR.responseText);
2692
2693						break;
2694					}
2695				}
2696		}
2697
2698		if(ajaxtype == "post"){
2699			ajaxOptions.dataType = 'json';
2700			ajaxOptions.data = ajaxData
2701		}
2702
2703		var handle = jQuery.ajax(ajaxOptions);
2704
2705		return(handle);
2706	}
2707
2708
2709
2710	/**
2711	 * get grid items wrapper
2712	 */
2713	function getGridItemsWrapper(objGrid, isSecond){
2714
2715		var classItems = "uc-items-wrapper";
2716
2717		if(isSecond == true)
2718			classItems = "uc-items-wrapper2";
2719
2720		if(objGrid.hasClass(classItems))
2721			return(objGrid);
2722
2723		var objItemsWrapper = objGrid.find("."+classItems);
2724
2725		if(objItemsWrapper.length == 0 && isSecond == false)
2726			throw new Error("Missing items wrapper - with class: uc-items-wrapper");
2727
2728		if(objItemsWrapper.length == 0)
2729			return(null);
2730
2731		return(objItemsWrapper);
2732	}
2733
2734
2735	/**
2736	 * set ajax loader
2737	 */
2738	function showAjaxLoader(objElement){
2739
2740		objElement.addClass("uc-ajax-loading");
2741	}
2742
2743	/**
2744	 * hide ajax loader
2745	 */
2746	function hideAjaxLoader(objElement){
2747
2748		objElement.removeClass("uc-ajax-loading");
2749	}
2750
2751
2752	/**
2753	 * show multiple ajax loader
2754	 */
2755	function showMultipleAjaxLoaders(objElements, isShow){
2756
2757		if(!objElements)
2758			return(false);
2759
2760		if(objElements.length == 0)
2761			return(false);
2762
2763		jQuery.each(objElements,function(index, objElement){
2764
2765			objElement = jQuery(objElement);
2766
2767			if(isShow == true){
2768
2769				showAjaxLoader(objElement);
2770			}
2771			else
2772				hideAjaxLoader(objElement);
2773		});
2774
2775	}
2776
2777
2778	/**
2779	 * refresh ajax grid
2780	 */
2781	function refreshAjaxGrid(objGrid, refreshType){
2782				
2783		var isLoadMore = (refreshType == g_vars.REFRESH_MODE_LOADMORE);	 //for the output
2784		var isFiltersInit = (refreshType == "filters" || refreshType == "filters_children");
2785		
2786		//for the options - not refresh other filters
2787		var isLoadMoreMode = (refreshType == g_vars.REFRESH_MODE_LOADMORE || refreshType == g_vars.REFRESH_MODE_PAGINATION);
2788		
2789		//get all grid filters
2790		var objFilters = objGrid.data("filters");
2791
2792		if(!objFilters)
2793			return(false);
2794
2795		if(objFilters.length == 0)
2796			return(false);
2797
2798		if(objGrid.hasClass(g_vars.CLASS_GRID_NOREFRESH))
2799			return(false);
2800
2801		var params = {};
2802		if(refreshType == "filters_children")
2803			params["filters_init_type"] = "children";
2804		
2805		params["refresh_type"] = refreshType;
2806		
2807		var objAjaxOptions = getGridAjaxOptions(objFilters, objGrid, isFiltersInit, isLoadMoreMode, params);
2808		
2809		if(!objAjaxOptions){
2810
2811			trace("ajax options are null");
2812			return(false);
2813		}
2814
2815		var ajaxUrl = objAjaxOptions["ajax_url"];
2816		var urlReplace = objAjaxOptions["url_replace"];
2817		var arrTerms = objAjaxOptions["terms"];
2818
2819		if(g_vars.DEBUG_AJAX_OPTIONS == true){
2820
2821			trace("DEBUG AJAX OPTIONS");