kirgudu_base 0.0.3 → 0.0.4

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

@@ -13,74 +13,136 @@ module KirguduBase
 
 
 			module InstanceMethods
-				def managing_items_index
-					@container = get_managing_container_class.find(params[get_managing_parent_id_key])
-					@items = get_managing_item_class.where(container_id: @container).order(:sort_position).page(params[:page_id])
+				def management_items_index
 
-					@managing_item_class = get_managing_item_class.to_s
-					@managing_container_class = get_managing_container_class.to_s
+					management_settings = self.class.get_kb_option(:management_settings)
+
+					filters_4_container = {}
+					self.fill_obligatory_filters(filters_4_container)
+
+					local_data = {}
+
+					local_data[:management_settings] = management_settings
+
+					local_container = management_settings.container_class.get_entry_by_id(params[management_settings.container_id_property], filters_4_container, {logger: string_logger})
+					local_data[:container] = local_container
+
+					filters_4_items = {}
+					self.fill_obligatory_filters(filters_4_items)
+					filters_4_items[management_settings.container_id_property] = params[management_settings.container_id_property]
+
+					local_items = management_settings.item_class.get_entries(nil, filters_4_items, {logger: string_logger})
+					local_data[:items] = local_items
 
-					views_path = get_managing_views_path if self.respond_to?(:get_managing_views_path)
-					views_path = "/shared/manage_items/" unless views_path
 
 					respond_to do |format|
-						format.html { render_html1("#{views_path}managing_items_index") }
-						format.json { render json: @container }
+						format.html { render_html1(self.class.get_method_latest_result(:get_kb_view_path, :index), locals: { data: local_data}) }
+						format.json { render json: local_data }
 					end
 				end
 
-				def managing_items_manage
-					@container = get_managing_container_class.find(params[get_managing_parent_id_key])
-					@items = get_managing_item_class.where(container_id: @container).order(:sort_position).page(params[:cpage])
+				def management_items_manage
 
-					@managing_item_class = get_managing_item_class.to_s
-					@managing_container_class = get_managing_container_class.to_s
+					local_data = {}
 
+					# gettting management settings
+					management_settings = self.class.get_kb_option(:management_settings)
+					local_data[:management_settings] = management_settings
 
-					container_all_items_ids = Array.new
+					#loading container data
+					filters_4_container = {}
+					self.fill_obligatory_filters(filters_4_container)
 
-					get_managing_item_class.where(container_id: @container.id).map { |u| container_all_items_ids.push(u.entry_id) }
+					local_container = management_settings.container_class.get_entry_by_id(params[management_settings.container_id_property], filters_4_container, {logger: string_logger})
+					local_data[:container] = local_container
 
+					#loading items data
+					filters_4_items = {}
+					self.fill_obligatory_filters(filters_4_items)
+					filters_4_items[management_settings.container_id_property] = params[management_settings.container_id_property]
+					filters_4_items[:per_page] = 999999
+					filters_4_items[:page] = 1
 
-					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
+					local_items = management_settings.item_class.get_entries(nil, filters_4_items, {logger: string_logger})
+					local_data[:items] = local_items
 
-					@entries = get_managing_entry_class.where { -(id.in container_all_items_ids) }.page(params[:ppage]).order(entries_order_by)
+					#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
+					filters_4_entries = {}
+					self.fill_obligatory_filters(filters_4_entries)
+					filters_4_entries[management_settings.entry_id_property] = params[management_settings.entry_id_property]
+					filters_4_entries[:per_page] = 999999
+					filters_4_entries[:page] = 1
+
+					# query to exclude already added entries
+					local_entries_initial_query = management_settings.entry_class.where { -(id.in management_settings.item_class.get_entries(nil, filters_4_items, {logger: string_logger}).select(management_settings.entry_id_property)) }
+
+					local_entries = management_settings.entry_class.get_entries(local_entries_initial_query, filters_4_entries, {logger: string_logger})
+					local_data[:entries] = local_entries
+
+					# fill parent for data
+					filters_for_parents = {}
+					self.fill_obligatory_filters(filters_for_parents)
+					self.fill_parents_for_local_data(local_data, filters_for_parents)
 
 
-					views_path = get_managing_views_path if self.respond_to?(:get_managing_views_path)
-					views_path = "/shared/manage_items/" unless views_path
 
 					respond_to do |format|
-						format.html { render_html1("#{views_path}managing_items_manage") }
+						format.html { render_html1 self.class.get_method_latest_result(:get_kb_view_path, :management), locals: { data: local_data}  }
 						format.json { render json: @entries }
 					end
 				end
 
