kirgudu_base 0.0.1 → 0.0.3

data/app/models/kirgudu_base/common.rb

@@ -0,0 +1,7 @@
+module KirguduBase
+  module Common
+    def self.table_name_prefix
+      'kirgudu_base_common_'
+    end
+  end
+end

data/app/models/kirgudu_base/common/portal.rb

@@ -0,0 +1,49 @@
+module KirguduBase
+	module Common
+		class Portal < ::KirguduBase::BaseModel
+
+			include ::KirguduBase::Models::BasicProperties::CreatedBy
+			include ::KirguduBase::Models::BasicProperties::UpdatedBy
+			include ::KirguduBase::Models::BasicProperties::OwnedBy
+			include ::KirguduBase::Models::BasicProperties::AdministratedBy
+
+
+
+			validates_presence_of :dns_name, :name
+			validates_uniqueness_of :dns_name
+			validates_length_of :dns_name, :name, allow_blank: true, maximum: 180
+
+
+			has_many :portal_users, class_name: ::KirguduBase::Common::PortalUser, foreign_key: :portal_id, dependent: :destroy
+			#has_many :users, class_name: ::KirguduBase::Securtiy::User, through: :portal_users
+
+
+
+			scope :with_dns_name, lambda { |value|
+				if value
+					value = value.gsub('%', '')
+					like_value = "%#{value}%"
+					where { dns_name.like like_value }
+				end
+			}
+
+			scope :with_keyword, lambda { |value|
+				if value
+					value = value.gsub('%', '')
+					like_value = "%#{value}%"
+					where { (name.like like_value) | (dns_name.like like_value) }
+				end
+			}
+
+
+			def self.apply_filters_to_query(query, filters={})
+				filters ||= {}
+
+				query = query.with_dns_name(filters[:dns_name])
+
+				super(query, filters)
+			end
+
+		end
+	end
+end

data/app/models/kirgudu_base/common/portal_user.rb

@@ -0,0 +1,58 @@
+module KirguduBase
+	module Common
+		class PortalUser  < ::KirguduBase::BaseModel
+
+			include ::KirguduBase::Models::BasicProperties::User
+			include ::KirguduBase::Models::BasicProperties::Portal
+
+
+			validates_presence_of :user_id, :portal_id
+			validates_uniqueness_of :user_id, scope: :portal_id
+
+
+			scope :by_status, lambda { |value| where { status_id == value } if value }
+
+
+			scope :with_keyword, lambda { |value|
+				if value
+					value = value.gsub('%', '')
+					like_value = "%#{value}%"
+					where { (user.first_name.like like_value) | (user.last_name.like like_value) }
+				end
+			}
+
+			def self.apply_filters_to_query(query, filters={})
+				filters ||= {}
+
+				filters.merge!({
+					               order:
+							               ["#{::KirguduBase::Common::Portal.table_name}.name asc",
+							               "#{::KirguduBase::Security::User.table_name}.last_name asc",
+							               "#{::KirguduBase::Security::User.table_name}.first_name asc"].join(", ")
+				               })
+
+				query = query.joins(:user).includes(:portal, :user)
+
+				super(query, filters)
+			end
+
+
+			def name_for_breadcrumbs
+				self.user_name
+			end
+
+			def to_s
+				self.user_name
+			end
+
+			def as_json(options = { })
+				# just in case someone says as_json(nil) and bypasses
+				# our default...
+				super((options || { }).merge({
+					                             :methods => [:user_name, :portal_name]
+				                             }))
+			end
+
+		end
+	end
+end

data/app/models/kirgudu_base/dynamic_filters/obligatory_filter.rb

@@ -0,0 +1,24 @@
+module KirguduBase
+	module DynamicFilters
+		class ObligatoryFilter < ::KirguduBase::DynamicPages::Element
+
+			validates_presence_of :name, :source_method
+
+			def initialize(options={})
+				self.name = nil
+				self.source_method = nil
+				self.only = nil
+				self.skip = nil
+
+				super(options)
+			end
+
+			attr_accessor :name
+			attr_accessor :source_method
+			attr_accessor :only
+			attr_accessor :skip
+
+
+		end
+	end
+end

