kirgudu_base 0.0.3 → 0.0.4

data/app/helpers/kirgudu_base/controllers/basic_actions.rb

@@ -3,7 +3,6 @@
 module KirguduBase
 	module Controllers
 		module BasicActions
-
 			################################################################################################################
 			#########################################       Base and Ajax Modules     ######################################
 			################################################################################################################
@@ -20,89 +19,196 @@ module KirguduBase
 							raise "Method :get_kb_page must be implemented for controller '#{self.class}'"
 						end
 
-						local_page = self.class.get_kb_page(:index)
+						options = {
+							logger: string_logger
+						}
+
+						local_data = {
+							errors: [],
+							messages: [],
+						    page: self.class.get_kb_page(:index)
+						}
 
-						unless local_page
+						unless local_data[:page]
 							respond_to do |format|
-								format.html { render_html1 self.get_view_path_for_page_404 }
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :page_404)}" }
 								format.json { render_json_page_404 }
 							end
 							return
 						end
 
-						filters = self.get_filters_for_list(local_page.lists[:entries_list], params)
-
-						self.fill_obligatory_filters(filters)
-						options = {
-							logger: string_logger
-						}
-
-						local_filters_data = self.load_data_for_filters_controls(local_page.lists[:entries_list], params)
-
-						local_entries_list = self.entry_class.get_entries(nil, filters, options)
+						# fill parent for data
+						filters_for_parents = {}
+						self.fill_obligatory_filters(filters_for_parents)
+						self.fill_parents_for_local_data(local_data, filters_for_parents)
 
 
+						filters = self.get_filters_for_list(local_data[:page].lists[:entries_list], params)
+						self.fill_obligatory_filters(filters)
+						filters.merge!(local_data[:parent_ids])
+
+						filters[:per_page] = 30 unless filters[:per_page]
+						filters[:per_page] ||= 30
+
+						# retrieving filters data from database
+						local_data[:filters_data] = self.load_data_for_filters_controls(local_data[:page].lists[:entries_list], params)
+						# retrieving entries from database
+						local_data[:entries] = self.entry_class.get_entries(nil, filters, options)
+
+						# filling filters for current url
+						filters_for_current_url = self.get_filters_for_list(local_data[:page].lists[:entries_list], params)
+						filters_for_current_url.merge!(local_data[:parent_ids])
+						local_data[:current_url] = self.to_url_for(:index, filters_for_current_url)
+
+						# building breadcrumbs
+						home_controller = self.class.get_method_latest_result(:get_kb_home_controller)
+						home_controller = eval(home_controller) if home_controller and home_controller.is_a?(String)
+						if home_controller
+							if self.class == home_controller
+								add_new_breadcrumb(I18n.t("#{home_controller.to_i18n}.index.title"))
+							else
+								add_new_breadcrumb(I18n.t("#{home_controller.to_i18n}.index.title"), home_controller.to_url_for(:index))
+							end
+						end
+						parent_ids = {}
+						local_data[:parents].each do |parent|
+							# breadcrumbs: adding parent index
+							add_new_breadcrumb(I18n.t("#{parent[:controller].to_i18n}.index.title"), parent[:controller].to_url_for(:index, parent_ids))
+							# breadcrumbs: getting parent entry name
+							parent_entry_name = nil
+							parent_entry_name = parent[:entry].name_for_breadcrumbs if parent[:entry].respond_to?(:name_for_breadcrumbs)
+							parent_entry_name = parent[:entry].id unless parent_entry_name
+							# breadcrumbs: adding parent entry
+							add_new_breadcrumb(parent_entry_name, parent[:controller].to_url_for(:show, parent_ids.merge(id: parent[:entry].id)))
+							parent_ids[parent[:id_param]] = parent[:id_value]
+						end if local_data[:parents]
+						# breadcrumbs: adding current index
+						add_new_breadcrumb(I18n.t("#{self.to_i18n}.index.title"), self.to_url_for(:index, local_data[:parent_ids]))
+
+
+
+						# logger.info "TEMPLATE PATH: #{self.class.get_method_latest_result(:get_kb_template)}"
+						# logger.info "VIEW PATH: #{self.class.get_method_latest_result(:get_kb_view_path, :index)}"
+
+						# rendering page
 						respond_to do |format|
-							format.html { render_html1 self.get_view_path_for_page_index, locals: {entries_list: local_entries_list, page: local_page, filters_data: local_filters_data} }
-							format.json { render_json_ok(local_entries_list) }
+							format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :index)}", locals: {data: local_data} }
+							format.json { render_json_ok(local_data[:entries]) }
 						end
 					end
-
 				end
 
-				module ShowActions
 
-					def show
 
+				module ShowActions
+					def show
 						unless self.class.respond_to?(:get_kb_page)
 							raise "Method :get_kb_page must be implemented for controller '#{self.class}'"
 						end
 
-						local_page = self.class.get_kb_page(:show)
+						options = {
+							logger: self.string_logger
+						}
+
 
-						if local_page.nil?
+						local_data = {
+							errors: [],
+							messages: [],
+							page: self.class.get_kb_page(:show)
+						}
+
+						if local_data[:page].nil?
 							respond_to do |format|
-								format.html { render_html1 self.get_view_path_for_page_404 }
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :page_404)}" }
 								format.json { render_json_page_404 }
 							end
 							return
 						end
 
-						#::ChupakabraTools::ClassHelper.get_controller_hierarchy(self.class).each do |klass|
-						#	parent_page = klass.get_kb_page(:show) if klass.respond_to?(:get_kb_page)
-						#
-						#	parent_page.menus.each_pair do |key, parent_menu|
-						#		menu = local_page.menus[parent_menu.name]
-						#		if menu
-						#			parent_menu.items.each do |menu_item|
-						#				menu.items << menu_item
-						#			end
-						#		end
-						#	end if parent_page
-						#end
-
-
+						# fill parent for data
+						filters_for_parents = {}
+						self.fill_obligatory_filters(filters_for_parents)
+						self.fill_parents_for_local_data(local_data, filters_for_parents)
+						# fill filters for search
 						filters = {}
 						self.fill_obligatory_filters(filters)
+						filters.merge!(local_data[:parent_ids])
+						# getting local entry
+						local_data[:entry] = self.entry_class.get_entry_by_id(params[:id], filters, options)
+						# entry not found, showing not found page
+						unless local_data[:entry]
+							local_data[:errors] << I18n.t("#{self.to_i18n}.messages.not_found", entry_id: params[:id])
+							respond_to do |format|
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :entry_not_found)}", locals: {data: local_data} }
+								format.json { render_json_not_found message: local_data[:errors] }
+							end
+							return
+						end
+						# getting lists
+						local_data[:page].lists.each_pair do |key, list|
+							if list.relation
+								filters_for_list = {}
+								self.fill_obligatory_filters(filters_for_list)
+								reflection = self.entry_class.reflections[list.relation.name]
+								list_per_page = list.relation.per_page_param
+								list_page = list.relation.page_param
 
