kirgudu_base 0.0.21 → 0.0.22

data/app/controllers/kirgudu_base/cabinet_controller.rb

@@ -25,44 +25,6 @@ module KirguduBase
 			@current_portal
 		end
 
-
-		include GuiHelper
-
-		#before_action :update_url_with_ajax_referer_url
-
-		# def create_breadcrumbs
-		#
-		# 	if @current_user.user_at_portals.count > 1
-		# 	add_new_breadcrumb I18n.t("select_portal.index.title"), url_for(controller: ::ErpZone::SelectPortalController.to_route_path, action: :index)
-		# 	end
-		#
-		# 	add_new_breadcrumb @current_portal.name, url_for(controller: ::AdminZone::DashboarController.to_route_path) if @current_portal
-		#
-		#
-		# 	if self.class.to_s == ::AdminZone::DashboardController
-		# 		add_new_breadcrumb(I18n.t("#{self.to_i18n}.index.title"))
-		# 		return
-		# 	end
-		#
-		# 	if self.action_name == "index"
-		# 		add_new_breadcrumb(I18n.t("#{self.to_i18n}.index.title"))
-		# 	else
-		# 		add_new_breadcrumb(
-		# 			I18n.t("#{self.to_i18n}.index.title"),
-		# 			url_for(controller: ::ChupakabraTools::ClassHelper.controller_underscore(self), action: "index", id: @container))
-		#
-		# 		if ['new', 'create'].include?(self.action_name)
-		# 			add_new_breadcrumb(I18n.t("#{self.to_i18n}.new.title"))
-		# 		elsif ['edit', 'update', 'show'].include?(self.action_name)
-		# 			entry = self.current_entry
-		#
-		# 			if entry && entry.respond_to?(:name_for_breadcrumbs)
-		# 				add_new_breadcrumb(entry.name_for_breadcrumbs)
-		# 			end
-		# 		end
-		# 	end
-		# end
-
 		protected
 
 		rescue_from ActiveRecord::RecordNotFound do
@@ -76,12 +38,12 @@ module KirguduBase
 		private
 
 		def before_entry_create(entry, filter_params, options)
-			entry.creator = @current_user
-			entry.updater = @current_user
+			entry.creator = self.current_user
+			entry.updater = self.current_user
 		end
 
 		def before_entry_update(entry, filter_params, options)
-			entry.updater = @current_user
+			entry.updater = self.current_user
 		end
 	end
 end

data/app/controllers/kirgudu_base/dynamic_pages_controller.rb