data/app/models/kirgudu_base/dynamic_filters/obligatory_filter_builder.rb

@@ -0,0 +1,47 @@
+module KirguduBase
+	module DynamicFilters
+		class ObligatoryFilterBuilder < ::KirguduBase::DynamicPages::Builder
+
+			def initialize(name, &block)
+
+				self.builder_options.merge!(
+					{
+						name: nil,
+						source_method: nil,
+					    only: nil,
+					    skip: nil
+					}
+				)
+
+				self.name(name)
+				super(&block)
+			end
+
+			def source_method(value)
+				self.builder_options[:source_method] = value
+			end
+
+			def only(value)
+				self.builder_options[:only] = value
+			end
+
+			def skip(value)
+				self.builder_options[:skip] = value
+			end
+
+			def to_filter
+				element = ::KirguduBase::DynamicFilters::ObligatoryFilter.new
+				self.build_element(element)
+				self.validate_generated_element(element)
+				element
+			end
+
+
+			protected
+			def name(value)
+				self.builder_options[:name] = value
+			end
+
+		end
+	end
+end

data/app/models/kirgudu_base/dynamic_pages/builder.rb

@@ -0,0 +1,81 @@
+module KirguduBase
+	module DynamicPages
+		class Builder
+			def initialize(&block)
+				self.kontroller_klass = kontroller_klass
+				self.parent_element = parent_element
+
+				instance_eval(&block) if block_given?
+			end
+
+
+			def build_element(element)
+				self.builder_options.each_pair do |key, value|
+					element.send("#{key}=", value)
+				end
+				element.fix_parent_entry(nil)
+				self.validate_generated_element(element)
+			end
+
+
+			def builder_options
+				@options = {} unless @options
+				@options
+			end
+
+			def validate_empty_parameter(name, value)
+				raise "Parameter \"#{name}\" cannot be empty. If you dont want to assign specific value to this parameter, just delete it from code" unless value
+			end
+
+			def valiadte_interger_parameter(name, value)
+				raise "Parameter \"#{name}\" accepts only integer values" unless value.is_a?(Integer)
+			end
+
+			def valiadte_interger_positive_parameter(name, value)
+				raise "Parameter \"#{name}\" accepts only integer values" unless value.is_a?(Integer)
+				raise "Parameter \"#{name}\" accepts only positive values (>=0)" unless value.is_a?(Integer) if value < 0
+			end
+
+
+			def validate_string_parameter(name, value)
+				raise "Parameter \"#{name}\" must be a \"String\"." unless value && value.is_a?(String)
+			end
+
+			def validate_symbol_parameter(name, value)
+				raise "Parameter \"#{name}\"must be a :Symbol." unless value && value.is_a?(Symbol)
+			end
+
+			def validate_string_or_symbol_parameter(name, value)
+				raise "Parameter \"#{name}\" must be a \"String\" or a :Symbol." unless value && (value.is_a?(String) || value.is_a?(Symbol))
+			end
+
+			attr_accessor :kontroller_klass
+			attr_accessor :parent_element
+
+			def validate_generated_element(element)
+				errors = []
+				unless element.valid?
+
+					#raise "ERRORS FOR ELEMENT: #{element.errors.methods.to_json}"
+					element.errors.each do |key, element_errors|
+						errors << "'#{key}' #{element_errors}"
+						#raise "ERROR KEY: #{key}; ERROR MESSAGES: #{element_errors}"
+						#element_errors.each do |element_error|
+						#	errors << "'#{key}' #{element_error}"
+						#end
+					end
+				end
+				if errors.length > 0
+
+					raise "ERRORS<br/>
+						   Controller: #{kontroller_klass} <br/>
+						   Class: #{element.class}
+						   Parent: #{element.parent_element} <br/>
+						   Name: #{element.name if element.respond_to?(:name)} <br/>
+
+						   #{errors.join('<br/>')}".html_safe
+				end
+			end
+		end
+	end
+end

data/app/models/kirgudu_base/dynamic_pages/controller_link.rb