-				def managing_items_add
-					container = get_managing_container_class.where(id: params[get_managing_parent_id_key]).first
-					entry = get_managing_entry_class.where(id: params[:entry_id]).first
+				def management_items_add
+
+					local_data = {}
+
+					# getting management settings
+					management_settings = self.class.get_kb_option(:management_settings)
+					local_data[:management_settings] = management_settings
 
+					#loading container data
+					filters_4_container = {}
+					self.fill_obligatory_filters(filters_4_container)
+					local_container = management_settings.container_class.get_entry_by_id(params[management_settings.container_id_property], filters_4_container, {logger: string_logger})
 
-					unless container
+					#loading entry data
+					filters_4_entries = {}
+					self.fill_obligatory_filters(filters_4_entries)
+					local_entry = management_settings.entry_class.get_entry_by_id(params[management_settings.entry_id_property], filters_4_entries, {logger: string_logger})
+
+					#checking if data found and valid
+					unless local_container
 						render json: {status: ::ChupakabraTools::SetManagementResult.id_by_tag('set_not_found'), message: I18n.t("#{self.to_i18n}.management.messages.set_not_found", id: params[:id])}
 						return
 					end
-					unless entry
+					unless local_entry
 						render json: {status: ::ChupakabraTools::SetManagementResult.id_by_tag('entry_not_found'), message: I18n.t("#{self.to_i18n}.management.messages.entry_not_found", entry_id: params[:entry_id])}
 						return
 					end
 
-					item = get_managing_item_class.where(container_id: container.id, entry_id: entry).first
+					filters_4_item = {}
+					self.fill_obligatory_filters(filters_4_item)
+					filters_4_item[management_settings.entry_id_property] = params[management_settings.entry_id_property]
+					filters_4_item[management_settings.container_id_property] = params[management_settings.container_id_property]
+
+					local_item = management_settings.item_class.get_entries(nil, filters_4_item, {logger: string_logger}).first
+
+					unless local_item
+						local_item = get_managing_item_class.new
+						local_item[management_settings.container_id_property] = container.id
+						local_item[management_settings.entry_id_property] = entry.id
 
-					unless item
-						item = get_managing_item_class.new
-						item.container_id = container.id
-						item.entry_id = entry.id
-						max_sort_position = get_managing_item_class.where(container_id: container.id).maximum(:sort_position)
-						item.sort_position = max_sort_position ? max_sort_position + 1 : 1
+						if local_item.respond_to?(:sort_position)
+							filters_4_items_max = {}
+							self.fill_obligatory_filters(filters_4_items_max)
+							filters_4_items_max[management_settings.container_id_property] = params[management_settings.container_id_property]
+
+							max_sort_position = management_settings.item_class.get_entries(nil, filters_4_items_max, {logger: string_logger}).maximum(:sort_position)
+							local_item.sort_position = max_sort_position ? max_sort_position + 1 : 1
+						end
 
-						if item.save
+						if local_item.save
 							render json: {status: ::ChupakabraTools::SetManagementResult.id_by_tag('management_ok'), message: I18n.t("#{self.to_i18n}.management.messages.add_management_ok")}
 						else
 							render json: {status: ::ChupakabraTools::SetManagementResult.id_by_tag('management_error'), message: I18n.t("#{self.to_i18n}.management.messages.add_management_error")}
@@ -90,17 +152,33 @@ module KirguduBase
 					end
 				end
 
-				def managing_items_remove
-					container = get_managing_container_class.where(id: params[:id]).first
+				def management_items_remove
 
+					local_data = {}
 
-					unless container
+					# getting management settings
+					management_settings = self.class.get_kb_option(:management_settings)
+					local_data[:management_settings] = management_settings
+
+					#loading container data
+					filters_4_container = {}
+					self.fill_obligatory_filters(filters_4_container)
+					local_container = management_settings.container_class.get_entry_by_id(params[management_settings.container_id_property], filters_4_container, {logger: string_logger})
+
+					unless local_container
 						render json: {status: ::ChupakabraTools::SetManagementResult.id_by_tag('set_not_found'), message: I18n.t("#{self.to_i18n}.management.messages.set_not_found", id: params[:id])}
 						return
 					end
 
-					item = get_managing_item_class.where(container_id: container.id, entry_id: params[:entry_id]).first
-					unless item
+					filters_4_item = {}
+					self.fill_obligatory_filters(filters_4_item)
+					filters_4_item[management_settings.entry_id_property] = params[management_settings.entry_id_property]
+					filters_4_item[management_settings.container_id_property] = params[management_settings.container_id_property]
+
+					local_item = management_settings.item_class.get_entries(nil, filters_4_item, {logger: string_logger}).first
+
+
+					unless local_item
 						render json: {status: ::ChupakabraTools::SetManagementResult.id_by_tag('item_not_found'), message: I18n.t("#{self.to_i18n}.management.messages.item_not_found", entry_id: params[:entry_id])}
 						return
 					end

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