-						local_entry = self.entry_class.get_entry_by_id(params[:id], filters, {logger: string_logger})
+								begin
+									filters_for_list[:per_page] = params[list_per_page].to_i
+								rescue
+								end
+								filters_for_list[:per_page] ||= 30
+								filters_for_list[:per_page] = 30 if filters_for_list[:per_page] == 0
 
+								begin
+									filters_for_list[:page] = params[list_page].to_i if params[list_page]
+								rescue
+								end
 
-						unless local_entry
-							respond_to do |format|
-								flash[:error] = I18n.t("#{self.to_i18n}.messages.not_found", entry_id: params[:id])
-								format.html { render_html1 get_not_found_view_path,
-								                           locals: {
-									                           entry: local_entry
-								                           }
-								}
-								format.json { render json: local_entry.errors, status: :unprocessable_entity }
+								filters_for_list[reflection.foreign_key] = local_data[:entry].id
+
+								#logger.info "FILTERS for LIST: #{filters_for_list.to_json}"
+
+								local_data[:"list_entries_#{list.name}"] = eval(reflection.class_name).get_entries(nil, filters_for_list, options)
 							end
-							return
+						end if local_data[:page].lists
+
+
+						# fill parent for data
+						filters_for_parents = {}
+						self.fill_obligatory_filters(filters_for_parents)
+						self.fill_parents_for_local_data(local_data, filters_for_parents)
+						# building breadcrumbs
+						home_controller = self.class.get_method_latest_result(:get_kb_home_controller)
+						home_controller = eval(home_controller) if home_controller and home_controller.is_a?(String)
+						add_new_breadcrumb(I18n.t("#{home_controller.to_i18n}.index.title"), home_controller.to_url_for(:index)) if home_controller
+						parent_ids = {}
+						local_data[:parents].each do |parent|
+							# breadcrumbs: adding parent index
+							add_new_breadcrumb(I18n.t("#{parent[:controller].to_i18n}.index.title"), parent[:controller].to_url_for(:index, parent_ids))
+							# breadcrumbs: getting parent entry name
+							parent_entry_name = nil
+							parent_entry_name = parent[:entry].name_for_breadcrumbs if parent[:entry].respond_to?(:name_for_breadcrumbs)
+							parent_entry_name = parent[:entry].id unless parent_entry_name
+							# breadcrumbs: adding parent entry
+							add_new_breadcrumb(parent_entry_name, parent[:controller].to_url_for(:show, parent_ids.merge(id: parent[:entry].id)))
+							parent_ids[parent[:id_param]] = parent[:id_value]
+						end if local_data[:parents]
+						# breadcrumbs: adding current index
+						add_new_breadcrumb(I18n.t("#{self.to_i18n}.index.title"), self.to_url_for(:index, local_data[:parent_ids]))
+						# breadcrumbs: getting current entry name
+						current_entry_name = nil
+						if local_data[:entry].respond_to?(:name_for_breadcrumbs)
+							current_entry_name = local_data[:entry].name_for_breadcrumbs
+							#current_entry_name.trim(20) if current_entry_name
 						end
+						current_entry_name = local_data[:entry].id unless current_entry_name
+						# breadcrumbs: adding current entry
+						add_new_breadcrumb(current_entry_name)
+						# rendering page
 						respond_to do |format|
-							format.html { render_html1 self.get_view_path_for_page_show, locals: {entry: local_entry, page: local_page} }
-							format.json { render json: local_entry }
+							format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :show)}", locals: {data: local_data} }
+							format.json { render_json_ok local_data[:entry] }
 						end
 					end
 
@@ -114,29 +220,58 @@ module KirguduBase
 						unless self.class.respond_to?(:get_kb_page)
 							raise "Method :get_kb_page must be implemented for controller '#{self.class}'"
 						end
-						local_page = self.class.get_kb_page(:new)
-						unless local_page
+
+						local_data = {
+							messages: [],
+							errors: [],
+							page: self.class.get_kb_page(:new)
+						}
+
+						unless local_data[:page]
 							respond_to do |format|
-								format.html { render_html1 self.get_view_path_for_page_404 }
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :page_404)}" }
 								format.json { render_json_page_404 }
 							end
 							return
 						end
-						local_entry = entry_class.new
 
-						# loading data for select-like controls
-						local_controls_data = self.load_data_for_entry_controls(local_page.forms[:changes], local_entry)
+						filters = {}
+						self.fill_obligatory_filters(filters)
 
+						# getting entry
+						local_data[:entry] = entry_class.new
+						# getting controls data
+						local_data[:controls_data] = self.load_data_for_entry_controls(local_data[:page].forms[:changes], local_data[:entry])
+
+						# fill parent for data
+						filters_for_parents = {}
+						self.fill_obligatory_filters(filters_for_parents)
+						self.fill_parents_for_local_data(local_data, filters_for_parents)
+
+						# building breadcrumbs
+						home_controller = self.class.get_method_latest_result(:get_kb_home_controller)
+						home_controller = eval(home_controller) if home_controller and home_controller.is_a?(String)
+						add_new_breadcrumb(I18n.t("#{home_controller.to_i18n}.index.title"), home_controller.to_url_for(:index)) if home_controller
+						parent_ids = {}
+						local_data[:parents].each do |parent|
+							# breadcrumbs: adding parent index
+							add_new_breadcrumb(I18n.t("#{parent[:controller].to_i18n}.index.title"), parent[:controller].to_url_for(:index, parent_ids))
+							# breadcrumbs: getting parent entry name
+							parent_entry_name = nil
+							parent_entry_name = parent[:entry].name_for_breadcrumbs if parent[:entry].respond_to?(:name_for_breadcrumbs)
+							parent_entry_name = parent[:entry].id unless parent_entry_name
+							# breadcrumbs: adding parent entry
+							add_new_breadcrumb(parent_entry_name, parent[:controller].to_url_for(:show, parent_ids.merge(id: parent[:entry].id)))
+							parent_ids[parent[:id_param]] = parent[:id_value]
+						end if local_data[:parents]
+						# breadcrumbs: adding current index
+						add_new_breadcrumb(I18n.t("#{self.to_i18n}.index.title"), self.to_url_for(:index, local_data[:parent_ids]))
+						add_new_breadcrumb(I18n.t("#{self.to_i18n}.new.title"))
+
+						# rendering page
 						respond_to do |format|
-							format.html { render_html1 self.get_view_path_for_page_new,
-							                           locals:
-								                           {
-									                           entry: local_entry,
-									                           page: local_page,
-									                           controls_data: local_controls_data
-								                           }
-							}
-							format.json { render json: local_entry }
+							format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :new)}", locals: {data: local_data} }
+							format.json { render_json_ok local_data[:entry] }
 						end
 					end
 
@@ -145,33 +280,48 @@ module KirguduBase
 						unless self.class.respond_to?(:get_kb_page)
 							raise "Method :get_kb_page must be implemented for controller '#{self.class}'"
 						end