@@ -0,0 +1,37 @@
+module KirguduBase
+	module DynamicPages
+		class ControllerLink < ::KirguduBase::DynamicPages::Element
+
+			mergeable_attributes :controller, :action, :id
+			fixable_attributes :id
+
+			validates_presence_of :action
+
+			def initialize(options = {})
+
+				self.controller = nil
+				self.action = nil
+				self.id = nil
+
+				super(options)
+			end
+
+
+			attr_accessor :controller
+			attr_accessor :action
+			attr_accessor :id
+
+
+			def to_external_hash(options = {})
+				options ||= {}
+				options.merge!({
+					               controller: self.controller,
+					               action: self.action,
+					               id: self.id
+				               })
+				super(options)
+			end
+
+		end
+	end
+end

data/app/models/kirgudu_base/dynamic_pages/controller_link_builder.rb

@@ -0,0 +1,44 @@
+module KirguduBase
+	module DynamicPages
+		class ControllerLinkBuilder < ::KirguduBase::DynamicPages::Builder
+
+			def initialize(&block)
+				raise "Cannot Build Empty Data Source" unless block_given?
+
+				self.builder_options.merge!(
+					{
+						controller: nil,
+						action: nil,
+						id: nil
+					}
+				)
+
+				super(&block)
+			end
+
+
+			def controller(value)
+				self.builder_options[:controller] = value
+			end
+
+
+			def action(value)
+				self.builder_options[:action] = value
+			end
+
+
+			def id(&block)
+				self.builder_options[:id] = ::KirguduBase::DynamicPages::ControllerLinkIdBuilder.new(&block).to_element
+			end
+
+
+			def to_element
+				element = ::KirguduBase::DynamicPages::ControllerLink.new()
+				self.build_element(element)
+				self.validate_generated_element(element)
+				element
+			end
+
+		end
+	end
+end

data/app/models/kirgudu_base/dynamic_pages/controller_link_id.rb

@@ -0,0 +1,35 @@
+module KirguduBase
+	module DynamicPages
+		class ControllerLinkId < ::KirguduBase::DynamicPages::Element
+
+			mergeable_attributes :id_source, :id_target
+
+			validates_presence_of :id_source, :id_target
+
+			def initialize(options = {})
+
+				self.id_source = nil
+				self.id_target = nil
+
+				super(options)
+			end
+
+			attr_accessor :id_source
+			attr_accessor :id_target
+
+
+			def to_external_hash(options = {})
+				options ||= {}
+				options.merge!({
+					               #url: self.url,
+					               #data_format: self.data_format,
+					               #http_method: self.http_method,
+					               #label_property: self.label_property,
+					               #value_property: self.value_property
+				               })
+				super(options)
+			end
+
+		end
+	end
+end

data/app/models/kirgudu_base/dynamic_pages/controller_link_id_builder.rb

@@ -0,0 +1,38 @@
+module KirguduBase
+	module DynamicPages
+		class ControllerLinkIdBuilder < ::KirguduBase::DynamicPages::Builder
+
+
+
+
+
+			def initialize(&block)
+				self.builder_options.merge!(
+					{
+						id_source: nil,
+						id_target: nil
+					}
+				)
+
+				super(&block)
+			end
+
+
+			def id_source(value)
+				self.builder_options[:id_source] = value
+			end
+
+			def id_target(value)
+				self.builder_options[:id_target] = value
+			end
+
+			def to_element
+				element = ::KirguduBase::DynamicPages::ControllerLinkId.new
+				self.build_element(element)
+				self.validate_generated_element(element)
+				element
+			end
+
+		end
+	end
+end

data/app/models/kirgudu_base/dynamic_pages/data_source.rb

@@ -1,111 +1,61 @@
-class KirguduBase::DynamicPages::DataSource
+module KirguduBase
+	module DynamicPages
+		class DataSource < ::KirguduBase::DynamicPages::Element
 
-	SUPPORTED_DATA_FORMATS = [:xml, :json, :csv ]
-	SUPPORTED_DATASOURCE_TYPES = [:jquery, :rails, :local]
+			mergeable_attributes :model, :cross_domain, :cache_locally, :url, :data_format, :label_property, :value_property, :type, :http_method
 