@@ -11,7 +11,7 @@ module KirguduBase
 			end
 
 			module InstanceMethods
-				def managing_items_sort_index
+				def sorting_items_index
 					@container= get_managing_container_class.find(params[get_managing_parent_id_key])
 					@items = get_managing_item_class.where(container_id: @container.id).order(:sort_position)
 
@@ -27,7 +27,7 @@ module KirguduBase
 					end
 				end
 
-				def managing_items_sort_process
+				def sorting_items_process
 					container = get_managing_container_class.find(params[get_managing_parent_id_key])
 					unless container
 						render json: {status: ::ChupakabraTools::SetManagementResult.id_by_tag('set_not_found'), message: I18n.t("#{self.to_i18n}.sorting.messages.set_not_found", id: params[:id])}

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

@@ -2,6 +2,10 @@ module KirguduBase
 	module Controllers
 		module DynamicPages
 
+
+			attr_accessor :kirgudu_controller_options
+
+
 			def kb_page(name, &block)
 
 				#raise "Page Name: #{name}"
@@ -10,28 +14,111 @@ module KirguduBase
 
 				element = ::KirguduBase::DynamicPages::PageBuilder.new(name, &block).to_element
 
-				exist_elements = @kirgudu_base_pages[element.name]
+				existent_page = @kirgudu_base_pages[element.name]
 
-				if exist_elements
-					exist_elements.merge(element)
+				if existent_page
+					existent_page.merge(element)
 				else
 					@kirgudu_base_pages[element.name] = element
 				end
+			end
+
+			def kb_menu(name, &block)
+
+				#raise "Page Name: #{name}"
+
+				@kirgudu_base_menus ||= {}
+
+				element = ::KirguduBase::DynamicPages::MenuBuilder.new(name, &block).to_element
+
+				existent_element = @kirgudu_base_menus[element.name]
+
+				if existent_element
+					existent_element.merge(element)
+				else
+					@kirgudu_base_menus[element.name] = element
+				end
+			end
+
+
+			def kb_parent_controller(controller, id)
+				options_array = kb_get_parents_options_container
+				options_array << {controller: controller, id: id}
+			end
+
+
+			def kb_entry_class(entry_class)
+				options = kb_get_options_container
+				options[:entry_class] = entry_class
+			end
+
+			def kb_home_controller(name)
+				options = kb_get_options_container
+				options[:home_controller] = name
+			end
+
+
+			def kb_management_settings(&block)
+				options = kb_get_options_container
+				options[:management_settings] = ::KirguduBase::DynamicPages::ManagementSettingsBuilder.new(&block).to_element
+			end
+
+			def kb_views_paths_404_page(value)
+				options = kb_get_view_paths_options_container
+				options[:page_404] = value
+			end
+
+			def kb_views_paths_entry_not_found(value)
+				options = kb_get_view_paths_options_container
+				options[:entry_not_found] = value
+			end
+
 
+			def kb_views_paths_index(value)
+				options = kb_get_view_paths_options_container
+				options[:index] = value
+			end
 
+			def kb_views_paths_new(value)
+				options = kb_get_view_paths_options_container
+				options[:new] = value
 			end
 
-			def kb_parent_controller(value)
-				@kirgudu_controller_options ||= {}
-				@kirgudu_controller_options[:parent_controller] = value
+			def kb_views_paths_edit(value)
+				options = kb_get_view_paths_options_container
+				options[:edit] = value
 			end
 
-			def kb_parent_id(value)
-				@kirgudu_controller_options ||= {}
-				@kirgudu_controller_options[:parent_id] = value
+			def kb_views_paths_delete(value)
+				options = kb_get_view_paths_options_container
+				options[:delete] = value
 			end
 
-			def get_kb_options(name)
+			def kb_views_paths_show(value)
+				options = kb_get_view_paths_options_container
+				options[:show] = value
+			end
+
+			def kb_views_paths_management(value)
+				options = kb_get_view_paths_options_container
+				options[:management] = value
+			end
+
+			def kb_views_paths_sorting(value)
+				options = kb_get_view_paths_options_container
+				options[:sorting] = value
+			end
+
+
+
+			def kb_template(name)
+				options = kb_get_options_container
+				options[:template] = name
+			end
+
+
+
+			def get_kb_option(name)
 				@kirgudu_controller_options[name] if @kirgudu_controller_options
 			end
 
@@ -39,6 +126,36 @@ module KirguduBase
 				@kirgudu_base_pages[name] if @kirgudu_base_pages
 			end
 