-						local_page = self.class.get_kb_page(:new)
-						unless local_page
+
+						local_data = {
+							messages: [],
+							errors: [],
+							page: self.class.get_kb_page(:new)
+						}
+
+						unless local_data[:page]
 							respond_to do |format|
-								format.html { render_html1 self.get_view_path_for_page_404 }
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :page_404)}" }
 								format.json { render_json_page_404 }
 							end
 							return
 						end
 
-						strong_params = {}.merge(self.class_strong_params(local_page.forms[:changes]))
-						self.fill_obligatory_filters(strong_params)
 
-						local_entry = self.entry_class.new(strong_params)
+						# fill parent for data
+						filters_for_parents = {}
+						self.fill_obligatory_filters(filters_for_parents)
+						self.fill_parents_for_local_data(local_data, filters_for_parents)
 
-						self.process_transaction_injections(local_entry, :create, :before_transaction, strong_params)
 
+						strong_params = {}.merge(self.class_strong_params(local_data[:page].forms[:changes]))
+						self.fill_obligatory_filters(strong_params)
+						strong_params.merge!(local_data[:parent_ids])
+
+						# getting entry
+						local_data[:entry] = self.entry_class.new(strong_params)
+
+						# pre create
+						self.process_transaction_injections(local_data[:entry], :create, :before_transaction, strong_params)
 						transaction_is_ok = true
 
 						ActiveRecord::Base.transaction do
 							#raise "In Transaction Before Create"
-							unless self.process_transaction_injections(local_entry, :create, :before_save, strong_params)
+							unless self.process_transaction_injections(local_data[:entry], :create, :before_save, strong_params)
 								transaction_is_ok = false
 								raise ActiveRecord::Rollback
 							end
 
-							if local_entry.save
-								unless process_transaction_injections(local_entry, :create, :after_save, strong_params)
+							if local_data[:entry].save
+								unless process_transaction_injections(local_data[:entry], :create, :after_save, strong_params)
 									transaction_is_ok = false
 									raise ActiveRecord::Rollback
 								end
@@ -181,26 +331,42 @@ module KirguduBase
 							end
 						end
 
-						self.process_transaction_injections(local_entry, :create, :after_transaction, strong_params)
+						self.process_transaction_injections(local_data[:entry], :create, :after_transaction, strong_params)
 
 						respond_to do |format|
 							if transaction_is_ok
-								flash[:success] = I18n.t("#{self.to_i18n}.messages.entry_created", entry_name: local_entry.to_s)
-								format.html { render_redirect url_for(action: :show, id: local_entry) }
-								format.json { render json: local_entry, status: :created, location: local_entry }
+								local_data[:messages] << I18n.t("#{self.to_i18n}.messages.entry_created", entry_name: local_data[:entry].to_s)
+								format.html { render_redirect self.to_url_for(:show, local_data[:parent_ids].merge(id: local_data[:entry].id)) }
+								format.json { render_json_ok local_data[:entry], message: local_data[:messages] }
 							else
 								# loading data for select-like controls
-								local_controls_data = self.load_data_for_entry_controls(local_page.forms[:changes], local_entry)
-								local_entry.errors[:form] << I18n.t("#{self.to_i18n}.messages.create_error")
-								format.html { render_html1 self.get_view_path_for_page_new,
-								                           locals:
-									                           {
-										                           entry: local_entry,
-										                           page: local_page,
-										                           controls_data: local_controls_data
-									                           }
-								}
-								format.json { render json: local_entry.errors, status: :unprocessable_entity }
+								local_data[:controls_data] = self.load_data_for_entry_controls(local_data[:page].forms[:changes], local_data[:entry])
+								local_data[:errors] << I18n.t("#{self.to_i18n}.messages.create_error")
+
+
+								# building breadcrumbs
+								home_controller = self.class.get_method_latest_result(:get_kb_home_controller)
+								home_controller = eval(home_controller) if home_controller and home_controller.is_a?(String)
+								add_new_breadcrumb(I18n.t("#{home_controller.to_i18n}.index.title"), home_controller.to_url_for(:index)) if home_controller
+								parent_ids = {}
+								local_data[:parents].each do |parent|
+									# breadcrumbs: adding parent index
+									add_new_breadcrumb(I18n.t("#{parent[:controller].to_i18n}.index.title"), parent[:controller].to_url_for(:index, parent_ids))
+									# breadcrumbs: getting parent entry name
+									parent_entry_name = nil
+									parent_entry_name = parent[:entry].name_for_breadcrumbs if parent[:entry].respond_to?(:name_for_breadcrumbs)
+									parent_entry_name = parent[:entry].id unless parent_entry_name
+									# breadcrumbs: adding parent entry
+									add_new_breadcrumb(parent_entry_name, parent[:controller].to_url_for(:show, parent_ids.merge(id: parent[:entry].id)))
+									parent_ids[parent[:id_param]] = parent[:id_value]
+								end if local_data[:parents]
+								# breadcrumbs: adding current index
+								add_new_breadcrumb(I18n.t("#{self.to_i18n}.index.title"), self.to_url_for(:index, local_data[:parent_ids]))
+								add_new_breadcrumb(I18n.t("#{self.to_i18n}.new.title"))
+
+								# rendering page
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :new)}", locals: {data: local_data} }
+								format.json { render_json_error local_data[:entry], message: local_data[:errors] }
 							end
 						end
 					end
@@ -215,42 +381,71 @@ module KirguduBase
 							raise "Method :get_kb_page must be implemented for controller '#{self.class}'"
 						end
 
-						local_page = self.class.get_kb_page(:edit)
+						local_data = {
+							errors: [],
+							messages: [],
+							page: self.class.get_kb_page(:edit)
+						}
 
-						unless local_page
+						unless local_data[:page]
 							respond_to do |format|
-								format.html { render_html1 get_view_path_for_page_404 }
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :page_404)}" }
 								format.json { render_json_page_404 }
 							end
 							return
 						end
 
+						# fill parent for data
+						filters_for_parents = {}
+						self.fill_obligatory_filters(filters_for_parents)
+						self.fill_parents_for_local_data(local_data, filters_for_parents)
+						# filling filters for search
 						filters = {}
 						self.fill_obligatory_filters(filters)
-
-						local_entry = self.entry_class.get_entry_by_id(params[:id], filters, {logger: string_logger})
-
-						unless local_entry
+						filters.merge!(local_data[:parent_ids])
+						# retrieving entry from database
+						local_data[:entry] = self.entry_class.get_entry_by_id(params[:id], filters, {logger: string_logger})
+						# entry not found, showing not found page
+						unless local_data[:entry]
+							local_data[:errors] << I18n.t("#{self.to_i18n}.messages.not_found", entry_id: params[:id])
 							respond_to do |format|