+			validates_presence_of :model, :type, :label_property, :value_property
+			validates_presence_of :url, :http_method, if: :is_internet_data_source?
 
-	def initialize(options = {})
-		self.name = nil
-		self.model = nil
-		self.cross_domain = false
-		self.cache_locally = false
-		self.list_url = nil
-		self.entry_url = nil
-		self.data_format = :json
-		self.label_property = "name"
-		self.value_property = "id"
-		self.type = :local
+			validates_inclusion_of :type, in: ::KirguduBase::DynamicPages::Enums::SUPPORTED_DATA_SOURCE_TYPES, allow_nil: true
+			validates_inclusion_of :data_format, in: ::KirguduBase::DynamicPages::Enums::SUPPORTED_DATA_FORMATS, allow_nil: true, message: "This Format is not supported. Supported Data Formats are #{::KirguduBase::DynamicPages::Enums::SUPPORTED_DATA_FORMATS.map { |i| ":#{i}" }.join(", ")}"
 
-		if options
-			options.symbolize_keys!
-			options.each_pair do |key, value|
-				self.send("#{key}=", value)
-			end
-		end
-	end
+			validates_inclusion_of :cross_domain, in: [:true, :false], allow_nil: true
+			validates_inclusion_of :cache_locally, in: [:true, :false], allow_nil: true
 
 
-	def name
-		@name
-	end
-
-	def name= value
-		@name = value
-	end
 
-	def model
-		@model
-	end
-
-	def model= value
-		@model = value
-	end
-
-	def cross_domain
-		@cross_domain
-	end
 
-	def cross_domain= value
-		@cross_domain = value ? true : false
-	end
-
-
-	def list_url
-		@list_url
-	end
-
-	def list_url= value
-		@list_url = value
-	end
-
-	def entry_url
-		@entry_url
-	end
-
-	def entry_url= value
-		@entry_url = value
-	end
+			def initialize(options = {})
+				self.model = nil
+				self.cross_domain = :false
+				self.cache_locally = :false
+				self.url = nil
+				self.data_format = :json
+				self.label_property = :name
+				self.value_property = :id
+				self.type = :local
+				self.http_method = nil
 
-	def data_format
-		@data_format
-	end
-
-	def data_format= value
-		raise "Data Format ':#{value}' is not supported. Supported Data Formats are #{SUPPORTED_DATA_FORMATS.map{ |i| ":#{i}" }.join(", ")}" unless SUPPORTED_DATA_FORMATS.include?(value)
-		@data_format = value
-	end
-
-	def label_property
-		@label_property
-	end
-	def label_property= value
-		@label_property = value
-	end
-
-	def value_property
-		@value_property
-	end
-
-	def value_property= value
-		@value_property = value
-	end
+				super(options)
+			end
 
-	def cache_locally
-		@cache_locally
-	end
 
-	def cache_locally= value
-		@cache_locally = value ? true : false
-	end
-
-	def type
-		@type
-	end
+			attr_accessor :model
+			attr_accessor :cross_domain
+			attr_accessor :cache_locally
+			attr_accessor :url
+			attr_accessor :data_format
+			attr_accessor :label_property
+			attr_accessor :value_property
+			attr_accessor :type
+			attr_accessor :http_method
+
+			def to_external_hash(options = {})
+				options ||= {}
+				options.merge!({
+					               url: self.url,
+				                   data_format: self.data_format,
+				                   http_method: self.http_method,
+				                   label_property: self.label_property,
+				                   value_property: self.value_property
+				               })
+				super(options)
+			end
 
-	def type= value
-		raise "Datasource Type ':#{value}' is not supported. Supported Datasource Types are #{SUPPORTED_DATASOURCE_TYPES.map { |i| ":#{i}" }.join(", ")}" unless SUPPORTED_DATASOURCE_TYPES.include?(value)
-		@type = value
+			def is_internet_data_source?
+				self.type == :jquery || self.type == :jquery_db || self.type == :remote
+			end
+		end
 	end
-
-
 end