+			def get_kb_menu(name)
+				@kirgudu_base_menus[name] if @kirgudu_base_menus
+			end
+
+			def get_kb_view_path(view_name)
+				if view_name
+					options = kb_get_view_paths_options_container
+					options[view_name.to_sym]
+				end
+			end
+
+			def get_kb_parents
+				kb_get_parents_options_container
+			end
+
+			def get_kb_entry_class
+				options = kb_get_options_container
+				options[:entry_class]
+			end
+
+			def get_kb_home_controller
+				options = kb_get_options_container
+				options[:home_controller]
+			end
+
+			def get_kb_template
+				options = kb_get_options_container
+				options[:template]
+			end
+
 
 			def kb_form_properties_template_set(name, &block)
 
@@ -46,7 +163,7 @@ module KirguduBase
 
 				#@form_properties_template_set = {} unless @form_properties_template_set
 				#
-				#template_set = ::KirguduBase::DynamicPages::FormPropertiesNamedSetBuilder.new(self, name, &block).to_set
+				#template_set = ::KirguduBase::DynamicPages::FormPropertiesNamedSetBuilder.new(name, &block).to_set
 				#@@form_properties_template_set[template_set.name] = template_set
 
 
@@ -55,6 +172,25 @@ module KirguduBase
 			def get_form_properties_template_set(name)
 				@kirgudu_base_pages[name] if @kirgudu_base_pages
 			end
+
+			protected
+			def kb_get_view_paths_options_container
+				options = self.kb_get_options_container
+				options[:views_paths] ||= {}
+				options[:views_paths]
+			end
+
+			def kb_get_options_container
+				self.kirgudu_controller_options ||= {}
+				self.kirgudu_controller_options
+			end
+
+			def kb_get_parents_options_container
+				options = kb_get_options_container
+				options[:parents] ||= []
+				options[:parents]
+			end
+
 		end
 	end
 end

data/app/helpers/kirgudu_base/form_builder.rb

@@ -104,6 +104,7 @@ module KirguduBase
 		def text_field(property, html_options = {})
 			html_options ||= {}
 
+
 			html_options.merge!(property.html_options) if property.html_options
 			html_options.merge!(
 				{
@@ -116,7 +117,8 @@ module KirguduBase
 
 			html_options_add_class(html_options, "error") if @object.errors[property.name].present?
 
-			super(property.name, html_options)
+
+			text_field_tag(property, @object, html_options)
 		end
 
 		def text_area(property, html_options = {})

data/app/helpers/kirgudu_base/gui_helper.rb

@@ -65,9 +65,10 @@ module KirguduBase
 			::KirguduBase::GuiHelper.html_options_prepare_commons(html_options, property, data_source)
 
 			html_options[:id] = SecureRandom.uuid.underscore unless html_options[:id]
-			html_options[:type] = "text"
-			html_options[:"control-type"] = "text-field"
-
+			html_options.merge!({
+				                    type: "text",
+				                    :"control-type" => "text-field"
+			                    })
 			content_tag("input", '', html_options)
 		end
 
@@ -90,12 +91,13 @@ module KirguduBase
 		def password_field_tag(property, data_source, html_options = {})
 			html_options ||= {}
 
+			::KirguduBase::GuiHelper.html_options_prepare_commons(html_options, property, data_source)
+
 			html_options.merge!({
 				                    type: "password",
 				                    :"control-type" => "password-field"
 			                    })
 
-			::KirguduBase::GuiHelper.html_options_prepare_commons(html_options, property, data_source)
 
 			html_options[:id] = SecureRandom.uuid.underscore unless html_options[:id]
 
@@ -299,6 +301,7 @@ module KirguduBase
 
 			html_options ||= {}
 			::KirguduBase::GuiHelper.html_options_add_class(html_options, ["chzn-select"])
+			html_options[:'control-type'] = 'chosen-select'
 
 			select_tag(property, data_source, choices_data, html_options)
 		end
@@ -310,6 +313,8 @@ module KirguduBase
 
 			control_value = ::KirguduBase::GuiHelper.get_value_for_control(property, data_source)
 
+			html_options[:'control-type'] ||= 'select'
+
 			if property.data_source.type == :jquery || property.data_source.type == :jquery_db
 				html_options.merge!({
 					                    :"ds-method" => property.data_source.http_method,
@@ -628,7 +633,7 @@ module KirguduBase
 				:"property-name" => property.name,
 				:"property-value" => control_value,
 				:"parent-property" => (property.parent if property.parent),
-				:"placeholder" => property.i18n_data_as_string(:placeholder)
+				:"placeholder" => (property.i18n_data_as_string(:placeholder) if property.placeholder)
 			)
 
 			# Adding to control attribute value: class = 'error' if error