-								flash[:error] = I18n.t("#{self.to_i18n}.messages.not_found", entry_id: params[:id])
-								format.html { render_html1 self.get_not_found_view_path, locals: {entry: local_entry} }
-								format.json { render json: local_entry.errors, status: :unprocessable_entity }
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :entry_not_found)}", locals: {data: local_data} }
+								format.json { render_json_not_found message: local_data[:errors] }
 							end
 							return
 						end
-						# loading data for select-like controls
-						local_controls_data = self.load_data_for_entry_controls(local_page.forms[:changes], local_entry)
-
+						# loading data for controls
+						local_data[:controls_data] = self.load_data_for_entry_controls(local_data[:page].forms[:changes], local_data[:entry])
+
+						# fill parent for data
+						filters_for_parents = {}
+						self.fill_obligatory_filters(filters_for_parents)
+						self.fill_parents_for_local_data(local_data, filters_for_parents)
+						# building breadcrumbs
+						home_controller = self.class.get_method_latest_result(:get_kb_home_controller)
+						home_controller = eval(home_controller) if home_controller and home_controller.is_a?(String)
+						add_new_breadcrumb(I18n.t("#{home_controller.to_i18n}.index.title"), home_controller.to_url_for(:index)) if home_controller
+						parent_ids = {}
+						local_data[:parents].each do |parent|
+							# breadcrumbs: adding parent index
+							add_new_breadcrumb(I18n.t("#{parent[:controller].to_i18n}.index.title"), parent[:controller].to_url_for(:index, parent_ids))
+							# breadcrumbs: getting parent entry name
+							parent_entry_name = nil
+							parent_entry_name = parent[:entry].name_for_breadcrumbs if parent[:entry].respond_to?(:name_for_breadcrumbs)
+							parent_entry_name = parent[:entry].id unless parent_entry_name
+							# breadcrumbs: adding parent entry
+							add_new_breadcrumb(parent_entry_name, parent[:controller].to_url_for(:show, parent_ids.merge(id: parent[:entry].id)))
+							parent_ids[parent[:id_param]] = parent[:id_value]
+						end if local_data[:parents]
+						# breadcrumbs: adding current index
+						add_new_breadcrumb(I18n.t("#{self.to_i18n}.index.title"), self.to_url_for(:index, local_data[:parent_ids]))
+						# breadcrumbs: adding current entry
+						add_new_breadcrumb(local_data[:entry].id)
+
+						# rendering page
 						respond_to do |format|
-							format.html { render_html1 self.get_view_path_for_page_edit,
-							                           locals:
-								                           {
-									                           entry: local_entry,
-									                           page: local_page,
-									                           controls_data: local_controls_data
-								                           }
-							}
-							format.json { render json: local_entry }
+							format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :edit)}", locals: {data: local_data} }
+							format.json { render_json_ok local_data[:entry] }
 						end
 					end
 
@@ -261,45 +456,55 @@ module KirguduBase
 							raise "Method :get_kb_page must be implemented for controller '#{self.class}'"
 						end
 
-						local_page = self.class.get_kb_page(:edit)
+						local_data = {
+							errors: [],
+							messages: [],
+							page: self.class.get_kb_page(:edit)
+						}
 
-						unless local_page
+						unless local_data[:page]
 							respond_to do |format|
-								format.html { render_html1 self.get_view_path_for_page_404 }
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :page_404)}" }
 								format.json { render_json_page_404 }
 							end
 							return
 						end
 
 
-						local_entry = self.entry_class.get_entry_by_id(params[:id], nil, {logger: string_logger})
-
-						# Render NOT FOUND Form
-						unless local_entry
+						# fill parent for data
+						filters_for_parents = {}
+						self.fill_obligatory_filters(filters_for_parents)
+						self.fill_parents_for_local_data(local_data, filters_for_parents)
+						# filling filters for search
+						filters = {}
+						self.fill_obligatory_filters(filters)
+						filters.merge!(local_data[:parent_ids]) # merging search filters with parent ids
+						# retrieving data from database
+						local_data[:entry] = self.entry_class.get_entry_by_id(params[:id], filters, {logger: string_logger})
+						# entry not found, showing not found page
+						unless local_data[:entry]
+							local_data[:errors] << I18n.t("#{self.to_i18n}.messages.not_found", entry_id: params[:id])
 							respond_to do |format|
-								flash[:error] = I18n.t("#{self.to_i18n}.messages.not_found", entry_id: params[:id])
-								format.html { render_html1 self.get_not_found_view_path, locals: {entry: local_entry} }
-								format.json { render json: nil, status: :unprocessable_entity }
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :entry_not_found)}", locals: {data: local_data} }
+								format.json { render_json_not_found message: local_data[:errors] }
 							end
 							return
 						end
-
-						strong_params = {}.merge(self.class_strong_params(local_page.forms[:changes]))
+						# getting string params from params
+						strong_params = {}.merge(self.class_strong_params(local_data[:page].forms[:changes]))
 						self.fill_obligatory_filters(strong_params)
 
-						self.process_transaction_injections(local_entry, :update, :before_transaction, strong_params)
-
+						self.process_transaction_injections(local_data[:entry], :update, :before_transaction, strong_params)
 						transaction_is_ok = true
-
 						ActiveRecord::Base.transaction do
 							#raise "In Transaction Before Create"
-							unless self.process_transaction_injections(local_entry, :update, :before_save, strong_params)
+							unless self.process_transaction_injections(local_data[:entry], :update, :before_save, strong_params)
 								transaction_is_ok = false
 								raise ActiveRecord::Rollback
 							end
 
-							if local_entry.update(strong_params)
-								unless process_transaction_injections(local_entry, :update, :after_save, strong_params)
+							if local_data[:entry].update(strong_params)
+								unless process_transaction_injections(local_data[:entry], :update, :after_save, strong_params)
 									transaction_is_ok = false
 									raise ActiveRecord::Rollback
 								end
@@ -308,36 +513,104 @@ module KirguduBase
 								raise ActiveRecord::Rollback
 							end
 						end
-
-						self.process_transaction_injections(local_entry, :update, :after_transaction, strong_params)
+						self.process_transaction_injections(local_data[:entry], :update, :after_transaction, strong_params)
 
 
 						respond_to do |format|
-							flash[:success] = I18n.t("#{self.to_i18n}.messages.manufacturer_updated", entry_name: local_entry.to_s)
+							flash[:success] = I18n.t("#{self.to_i18n}.messages.manufacturer_updated", entry_name: local_data[:entry].to_s)
 							if transaction_is_ok
-								format.html { render_redirect url_for(action: :show, id: local_entry) }
+								format.html { render_redirect url_for(action: :show, id: local_data[:entry]) }
 								format.json { head :no_content }
 							else
 								# loading data for select-like controls
