# -*- encoding : utf-8 -*-

module KirguduBase
	module Controllers
		module BasicActions
			################################################################################################################
			#########################################       Base and Ajax Modules     ######################################
			################################################################################################################

			module Base
				module IndexActions


					def index
						#raise self.entry_class
						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?

						raise "Method :get_kb_page must be implemented for controller '#{self.class}'" unless self.class.respond_to?(:get_kb_page)

						options = {
							logger: string_logger
						}

						local_data = {
							errors: [],
							messages: [],
							page: self.class.get_kb_page(:index)
						}

						# Rendering 'Page not Found' and completing Request
						self.def render_page_404 and return unless local_data[:page]

						# fill parent for data
						filters_for_parents = {}
						self.fill_obligatory_db_query_params(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_db_query_params(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
						self.kb_dp_breadcrumbs_build_for_index(local_data, true) #index page

						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.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 DashboardActions

					def dashboard
						#raise self.entry_class
						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?

						unless self.class.respond_to?(:get_kb_page)
							raise "Method :get_kb_page must be implemented for controller '#{self.class}'"
						end

						options = {
							logger: string_logger
						}

						local_data = {
							errors: [],
							messages: [],
							page: self.class.get_kb_page(:dashboard)
						}

						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_db_query_params(filters_for_parents)
						self.fill_parents_for_local_data(local_data, filters_for_parents)


						# 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
						self.kb_dp_breadcrumbs_build_for_index(local_data, true) #index page


						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.class.get_method_latest_result(:get_kb_template)}/#{self.class.get_method_latest_result(:get_kb_view_path, :dashboard)}", locals: {data: local_data} }
							format.json { render_json_ok(nil) }
						end
					end
				end


				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

						options = {
							logger: self.string_logger
						}


						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.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_db_query_params(filters_for_parents)
						self.fill_parents_for_local_data(local_data, filters_for_parents)
						# fill filters for search
						filters = {}
						self.fill_obligatory_db_query_params(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_db_query_params(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

								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

								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
						end if local_data[:page].lists


						# fill parent for data
						filters_for_parents = {}
						self.fill_obligatory_db_query_params(filters_for_parents)
						self.fill_parents_for_local_data(local_data, filters_for_parents)

						# building breadcrumbs
						self.kb_dp_breadcrumbs_build_for_index(local_data, false) #not index page

						# rendering 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, :show)}", locals: {data: local_data} }
							format.json { render_json_ok local_data[:entry] }
						end
					end

				end

				module NewActions

					def new
						unless self.class.respond_to?(:get_kb_page)
							raise "Method :get_kb_page must be implemented for controller '#{self.class}'"
						end

						local_data = {
							messages: [],
							errors: [],
							page: self.class.get_kb_page(:new)
						}

						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

						filters = {}
						self.fill_obligatory_db_query_params(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_db_query_params(filters_for_parents)
						self.fill_parents_for_local_data(local_data, filters_for_parents)

						# building breadcrumbs
						self.kb_dp_breadcrumbs_build_for_index(local_data, false) #not index page

						# rendering 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, :new)}", locals: {data: local_data} }
							format.json { render_json_ok local_data[:entry] }
						end
					end


					def create
						unless self.class.respond_to?(:get_kb_page)
							raise "Method :get_kb_page must be implemented for controller '#{self.class}'"
						end

						local_data = {
							messages: [],
							errors: [],
							page: self.class.get_kb_page(:new)
						}

						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_db_query_params(filters_for_parents)
						self.fill_parents_for_local_data(local_data, filters_for_parents)


						strong_params = {}.merge(self.class_strong_params(local_data[:page].forms[:changes]))
						self.fill_obligatory_db_query_params(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_data[:entry], :create, :before_save, strong_params)
								transaction_is_ok = false
								raise ActiveRecord::Rollback
							end

							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
							else
								transaction_is_ok = false
								raise ActiveRecord::Rollback
							end
						end

						self.process_transaction_injections(local_data[:entry], :create, :after_transaction, strong_params)

						respond_to do |format|
							if transaction_is_ok
								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_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
								self.kb_dp_breadcrumbs_build_for_index(local_data, false) #not index page

								# 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

				end

				module EditActions

					def edit

						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(:edit)
						}

						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_db_query_params(filters_for_parents)
						self.fill_parents_for_local_data(local_data, filters_for_parents)
						# filling filters for search
						filters = {}
						self.fill_obligatory_db_query_params(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
						# 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_db_query_params(filters_for_parents)
						self.fill_parents_for_local_data(local_data, filters_for_parents)
						# building breadcrumbs

						self.kb_dp_breadcrumbs_build_for_index(local_data, false) #not index page

						# rendering 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, :edit)}", locals: {data: local_data} }
							format.json { render_json_ok local_data[:entry] }
						end
					end


					def update

						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(:edit)
						}

						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_db_query_params(filters_for_parents)
						self.fill_parents_for_local_data(local_data, filters_for_parents)
						# filling filters for search
						filters = {}
						self.fill_obligatory_db_query_params(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|
								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 string params from params
						strong_params = {}.merge(self.class_strong_params(local_data[:page].forms[:changes]))
						self.fill_obligatory_db_query_params(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_data[:entry], :update, :before_save, strong_params)
								transaction_is_ok = false
								raise ActiveRecord::Rollback
							end

							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
							else
								transaction_is_ok = false
								raise ActiveRecord::Rollback
							end
						end
						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_data[:entry].to_s)
							if transaction_is_ok
								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_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
								self.kb_dp_breadcrumbs_build_for_index(local_data, false) #not index page


								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 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_db_query_params(filters_for_parents)
						self.fill_parents_for_local_data(local_data, filters_for_parents)
						# filling filters for search
						filters = {}
						self.fill_obligatory_db_query_params(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

				module ExportActions

					def export
						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?

						options = {
							logger: string_logger
						}

						local_data = {
							errors: [],
							messages: []
						}

						# fill parent for data
						filters_for_parents = {}
						self.fill_obligatory_db_query_params(filters_for_parents)
						self.fill_parents_for_local_data(local_data, filters_for_parents)
						# filling filters for search
						filters = {}
						self.fill_obligatory_db_query_params(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]

						unless export_type

						end

						export_options = {}

						self.entry_class.export_types_set.each do |exp|
							if exp[:name] == export_type
								#export_options[:include] =
								#render text: @entries_list.to_json
							end
						end

						if params[:type]
							case params[:type]
								when "json"

								when "xml"
									render text: local_data[:entries_list].to_xml
							end
						else
							respond_to do |format|
								format.json { render json: local_data[:entries] }
								format.json { render xml: local_data[:entries] }
							end
						end
					end
				end


				module ImportActions
					def import
						import_type = params[:type]

					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_db_query_params(filters_for_parents)
						self.fill_parents_for_local_data(local_data, filters_for_parents)


						#loading container data
						filters_4_container = {}
						self.fill_obligatory_db_query_params(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_db_query_params(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_db_query_params(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_db_query_params(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
						self.kb_dp_breadcrumbs_build_for_index(local_data, false) #not index 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, :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_db_query_params(filters_for_parents)
						self.fill_parents_for_local_data(local_data, filters_for_parents)


						#loading container from database
						filters_4_container = {}
						self.fill_obligatory_db_query_params(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::ApiStatus.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_db_query_params(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::ApiStatus.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_db_query_params(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_db_query_params(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::ApiStatus.id_by_tag('ok'), message: I18n.t("#{self.to_i18n}.management.messages.add_management_ok")}
							else
								render json: {status: ::ChupakabraTools::ApiStatus.id_by_tag('error'), message: I18n.t("#{self.to_i18n}.management.messages.add_management_error")}
							end
						else
							render json: {status: ::ChupakabraTools::ApiStatus.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_db_query_params(filters_for_parents)
						self.fill_parents_for_local_data(local_data, filters_for_parents)

						#loading container from database
						filters_4_container = {}
						self.fill_obligatory_db_query_params(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::ApiStatus.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_db_query_params(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::ApiStatus.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::ApiStatus.id_by_tag('ok'), message: I18n.t("#{self.to_i18n}.management.messages.remove_management_ok")}
						else
							render json: {status: ::ChupakabraTools::ApiStatus.id_by_tag('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_db_query_params(filters_for_parents)
						self.fill_parents_for_local_data(local_data, filters_for_parents)


						#loading container data
						filters_4_container = {}
						self.fill_obligatory_db_query_params(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_db_query_params(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
						self.kb_dp_breadcrumbs_build_for_index(local_data, false) #not index 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, :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_db_query_params(filters_for_parents)
						self.fill_parents_for_local_data(local_data, filters_for_parents)

						#loading container from database
						filters_4_container = {}
						self.fill_obligatory_db_query_params(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::ApiStatus.id_by_tag('set_not_found'), message: I18n.t("#{self.to_i18n}.sorting.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_db_query_params(filters_4_item)
						# filters_4_item[local_container_id_property] = params[local_container_id_property]


						filters_4_item = {}
						self.fill_obligatory_db_query_params(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::ApiStatus.id_by_tag('ok'), message: I18n.t("#{self.to_i18n}.sorting.messages.sorting_ok")}
						else
							render json: {status: ::ChupakabraTools::ApiStatus.id_by_tag('error'), message: I18n.t("#{self.to_i18n}.sorting.messages.sorting_error")}
						end
					end

				end
			end


			module Common
				def kb_dp_render_page_404
					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.html { render_html1 self.get_view_path(:page_404), layout: self.get_view_path(:layout) }
						format.json { render_json_page_404 }
					end
				end


				def kb_dp_breadcrumbs_build_for_index(local_data, is_index_page)
					# getting home controller
					local_home_path = self.class.get_method_latest_result(:get_kb_home_path)

					if is_index_page
						if local_home_path
							if self.class == local_home_path
								add_new_breadcrumb(I18n.t("#{local_home_path.to_i18n}.index.title"))
							else
								add_new_breadcrumb(I18n.t("#{local_home_path.to_i18n}.index.title"), local_home_path.to_url_for(:index))
							end
						end
					else
						add_new_breadcrumb(I18n.t("#{local_home_path.to_i18n}.index.title"), local_home_path.to_url_for(:index))
					end if local_home_path

					# building breadcrumbs for parents
					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]))

					unless is_index_page
						# breadcrumbs: getting entry name
						entry_name = nil
						entry_name = local_data[:entry].name_for_breadcrumbs if local_data[:entry].respond_to?(:name_for_breadcrumbs)
						#entry_name.trim(20) if entry_name && entry_name.length > 20
						# breadcrumbs: adding current entry
						page_name = local_data[:page].name
						if page_name == :edit
							add_new_breadcrumb(local_data[:entry].id)
						elsif page_name == :show || page_name == :delete
							add_new_breadcrumb(entry_name || local_data[:entry].id)
						elsif page_name == :new
							add_new_breadcrumb(I18n.t("#{self.to_i18n}.new.title"))
						elsif page_name == :management
							add_new_breadcrumb(I18n.t("#{self.to_i18n}.management.title"))
						elsif page_name == :sorting
							add_new_breadcrumb(I18n.t("#{self.to_i18n}.sorting.title"))
						end
					end
				end


				################################################################################################################
				#########################################       Ajax Modules     ###############################################
				################################################################################################################

				module Ajax
					module InplaceEditActions
						def edit_inplace

							unless self.class.respond_to?(:get_kb_page)
								render text: '<span style = "color: red;"><b>ERROR OCCURRED!!!</b></span>'
								return
							end

							local_data = {}
							local_data[:page] = self.class.get_kb_page(:update)


							unless local_data[:page]
								render text: '<span style = "color: red;"><b>ERROR OCCURRED!!!</b></span>'
								return
							end


							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_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
								rescue
									result_string = '<span style = "color: red;"><b>ERROR OCCURRED!!!</b></span>'
								end
								if result_string.blank?
									begin
										result_string = local_data[:entry].send(params[:field_name])
									rescue
										result_string = '<span style = "color: red;"><b>ERROR OCCURRED!!!</b></span>'
									end
								end

								render text: result_string
							else
								render text: '<span style = "color: red;"><b>NOT FOUND!!!</b></span>'
							end
						end

					end
				end
			end
		end
	end
end