@@ -0,0 +1,1209 @@
+module KirguduBase
+	class DynamicPagesController < ::KirguduBase::ApplicationController
+
+		########################################################################################
+		#########################      Before&After Actions      ###############################
+		########################################################################################
+
+		before_action :kb_dp_init_controller_action
+
+
+		########################################################################################
+		########################      Transaction Injections      ##############################
+		########################################################################################
+
+		kb_transaction_injection do
+			method :before_entry_create
+			action :create
+			flow_position :before_save
+		end
+
+		kb_transaction_injection do
+			method :before_entry_update
+			action :update
+			flow_position :before_save
+		end
+
+
+		########################################################################################
+		################################      Actions     ######################################
+		########################################################################################
+
+
+		def index
+			# 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)
+
+
+			db_query_params = self.get_filters_for_list(@local_data[:page].lists[:entries_list], params)
+			self.fill_obligatory_db_query_params(db_query_params)
+			db_query_params.merge!(@local_data[:parent_ids])
+
+			db_query_params[:per_page] = 30 unless db_query_params[:per_page]
+			db_query_params[:per_page] ||= 30
+
+			# retrieving db_query_params 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, db_query_params, @options)
+
+			# filling db_query_params 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])
+
+			#raise "DP INDEX - PARENT IDS: #{@local_data[:parent_ids].to_json}"
+			#raise "DP INDEX - FILTERS FOR CURRENT URL: #{filters_for_current_url.to_json}"
+
+			@local_data[:current_url] = self.to_url_for(:index, filters_for_current_url)
+
+			#raise "DEBUG: INDEX - BEFORE BREADCRUMBS"
+			# building breadcrumbs
+			self.kb_dp_breadcrumbs_build(@local_data, true) #index page
+
+			#raise "DEBUG: INDEX - AFTER BREADCRUMBS"
+
+			# 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
+
+			#raise "DEBUG: INDEX - BEFORE VIEW RENDER
+			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.html { render_html1 self.get_view_path(:index), layout: self.get_view_path(:layout), locals: {data: @local_data} }
+				format.json { render_json_ok(@local_data[:entries]) }
+			end
+		end
+
+
+		def dashboard
+
+			# 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 db_query_params 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(@local_data, true) #index page
+
+
+			# 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.html { render_html1 self.get_view_path(:dashboard), layout: self.get_view_path(:layout), locals: {data: @local_data} }
+				format.json { render_json_ok(nil) }
+			end
+		end
+
+
+		def show
+
+			# 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 db_query_params for search
+			db_query_params = {}
+			self.fill_obligatory_db_query_params(db_query_params)
+			db_query_params.merge!(@local_data[:parent_ids])
+			# retrieving entry from database
+			@local_data[:entry] = self.entry_class.get_entry_by_id(params[:id], db_query_params, @options)
+
+			#Rendering 'Entry Not Found' Page
+			self.kb_db_render_entry_not_found_page and return unless @local_data[:entry]
+
+			# 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
+
+
+					filters_for_list[:per_page] = params[list_per_page].to_i rescue 30
+					filters_for_list[:per_page] ||= 30
+					filters_for_list[:per_page] = 30 if filters_for_list[:per_page] == 0
+					filters_for_list[:page] = params[list_page].to_i rescue 1
+					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(@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.html { render_html1 self.get_view_path(:show), layout: self.get_view_path(:layout), locals: {data: @local_data} }
+				format.json { render_json_ok @local_data[:entry] }
+			end
+		end
+
+		def new
+
+			db_query_params = {}
+			self.fill_obligatory_db_query_params(db_query_params)
+
+			# 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(@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.html { render_html1 self.get_view_path(:new), layout: self.get_view_path(:layout), locals: {data: @local_data} }
+				format.json { render_json_ok @local_data[:entry] }
+			end
+		end
+
+
+		def create
+
+
+			# 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(@local_data, false) #not index page
+
+					# rendering page
+					format.html { render_html1 self.get_view_path(:new), layout: self.get_view_path(:layout), locals: {data: @local_data} }
+					format.json { render_json_error @local_data[:entry], message: @local_data[:errors] }
+				end
+			end
+		end
+
+
+		def edit
+
+			# 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 db_query_params for search
+			db_query_params = {}
+			self.fill_obligatory_db_query_params(db_query_params)
+			db_query_params.merge!(@local_data[:parent_ids])
+			# retrieving entry from database
+			@local_data[:entry] = self.entry_class.get_entry_by_id(params[:id], db_query_params, @options)
+
+			#Rendering 'Entry Not Found' Page
+			self.kb_db_render_entry_not_found_page and return unless @local_data[: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_db_query_params(filters_for_parents)
+			self.fill_parents_for_local_data(@local_data, filters_for_parents)
+			# building breadcrumbs
+
+			self.kb_dp_breadcrumbs_build(@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.html { render_html1 self.get_view_path(:edit), layout: self.get_view_path(:layout), locals: {data: @local_data} }
+				format.json { render_json_ok @local_data[:entry] }
+			end
+		end
+
+
+		def update
+
+
+			# 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 db_query_params for search
+			db_query_params = {}
+			self.fill_obligatory_db_query_params(db_query_params)
+			db_query_params.merge!(@local_data[:parent_ids]) # merging search db_query_params with parent ids
+			# retrieving data from database
+			@local_data[:entry] = self.entry_class.get_entry_by_id(params[:id], db_query_params, {logger: string_logger})
+
+			#Rendering 'Entry Not Found' Page
+			self.kb_db_render_entry_not_found_page and return unless @local_data[:entry]
+
+			# 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(@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.html { render_html1 self.get_view_path(:edit), layout: self.get_view_path(:layout), locals: {data: @local_data} }
+					format.json { render json: @local_data[:entry].errors, status: :unprocessable_entity }
+				end
+			end
+		end
+
+
+		def destroy
+
+
+			# 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 db_query_params for search
+			db_query_params = {}
+			self.fill_obligatory_db_query_params(db_query_params)
+			db_query_params.merge!(@local_data[:parent_ids])
+			# retrieving entry from database
+			@local_data[:entry] = self.entry_class.get_entry_by_id(params[:id], db_query_params, {logger: string_logger})
+
+			#Rendering 'Entry Not Found' Page
+			self.kb_db_render_entry_not_found_page and return unless @local_data[:entry]
+
+
+			# 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(:delete), layout: self.get_view_path(:layout), locals: {data: @local_data} }
+					format.json { render_json_error(message: @local_data[:errors]) }
+				end
+			end
+		end
+
+
+		def export
+
+			# 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 db_query_params for search
+			db_query_params = {}
+			self.fill_obligatory_db_query_params(db_query_params)
+			db_query_params.merge!(@local_data[:parent_ids])
+			# retrieving entries from database
+			@local_data[:entries] = self.entry_class.get_entries(nil, db_query_params, @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
+
+		def import
+			import_type = params[:type]
+
+		end
+
+		def manage_items
+
+
+			# getting management settings
+			@local_data[:management_settings] = @local_data[:page].managements[:manage] if @local_data[:page].managements
+
+			self.kb_dp_render_page_404 and return unless @local_data[:management_settings]
+
+
+			#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 db_query_params 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 db_query_params 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(@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.html { render_html1 self.get_view_path(:management), layout: self.get_view_path(:layout), locals: {data: @local_data} }
+				format.json { render json: @local_data }
+			end
+		end
+
+		def manage_items_add
+
+
+			# getting management settings
+			@local_data[:management_settings] = @local_data[:page].managements[:manage] if @local_data[:page].managements
+
+			self.kb_dp_render_page_404 and return 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 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)
+
+			#Rendering 'Entry Not Found' Page
+			self.kb_db_render_entry_not_found_page and return unless @local_data[:entry]
+
+			#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 db_query_params - #{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
+
+
+			# getting management settings
+			@local_data[:management_settings] = @local_data[:page].managements[:manage] if @local_data[:page].managements
+
+			self.kb_dp_render_page_404 and return 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 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
+
+			# getting sorting settings
+			@local_data[:sorting_settings] = @local_data[:page].sortings[:sort] if @local_data[:page].sortings
+
+			self.kb_dp_render_page_404 and return unless @local_data[:sorting_settings]
+
+
+			#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 db_query_params 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(@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
+
+
+			# getting sorting settings
+			@local_data[:sorting_settings] = @local_data[:page].sortings[:sort] if @local_data[:page].sortings
+
+			self.kb_dp_render_page_404 and return unless @local_data[:sorting_settings]
+
+			#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
+
+
+		# def http_download
+		#
+		# end
+		#
+		# def http_download_process
+		#
+		# def http_upload
+		#
+		# end
+		#
+		# def http_upload_process
+		#
+		# end
+
+
+		def edit_inplace
+
+
+			@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 = self.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
+
+
+		#protected
+
+
+		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), locals: {data: @local_data} }
+				format.json { render_json_page_404 }
+			end
+		end
+
+		def kb_db_render_entry_not_found_page
+			@local_data[:errors] << I18n.t("#{self.to_i18n}.messages.entry_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.html { render_html1 self.get_view_path(:entry_not_found), layout: self.get_view_path(:layout), locals: {data: @local_data} }
+				format.json { render_json_not_found message: @local_data[:errors] }
+			end
+		end
+
+
+		def kb_dp_breadcrumbs_build(local_data, is_index_page)
+			# getting home controller
+			local_home_path = self.class.get_method_latest_result(:get_kb_home_path)
+
+			if local_home_path
+				local_home_controller = eval(local_home_path[:controller])
+				local_home_url = local_home_controller.to_url_for(local_home_path[:action], local_home_path[:params])
+
+				if is_index_page
+					if self.class == local_home_path[:controller]
+						self.add_new_breadcrumb(I18n.t("#{local_home_controller.to_i18n}.#{local_home_path[:action]}.title"))
+					else
+						self.add_new_breadcrumb(I18n.t("#{local_home_controller.to_i18n}.#{local_home_path[:action]}.title"), local_home_url)
+					end
+				else
+					self.add_new_breadcrumb(I18n.t("#{local_home_controller.to_i18n}.#{local_home_path[:action]}.title"), local_home_url)
+				end
+			end
+			# building breadcrumbs for parents
+			parent_ids = {}
+			@local_data[:parents].reverse.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
+				self.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
+			self.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
+					self.add_new_breadcrumb(@local_data[:entry].id)
+				elsif page_name == :show || page_name == :delete
+					self.add_new_breadcrumb(entry_name || @local_data[:entry].id)
+				elsif page_name == :new
+					self.add_new_breadcrumb(I18n.t("#{self.to_i18n}.new.title"))
+				elsif page_name == :management
+					self.add_new_breadcrumb(I18n.t("#{self.to_i18n}.management.title"))
+				elsif page_name == :sorting
+					self.add_new_breadcrumb(I18n.t("#{self.to_i18n}.sorting.title"))
+				end
+			end
+		end
+
+
+		def kb_dp_init_controller_action
+
+			# check if controller implement methods 'entry_class'
+			#raise "\"kb_entry_class\" value not defined for controller #{self.class}" if self.entry_class.nil?
+			#raise "Current User NULL" if self.controller.current_user.nil?
+
+
+			#check if controller implement method 'get_kb_page'
+			raise "Method :get_kb_page must be implemented for controller '#{self.class}'" unless self.class.respond_to?(:get_kb_page)
+
+			# getting page mame symbol for action
+			page_name = case self.action_name
+				            when 'index' then
+					            :index
+				            when 'dashboard' then
+					            :dashboard
+				            when 'new', 'create' then
+					            :new
+				            when 'edit', 'update', 'edit_inplace' then
+					            :edit
+				            when 'delete', 'destroy' then
+					            :delete
+				            when 'sort_items', 'sort_items_process' then
+					            :sorting
+				            when 'manage_items', 'manage_items_add', 'manage_items_remove' then
+					            :management
+				            when 'show' then
+					            :show
+				            else
+					            nil
+			            end
+
+
+			#initialize '@local_data' variable
+			@local_data = {
+				errors: [],
+				messages: [],
+				page: nil,
+				menus: {}
+			}
+			# getting kb_page
+			@local_data[:page] = self.class.get_kb_page(page_name) if page_name
+			# Rendering 'Page not Found' and completing Request if no page found
+			self.kb_dp_render_page_404 unless @local_data[:page] if page_name
+
+
+			@local_data[:allow_create] = self.class.get_kb_page(:new) != nil
+			@local_data[:allow_update] = self.class.get_kb_page(:edit) != nil
+			@local_data[:allow_delete] = self.class.get_kb_page(:delete) != nil
+
+			@options = {
+				logger: self.string_logger
+			}
+			@local_data[:menus][:left_menu] = self.class.get_method_latest_result(:get_kb_menu, :left_menu)
+
+		end
+
+
+		#########################################################################################################################
+		###############################            Obligatory Filters Methods            ########################################
+		#########################################################################################################################
+
+
+		def fill_obligatory_db_query_params(db_query_params, options = {})
+			options ||= {}
+
+			classes_to_process = self.get_class_hierarchy
+
+			classes_to_process.each do |kontroller_klass|
+				kontroller_klass.get_kb_obligatory_filters.each do |filter|
+					execute_flag = true
+
+					if filter.only && filter.only.length > 0
+						execute_flag = false
+						filter.only.each do |item|
+							if item == self.action.to_sym
+								execute_flag = true
+							end
+						end
+					end
+					if filter.skip && filter.skip.length > 0
+						filter.skip.each do |item|
+							if item == self.action.to_sym
+								execute_flag = false
+							end
+						end
+					end
+					db_query_params[filter.name] = self.send(filter.source_method) if execute_flag
+				end if kontroller_klass.respond_to?(:get_kb_obligatory_filters)
+			end
+			#raise "Obligatory Filters: #{db_query_params.to_json}"
+		end
+
+		#########################################################################################################################
+		#################################             Data For Form Controls             ########################################
+		#########################################################################################################################
+
+		def load_data_for_entry_controls(form, entry, options = {})
+			controls_data = {}
+
+
+			form.properties.values.select { |p| !p.data_source.nil? }.each do |property|
+				if property.data_source
+					controls_data[property.name] = if property.data_source.type == :db || property.data_source.type == :jquery_db
+						                               db_query_params = {}
+						                               parent_value = nil
+						                               if property.parent
+							                               parent_value = entry[property.parent]
+							                               db_query_params[property.parent] = parent_value
+						                               end
+
+						                               self.fill_obligatory_db_query_params(db_query_params, options)
+						                               db_query_params.merge!({
+							                                                      per_page: 9999999,
+							                                                      page: 1
+						                                                      })
+						                               property.data_source.model.get_entries(nil, db_query_params, options).map { |u| [u.send(property.data_source.label_property), u.send(property.data_source.value_property)] } if property.parent.nil? || parent_value
+						                           elsif property.data_source.type == :i18n
+
+						                           elsif property.data_source.type == :enum
+							                           property.data_source.model.to_select
+						                           elsif property.data_source.type == :array
+							                           property.data_source.model.map { |i| i.is_a?(Array) ? [i[0], i[0]] : [i, i] }
+						                           end
+				end
+			end if form && form.properties
+			controls_data
+		end
+
+		def load_data_for_filters_controls(list, values_source, options = {})
+			controls_data = {}
+
+
+			list.filters.select { |f| !f.data_source.nil? }.each do |filter|
+
+				controls_data[filter.name] = if filter.data_source.type == :db || filter.data_source.type == :jquery_db
+					                             db_query_params = {}
+					                             if filter.parent
+						                             parent_value = values_source[filter.parent]
+						                             db_query_params[filter.parent] = values_source[filter.parent] if parent_value
+					                             end
+					                             fill_obligatory_db_query_params(db_query_params, options)
+					                             db_query_params.merge!({
+						                                                    per_page: 9999999,
+						                                                    page: 1
+					                                                    })
+					                             filter.data_source.model.get_entries(nil, db_query_params, options).map { |u| [u.send(filter.data_source.label_property), u.send(filter.data_source.value_property)] }
+					                         elsif filter.data_source.type == :i18n
+
+					                         elsif filter.data_source.type == :enum
+						                         filter.data_source.model.to_select
+					                         elsif filter.data_source.type == :array
+						                         filter.data_source.model
+					                         end
+
+			end if list && list.filters
+			controls_data
+		end
+
+
+		#def fill_parents_for_local_data(local_data, db_query_params)
+		#	if local_data && local_data.is_a?(Hash)
+		#		controllers_hierarchy = ::ChupakabraTools::ClassHelper.get_controller_hierarchy(self.class)
+		#
+		#		local_data[:parent_elements] = {}
+		#
+		#		controllers_hierarchy.each do |ctrler|
+		#			if ctrler.respond_to?(:get_kb_parents)
+		#				parent_controllers = ctrler.get_kb_parents
+		#				parent_controllers.each do |pk|
+		#					local_data[:parent_elements][pk[:id]] = pk[:controller].get_kb_entry_class.get_entry_by_id(params[pk[:id]], db_query_params, {logger: string_logger})
+		#				end if parent_controllers
+		#			else
+		#				break
+		#			end
+		#		end
+		#
+		#		#raise "Parent Elements: #{local_data[:parent_elements]}"
+		#
+		#		local_data[:parent_ids] = {}
+		#
+		#
+		#		local_data[:parent_elements].each_pair do |key, element|
+		#			local_data[:parent_ids][key] = element.id
+		#		end
+		#	end
+		#end
+
+
+		# old version of fill_parents_for_local_data
+		# def fill_parents_for_local_data(local_data, db_query_params, options = {})
+		# 	options ||= {}
+		# 	local_data[:parents] = []
+		# 	local_data[:parent_elements] = {}
+		# 	local_data[:parent_ids] = {}
+		#
+		# 	if local_data && local_data.is_a?(Hash)
+		# 		controllers_hierarchy = ::ChupakabraTools::ClassHelper.get_controller_hierarchy(self.class)
+		#
+		# 		#raise "FILL PARENT ELEMENTS - CONTROLLERS #{controllers_hierarchy.map{ |c| c.to_s}.to_json}"
+		# 		controllers_hierarchy.each do |ctrler|
+		# 			if ctrler.respond_to?(:get_kb_parents)
+		# 				parent_controllers = ctrler.get_kb_parents
+		# 				parent_controllers.each do |pk|
+		# 					parent_entry = pk[:controller].get_kb_entry_class.get_entry_by_id(params[pk[:id]], db_query_params, options)
+		# 					parent_hash = {
+		# 						controller: pk[:controller],
+		# 						entry: parent_entry,
+		# 						id_param: pk[:id],
+		# 						id_value: parent_entry.id
+		# 					}
+		# 					local_data[:parents] << parent_hash
+		# 				end if parent_controllers
+		#
+		# 				parent_controllers.each do |pk|
+		# 					local_data[:parent_elements][pk[:id]] = pk[:controller].get_kb_entry_class.get_entry_by_id(params[pk[:id]], db_query_params, options)
+		# 				end if parent_controllers
+		#
+		# 			end
+		# 		end
+		# 		#raise "Parent Elements: #{local_data[:parent_elements]}"
+		# 		local_data[:parent_elements].each_pair do |key, element|
+		# 			local_data[:parent_ids][key] = element.id
+		# 		end
+		# 	end
+		# end
+
+
+		def fill_parents_for_local_data(local_data, db_query_params, options = {})
+			options ||= {}
+
+			if local_data && local_data.is_a?(Hash)
+
+				local_data[:parents] = []
+				local_data[:parent_elements] = {}
+				local_data[:parent_ids] = {}
+
+				#controllers_hierarchy = ::ChupakabraTools::ClassHelper.get_controller_hierarchy(self.class)
+
+				#raise "FILL PARENT ELEMENTS - CONTROLLERS #{controllers_hierarchy.map{ |c| c.to_s}.to_json}"
+
+				ktrlr = self.class # setting start value for 'ktrlr' as 'self'
+				while true do
+					parent_ktrlr_data = ktrlr.get_kb_parent_controller_data # getting parent controller data set with kb_parent_controller
+					break unless parent_ktrlr_data # unless we have parent controller data we break the WHILE loop
+
+					parent_entry = parent_ktrlr_data[:controller].get_kb_entry_class.get_entry_by_id(params[parent_ktrlr_data[:id]], db_query_params, options) # getting entry for parent controller
+					parent_hash = {
+						controller: parent_ktrlr_data[:controller],
+						entry: parent_entry,
+						id_param: parent_ktrlr_data[:id],
+						id_value: parent_entry.id
+					}
+					local_data[:parents] << parent_hash
+					local_data[:parent_elements][parent_ktrlr_data[:id]] = parent_entry
+					local_data[:parent_ids][parent_ktrlr_data[:id]] = parent_entry.id
+
+					ktrlr = parent_ktrlr_data[:controller] # assiging value for 'ktrlr' as controller from parent controller data
+
+				end
+
+				#raise "FILL PARENT ELEMENTS - Parent Elements: #{local_data[:parent_elements].to_json}"
+				#raise "FILL PARENT ELEMENTS - Parent IDs: #{local_data[:parent_ids].to_json}"
+			end
+		end
+
+		#########################################################################################################################
+		###############################            Strong Parameters Filters Methods            ########################################
+		#########################################################################################################################
+
+		def class_strong_filters(list, options = {})
+			strong_filters = {}
+			list.filters.each do |filter|
+				#raise "Found Filter for list: #{filter}"
+				strong_filters[filter.name] = params[filter.name] if params[filter.name]
+			end if list && list.filters
+			strong_filters
+		end
+
+
+		#########################################################################################################################
+		###############################         Transaction Injection Methods            ########################################
+		#########################################################################################################################
+		def before_entry_create(entry, filter_params, options)
+
+		end
+
+		def before_entry_update(entry, filter_params, options)
+
+		end
+
+		#########################################################################################################################
+		#################################         Database Requests Methods            ##########################################
+		#########################################################################################################################
+
+
+	end
+end