-								local_controls_data = self.load_data_for_entry_controls(local_page.forms[:changes], local_entry)
-								local_entry.errors[:form] << I18n.t("#{self.to_i18n}.messages.update_error")
-								format.html { render_html1 self.get_view_path_for_page_edit,
-								                           locals:
-									                           {
-										                           entry: local_entry,
-										                           page: local_page,
-										                           controls_data: local_controls_data
-									                           }
-								}
-								format.json { render json: local_entry.errors, status: :unprocessable_entity }
+								local_data[:controls_data] = self.load_data_for_entry_controls(local_data[:page].forms[:changes], local_data[:entry])
+								local_data[:entry].errors[:form] << I18n.t("#{self.to_i18n}.messages.update_error")
+
+
+								# building breadcrumbs
+								home_controller = self.class.get_method_latest_result(:get_kb_home_controller)
+								home_controller = eval(home_controller) if home_controller and home_controller.is_a?(String)
+								add_new_breadcrumb(I18n.t("#{home_controller.to_i18n}.index.title"), home_controller.to_url_for(:index)) if home_controller
+								parent_ids = {}
+								local_data[:parents].each do |parent|
+									# breadcrumbs: adding parent index
+									add_new_breadcrumb(I18n.t("#{parent[:controller].to_i18n}.index.title"), parent[:controller].to_url_for(:index, parent_ids))
+									# breadcrumbs: getting parent entry name
+									parent_entry_name = nil
+									parent_entry_name = parent[:entry].name_for_breadcrumbs if parent[:entry].respond_to?(:name_for_breadcrumbs)
+									parent_entry_name = parent[:entry].id unless parent_entry_name
+									# breadcrumbs: adding parent entry
+									add_new_breadcrumb(parent_entry_name, parent[:controller].to_url_for(:show, parent_ids.merge(id: parent[:entry].id)))
+									parent_ids[parent[:id_param]] = parent[:id_value]
+								end if local_data[:parents]
+								# breadcrumbs: adding current index
+								add_new_breadcrumb(I18n.t("#{self.to_i18n}.index.title"), self.to_url_for(:index, local_data[:parent_ids]))
+								# breadcrumbs: adding current entry
+								add_new_breadcrumb(local_data[:entry].id)
+
+
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :edit)}", locals: {data: local_data} }
+								format.json { render json: local_data[:entry].errors, status: :unprocessable_entity }
 							end
 						end
 					end
 				end
 
 				module DeleteActions
-					def delete
+					def destroy
+						unless self.class.respond_to?(:get_kb_page)
+							raise "Method :get_kb_page must be implemented for controller '#{self.class}'"
+						end
+
+						local_data = {
+							errors: [],
+							messages: [],
+							page: self.class.get_kb_page(:delete)
+						}
 
+						#unless local_data[:page]
+						#	respond_to do |format|
+						#		format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :page_404)}" }
+						#		format.json { render_json_page_404 }
+						#	end
+						#	return
+						#end
+
+
+						# fill parent for data
+						filters_for_parents = {}
+						self.fill_obligatory_filters(filters_for_parents)
+						self.fill_parents_for_local_data(local_data, filters_for_parents)
+						# filling filters for search
+						filters = {}
+						self.fill_obligatory_filters(filters)
+						filters.merge!(local_data[:parent_ids])
+						# retrieving entry from database
+						local_data[:entry] = self.entry_class.get_entry_by_id(params[:id], filters, {logger: string_logger})
+						# entry not found, showing not found page
+						unless local_data[:entry]
+							local_data[:errors] << I18n.t("#{self.to_i18n}.messages.not_found", entry_id: params[:id])
+							respond_to do |format|
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :entry_not_found)}", locals: {data: local_data} }
+								format.json { render_json_not_found message: local_data[:errors] }
+							end
+							return
+						end
+						# destroying entry
+						if local_data[:entry].destroy
+							# entry destroyed
+							respond_to do |format|
+								format.html { render_redirect(self.to_url_for(:index, local_data[:parent_ids])) }
+								format.json { render_json_ok(local_data[:entry], message: "Record Deleted") }
+							end
+						else
+							# failed to destroy entry
+							local_data[:errors] << I18n.t("#{self.to_i18n}.messages.delete_error")
+							respond_to do |format|
+								format.html { render_html1 self.get_view_path_for_page_edit, locals: {data: local_data} }
+								format.json { render_json_error(local_data[:entry], message: local_data[:errors]) }
+							end
+						end
 					end
 				end
 
@@ -347,14 +620,25 @@ module KirguduBase
 						raise "No defined \"entry_class\" method for controller #{self.class}" if !self.respond_to?(:entry_class) || self.entry_class.nil?
 						raise "Current User NULL" if @current_user.nil?
 
-						filters = {}.merge(params)
 						options = {
 							logger: string_logger
 						}
 
-						#logger.info "OPTIONS FOR SEARCH: #{options.to_s}"
+						local_data = {
+							errors: [],
+							messages: []
+						}
 
-						@entries_list = self.entry_class.get_entries(nil, filters, options)
+						# fill parent for data
+						filters_for_parents = {}
+						self.fill_obligatory_filters(filters_for_parents)
+						self.fill_parents_for_local_data(local_data, filters_for_parents)
+						# filling filters for search
+						filters = {}
+						self.fill_obligatory_filters(filters)
+						filters.merge!(local_data[:parent_ids])
+						# retrieving entries from database
+						local_data[:entries] = self.entry_class.get_entries(nil, filters, options)
 
 						export_type = params[:type]
 
@@ -376,12 +660,12 @@ module KirguduBase
 								when "json"
 
 								when "xml"
-									render text: @entries_list.to_xml
+									render text: local_data[:entries_list].to_xml
 							end
 						else
 							respond_to do |format|
-								format.json { render json: @entries_list }
-								format.json { render xml: @entries_list }
+								format.json { render json: local_data[:entries] }
+								format.json { render xml: local_data[:entries] }
 							end
 						end
 					end
@@ -395,8 +679,528 @@ module KirguduBase
 					end
 				end
 
+
+				module ItemsManagementActions
+
+					def manage_items
+
+						unless self.class.respond_to?(:get_kb_page)
+							raise "Method :get_kb_page must be implemented for controller '#{self.class}'"
+						end
+
+						local_data = {
+							errors: [],
+							messages: [],
+							page: self.class.get_kb_page(:management)
+						}
+
+						options = {
+							logger: string_logger
+						}
+
+						unless local_data[:page]
+							respond_to do |format|
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :page_404)}" }
+								format.json { render_json_page_404 }
+							end
+							return
+						end
+
+						# getting management settings
+						local_data[:management_settings] = local_data[:page].managements[:manage] if local_data[:page].managements
+
+						unless local_data[:management_settings]
+							respond_to do |format|
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :page_404)}" }
+								format.json { render_json_page_404 }
+							end
+							return
+						end
+
+						#raise "MANAGEMENT: management settings error" unless local_data[:management_settings]
+
+						local_container_class = local_data[:management_settings].container_class
+						local_container_id_property = local_data[:management_settings].container_id_property
+						local_item_class = local_data[:management_settings].item_class
+						local_entry_id_property = local_data[:management_settings].entry_id_property
+						local_entry_class = local_data[:management_settings].entry_class
+
+
+						# fill parent for data
+						filters_for_parents = {}
+						self.fill_obligatory_filters(filters_for_parents)
+						self.fill_parents_for_local_data(local_data, filters_for_parents)
+
+
+						#loading container data
+						filters_4_container = {}
+						self.fill_obligatory_filters(filters_4_container)
+						filters_4_container.merge!(local_data[:parent_ids])
+						# retrieving container from database
+						local_data[:container] = local_container_class.get_entry_by_id(params[local_container_id_property], filters_4_container, options)
+						# filling filters for items
+						filters_4_items = {}
+						self.fill_obligatory_filters(filters_4_items)
+						filters_4_items.merge!(local_data[:parent_ids])
+						filters_4_items[local_container_id_property] = params[local_container_id_property]
+						# retrieving items from database
+						local_data[:items] = local_item_class.get_entries(nil, filters_4_items, options)
+
+						#entries_order_by = get_managing_entries_order_by if self.respond_to?(:get_managing_entries_order_by)
+						#entries_order_by = "name asc" unless entries_order_by
+
+						# filling filters for entries
+						filters_4_entries = {}
+						self.fill_obligatory_filters(filters_4_entries)
+						filters_4_entries[local_entry_id_property] = params[local_entry_id_property]
+						# retrieving entries from database
+						local_entries_initial_query = local_entry_class.where { -(id.in local_item_class.get_entries(nil, filters_4_items, options).select(local_entry_id_property)) }
+
+						#fill parent elements
+						filters_for_parents = {}
+						self.fill_obligatory_filters(filters_for_parents)
+						self.fill_parents_for_local_data(local_data, filters_for_parents)
+
+						local_entries = local_entry_class.get_entries(local_entries_initial_query, filters_4_entries, options)
+						local_data[:entries] = local_entries
+
+
+						# building breadcrumbs
+						home_controller = self.class.get_method_latest_result(:get_kb_home_controller)
+						home_controller = eval(home_controller) if home_controller and home_controller.is_a?(String)
+						add_new_breadcrumb(I18n.t("#{home_controller.to_i18n}.index.title"), home_controller.to_url_for(:index)) if home_controller
+						parent_ids = {}
+						local_data[:parents].each do |parent|
+							# breadcrumbs: adding parent index
+							add_new_breadcrumb(I18n.t("#{parent[:controller].to_i18n}.index.title"), parent[:controller].to_url_for(:index, parent_ids))
+							# breadcrumbs: getting parent entry name
+							parent_entry_name = nil
+							parent_entry_name = parent[:entry].name_for_breadcrumbs if parent[:entry].respond_to?(:name_for_breadcrumbs)
+							parent_entry_name = parent[:entry].id unless parent_entry_name
+							# breadcrumbs: adding parent entry
+							add_new_breadcrumb(parent_entry_name, parent[:controller].to_url_for(:show, parent_ids.merge(id: parent[:entry].id)))
+							parent_ids[parent[:id_param]] = parent[:id_value]
+						end if local_data[:parents]
+						# breadcrumbs: adding current index
+						add_new_breadcrumb(I18n.t("#{self.to_i18n}.index.title"), self.to_url_for(:index, local_data[:parent_ids]))
+						add_new_breadcrumb(I18n.t("#{self.to_i18n}.management.title"))
+
+
+						respond_to do |format|
+							format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :management)}", locals: {data: local_data} }
+							format.json { render json: local_data }
+						end
+					end
+
+					def manage_items_add
+
+						unless self.class.respond_to?(:get_kb_page)
+							raise "Method :get_kb_page must be implemented for controller '#{self.class}'"
+						end
+
+						local_data = {
+							errors: [],
+							messages: [],
+							page: self.class.get_kb_page(:management)
+						}
+
+						options = {
+							logger: string_logger
+						}
+
+						unless local_data[:page]
+							respond_to do |format|
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :page_404)}" }
+								format.json { render_json_page_404 }
+							end
+							return
+						end
+
+						# getting management settings
+						local_data[:management_settings] = local_data[:page].managements[:manage] if local_data[:page].managements
+
+						unless local_data[:management_settings]
+							respond_to do |format|
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :page_404)}" }
+								format.json { render_json_page_404 }
+							end
+							return
+						end
+
+
+						local_container_class = local_data[:management_settings].container_class
+						local_container_id_property = local_data[:management_settings].container_id_property
+						local_item_class = local_data[:management_settings].item_class
+						local_entry_id_property = local_data[:management_settings].entry_id_property
+						local_entry_class = local_data[:management_settings].entry_class
+
+
+						# fill parent for data
+						filters_for_parents = {}
+						self.fill_obligatory_filters(filters_for_parents)
+						self.fill_parents_for_local_data(local_data, filters_for_parents)
+
+
+						#loading container from database
+						filters_4_container = {}
+						self.fill_obligatory_filters(filters_4_container)
+						local_data[:container] = local_container_class.get_entry_by_id(params[local_container_id_property], filters_4_container, options)
+						#checking if container not found
+						unless local_data[:container]
+							render json: {status: ::ChupakabraTools::SetManagementResult.id_by_tag('set_not_found'), message: I18n.t("#{self.to_i18n}.management.messages.set_not_found", id: params[local_container_id_property])}
+							return
+						end
+
+
+						#loading entry from database
+						filters_4_entries = {}
+						self.fill_obligatory_filters(filters_4_entries)
+						#local_data[:entry] = local_entry_class.get_entry_by_id(params[local_entry_id_property], filters_4_entries, options )
+						local_data[:entry] = local_entry_class.get_entry_by_id(params[:entry_id], filters_4_entries, options)
+
+						#checking if entry not found
+						unless local_data[:entry]
+							render json: {status: ::ChupakabraTools::SetManagementResult.id_by_tag('entry_not_found'), message: I18n.t("#{self.to_i18n}.management.messages.entry_not_found", entry_id: params[:entry_id])}
+							return
+						end
+
+						#raise "MANAGEMENT: entry is ok"
+
+						# loading item from database
+						filters_4_item = {}
+						self.fill_obligatory_filters(filters_4_item)
+						filters_4_item[local_container_id_property] = params[local_container_id_property]
+						#filters_4_item[local_entry_id_property] = params[local_entry_id_property]
+						filters_4_item[local_entry_id_property] = params[:entry_id]
+
+						logger.info("MANAGEMENT ADD: Retrieve Item from database filters - #{filters_4_item.to_json}")
+
+						local_data[:item] = local_item_class.get_entries(nil, filters_4_item, options).first
+
+						unless local_data[:item]
+							local_data[:item] = local_item_class.new
+							local_data[:item][local_container_id_property] = local_data[:container].id
+							local_data[:item][local_entry_id_property] = local_data[:entry].id
+
+							if local_data[:item].respond_to?(:sort_position)
+								filters_4_items_max = {}
+								self.fill_obligatory_filters(filters_4_items_max)
+								filters_4_items_max[local_container_id_property] = params[local_container_id_property]
+
+								max_sort_position = local_item_class.get_entries(nil, filters_4_items_max, options).maximum(:sort_position)
+								local_data[:item].sort_position = max_sort_position ? max_sort_position + 1 : 1
+							end
+
+							# saving entry using transactions
+							self.process_transaction_injections(local_data[:item], :create, :before_transaction, nil)
+							transaction_is_ok = true
+							ActiveRecord::Base.transaction do
+								#raise "In Transaction Before Create"
+								unless self.process_transaction_injections(local_data[:item], :create, :before_save, nil)
+									transaction_is_ok = false
+									raise ActiveRecord::Rollback
+								end
+
+								if local_data[:item].save
+									unless self.process_transaction_injections(local_data[:item], :create, :after_save, nil)
+										transaction_is_ok = false
+										raise ActiveRecord::Rollback
+									end
+								else
+									transaction_is_ok = false
+									raise ActiveRecord::Rollback
+								end
+							end
+							self.process_transaction_injections(local_data[:item], :create, :after_transaction, nil)
+
+							# rendering page
+							if transaction_is_ok
+								render json: {status: ::ChupakabraTools::SetManagementResult.id_by_tag('management_ok'), message: I18n.t("#{self.to_i18n}.management.messages.add_management_ok")}
+							else
+								render json: {status: ::ChupakabraTools::SetManagementResult.id_by_tag('management_error'), message: I18n.t("#{self.to_i18n}.management.messages.add_management_error")}
+							end
+						else
+							render json: {status: ::ChupakabraTools::SetManagementResult.id_by_tag('entry_already_in_set'), message: I18n.t("#{self.to_i18n}.management.messages.entry_already_in_set")}
+						end
+					end
+
+					def manage_items_remove
+
+						unless self.class.respond_to?(:get_kb_page)
+							raise "Method :get_kb_page must be implemented for controller '#{self.class}'"
+						end
+
+						local_data = {
+							errors: [],
+							messages: [],
+							page: self.class.get_kb_page(:management)
+						}
+
+						options = {
+							logger: string_logger
+						}
+
+						unless local_data[:page]
+							respond_to do |format|
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :page_404)}" }
+								format.json { render_json_page_404 }
+							end
+							return
+						end
+
+						# getting management settings
+						local_data[:management_settings] = local_data[:page].managements[:manage] if local_data[:page].managements
+
+						unless local_data[:management_settings]
+							respond_to do |format|
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :page_404)}" }
+								format.json { render_json_page_404 }
+							end
+							return
+						end
+
+
+						local_container_class = local_data[:management_settings].container_class
+						local_container_id_property = local_data[:management_settings].container_id_property
+						local_item_class = local_data[:management_settings].item_class
+						local_entry_id_property = local_data[:management_settings].entry_id_property
+						local_entry_class = local_data[:management_settings].entry_class
+
+
+						# fill parent for data
+						filters_for_parents = {}
+						self.fill_obligatory_filters(filters_for_parents)
+						self.fill_parents_for_local_data(local_data, filters_for_parents)
+
+						#loading container from database
+						filters_4_container = {}
+						self.fill_obligatory_filters(filters_4_container)
+						local_data[:container] = local_container_class.get_entry_by_id(params[local_container_id_property], filters_4_container, options)
+						#checking if container not found
+						unless local_data[:container]
+							render json: {status: ::ChupakabraTools::SetManagementResult.id_by_tag('set_not_found'), message: I18n.t("#{self.to_i18n}.management.messages.set_not_found", id: params[local_container_id_property])}
+							return
+						end
+
+
+						# loading item from database
+						filters_4_item = {}
+						self.fill_obligatory_filters(filters_4_item)
+						filters_4_item[local_container_id_property] = params[local_container_id_property]
+						filters_4_item[local_entry_id_property] = params[:entry_id]
+
+						local_data[:item] = local_item_class.get_entries(nil, filters_4_item, options).first
+
+
+						unless local_data[:item]
+							render json: {status: ::ChupakabraTools::SetManagementResult.id_by_tag('item_not_found'), message: I18n.t("#{self.to_i18n}.management.messages.item_not_found", entry_id: params[:entry_id])}
+							return
+						end
+
+						if local_data[:item].destroy
+							render json: {status: ::ChupakabraTools::SetManagementResult.id_by_tag('management_ok'), message: I18n.t("#{self.to_i18n}.management.messages.remove_management_ok")}
+						else
+							render json: {status: ::ChupakabraTools::SetManagementResult.id_by_tag('management_error'), message: I18n.t("#{self.to_i18n}.management.messages.remove_management_error")}
+						end
+					end
+
+
+					def sort_items
+
+						unless self.class.respond_to?(:get_kb_page)
+							raise "Method :get_kb_page must be implemented for controller '#{self.class}'"
+						end
+
+						local_data = {
+							errors: [],
+							messages: [],
+							page: self.class.get_kb_page(:sorting)
+						}
+
+						options = {
+							logger: string_logger
+						}
+
+						unless local_data[:page]
+							respond_to do |format|
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :page_404)}" }
+								format.json { render_json_page_404 }
+							end
+							return
+						end
+
+						# getting sorting settings
+						local_data[:sorting_settings] = local_data[:page].sortings[:sort] if local_data[:page].sortings
+
+						unless local_data[:sorting_settings]
+							respond_to do |format|
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :page_404)}" }
+								format.json { render_json_page_404 }
+							end
+							return
+						end
+
+						#raise "SORTING: sorting settings error" unless local_data[:sorting_settings]
+
+						local_container_class = local_data[:sorting_settings].container_class
+						local_container_id_property = local_data[:sorting_settings].container_id_property
+						local_item_class = local_data[:sorting_settings].item_class
+						local_entry_id_property = local_data[:sorting_settings].entry_id_property
+						local_entry_class = local_data[:sorting_settings].entry_class
+
+
+						# fill parent for data
+						filters_for_parents = {}
+						self.fill_obligatory_filters(filters_for_parents)
+						self.fill_parents_for_local_data(local_data, filters_for_parents)
+
+
+						#loading container data
+						filters_4_container = {}
+						self.fill_obligatory_filters(filters_4_container)
+						filters_4_container.merge!(local_data[:parent_ids])
+						# retrieving container from database
+						local_data[:container] = local_container_class.get_entry_by_id(params[local_container_id_property], filters_4_container, options)
+						# filling filters for items
+						filters_4_items = {}
+						self.fill_obligatory_filters(filters_4_items)
+						filters_4_items.merge!(local_data[:parent_ids])
+						filters_4_items[local_container_id_property] = params[local_container_id_property]
+						filters_4_items[:order] = ::Core::Store::CollectionProduct.for_sql_order_by(:sort_position, :asc)
+						# retrieving items from database
+						local_data[:items] = local_item_class.get_entries(nil, filters_4_items, options)
+
+
+						# building breadcrumbs
+						home_controller = self.class.get_method_latest_result(:get_kb_home_controller)
+						home_controller = eval(home_controller) if home_controller and home_controller.is_a?(String)
+						add_new_breadcrumb(I18n.t("#{home_controller.to_i18n}.index.title"), home_controller.to_url_for(:index)) if home_controller
+						parent_ids = {}
+						local_data[:parents].each do |parent|
+							# breadcrumbs: adding parent index
+							add_new_breadcrumb(I18n.t("#{parent[:controller].to_i18n}.index.title"), parent[:controller].to_url_for(:index, parent_ids))
+							# breadcrumbs: getting parent entry name
+							parent_entry_name = nil
+							parent_entry_name = parent[:entry].name_for_breadcrumbs if parent[:entry].respond_to?(:name_for_breadcrumbs)
+							parent_entry_name = parent[:entry].id unless parent_entry_name
+							# breadcrumbs: adding parent entry
+							add_new_breadcrumb(parent_entry_name, parent[:controller].to_url_for(:show, parent_ids.merge(id: parent[:entry].id)))
+							parent_ids[parent[:id_param]] = parent[:id_value]
+						end if local_data[:parents]
+						# breadcrumbs: adding current index
+						add_new_breadcrumb(I18n.t("#{self.to_i18n}.index.title"), self.to_url_for(:index, local_data[:parent_ids]))
+						add_new_breadcrumb(I18n.t("#{self.to_i18n}.sorting.title"))
+
+
+						respond_to do |format|
+							format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :sorting)}", locals: {data: local_data} }
+							format.json { render_json_ok local_data }
+						end
+
+					end
+
+					def sort_items_process
+
+
+						unless self.class.respond_to?(:get_kb_page)
+							raise "Method :get_kb_page must be implemented for controller '#{self.class}'"
+						end
+
+						local_data = {
+							errors: [],
+							messages: [],
+							page: self.class.get_kb_page(:sorting)
+						}
+
+						options = {
+							logger: string_logger
+						}
+
+						unless local_data[:page]
+							respond_to do |format|
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :page_404)}" }
+								format.json { render_json_page_404 }
+							end
+							return
+						end
+
+						# getting sorting settings
+						local_data[:sorting_settings] = local_data[:page].sortings[:sort] if local_data[:page].sortings
+
+						unless local_data[:sorting_settings]
+							respond_to do |format|
+								format.html { render_html1 "#{self.class.get_method_latest_result(:get_kb_template)}#{self.class.get_method_latest_result(:get_kb_view_path, :page_404)}" }
+								format.json { render_json_page_404 }
+							end
+							return
+						end
+
+						#raise "SORTING: sorting settings error" unless local_data[:sorting_settings]
+
+						local_container_class = local_data[:sorting_settings].container_class
+						local_container_id_property = local_data[:sorting_settings].container_id_property
+						local_item_class = local_data[:sorting_settings].item_class
+						local_entry_id_property = local_data[:sorting_settings].entry_id_property
+						local_entry_class = local_data[:sorting_settings].entry_class
+
+
+						# fill parent for data
+						filters_for_parents = {}
+						self.fill_obligatory_filters(filters_for_parents)
+						self.fill_parents_for_local_data(local_data, filters_for_parents)
+
+						#loading container from database
+						filters_4_container = {}
+						self.fill_obligatory_filters(filters_4_container)
+						local_data[:container] = local_container_class.get_entry_by_id(params[local_container_id_property], filters_4_container, options)
+						#checking if container not found
+						unless local_data[:container]
+							render json: {status: ::ChupakabraTools::SetManagementResult.id_by_tag('set_not_found'), message: I18n.t("#{self.to_i18n}.management.messages.set_not_found", id: params[local_container_id_property])}
+							return
+						end
+
+
+						# loading items from database one by one and processing them
+						# filters_4_item = {}
+						# self.fill_obligatory_filters(filters_4_item)
+						# filters_4_item[local_container_id_property] = params[local_container_id_property]
+
+
+						filters_4_item = {}
+						self.fill_obligatory_filters(filters_4_item)
+						filters_4_item[local_container_id_property] = params[local_container_id_property]
+						#filters_4_item[local_entry_id_property] = id
+
+
+						result_is_ok = false
+						if params[:items]
+							begin
+								ActiveRecord::Base.transaction do
+									params[:items].each_with_index do |id, index|
+										logger.info("ITEMID: #{id}")
+
+										logger.info "ITEM FILTERS: #{filters_4_item.to_json}"
+										item = local_item_class.get_entry_by_id(id, filters_4_item, options)
+										if item
+											item.sort_position = index + 1
+											item.save
+										end
+									end
+									result_is_ok = true
+								end
+							end
+						end
+						if result_is_ok == true
+							render json: {status: ::ChupakabraTools::SetManagementResult.id_by_tag('management_ok'), message: I18n.t("#{self.to_i18n}.sorting.messages.management_ok")}
+						else
+							render json: {status: ::ChupakabraTools::SetManagementResult.id_by_tag('management_error'), message: I18n.t("#{self.to_i18n}.sorting.messages.management_error")}
+						end
+					end
+
+				end
 			end
 
+
 			################################################################################################################
 			#########################################       Ajax Modules     ###############################################
 			################################################################################################################
@@ -410,23 +1214,25 @@ module KirguduBase
 							return
 						end
 
-						local_page = self.class.get_kb_page(:update)
+						local_data = {}
+						local_data[:page] = self.class.get_kb_page(:update)
+
 
-						unless local_page
+						unless local_data[:page]
 							render text: '<span style = "color: red;"><b>ERROR OCCURRED!!!</b></span>'
 							return
 						end
 
 
-						local_entry = self.entry_class.get_entry_by_id(params[:id], nil, {logger: string_logger})
-						if local_entry
+						local_data[:entry] = self.entry_class.get_entry_by_id(params[:id], nil, {logger: string_logger})
+						if local_data[:entry]
 							result_string = ''
 							begin
-								unless local_entry[params[:field_name]] == params[:value]
-									local_entry[params[:field_name]] = params[:value]
-									local_entry.updated_at = Time.now
-									local_entry.updater = @current_user
-									unless local_entry.save
+								unless local_data[:entry][params[:field_name]] == params[:value]
+									local_data[:entry][params[:field_name]] = params[:value]
+									local_data[:entry].updated_at = Time.now
+									local_data[:entry].updater = @current_user
+									unless local_data[:entry].save
 										result_string = '<span style = "color: red;"><b>FAILED TO SAVE!!!</b></span>'
 									end
 								end
@@ -435,7 +1241,7 @@ module KirguduBase
 							end
 							if result_string.blank?
 								begin
-									result_string = local_entry.send(params[:field_name])
+									result_string = local_data[:entry].send(params[:field_name])
 								rescue
 									result_string = '<span style = "color: red;"><b>ERROR OCCURRED!!!</b></span>'
 								end