binda 0.0.7 → 0.1.0

data/app/models/binda/gallery.rb

@@ -2,8 +2,6 @@ module Binda
   class Gallery < ApplicationRecord
 
   	# Associations
-  	has_many :bindings
-  	has_many :assets, through: :bindings
   	belongs_to :fieldable, polymorphic: true
   	belongs_to :field_setting
 

data/app/models/binda/image.rb

@@ -0,0 +1,7 @@
+module Binda
+  class Image < Asset
+
+    mount_uploader :image, ImageUploader
+
+  end
+end

data/app/models/binda/relation.rb

@@ -0,0 +1,79 @@
+module Binda
+  # Relation 
+  # 
+  # This model is used to connect components and boards to each others.
+  # 
+  # `Relation` gathers all connection a `Component` record has with other records (being 
+  #   another `Component` or `Board`). It's possible to have multiple relations for the 
+  #   same component and each one can gather connections to several other components.
+  #   Any relation has one owner and several dependents. A relation is a one-direction operation
+  #   meaning that an owner can choose its dependents, not the other way around.
+  #   
+  # Reference: https://www.railstutorial.org/book/following_users
+  # 
+  # @example: owner = Binda::Component.first
+  #   dependent = Binda::Component.last
+  #   relation_setting = Binda::FieldSetting.create(field_type: relation, field_group_id: owner.structure.field_groups.first)
+  #   relation = owner.relations.where(field_setting_id: relation_setting.id).first
+  #   relation.dependent_components << dependent
+  class Relation < ApplicationRecord
+
+    belongs_to :fieldable, polymorphic: true
+    belongs_to :field_setting
+
+    # Relations are the connection between a Owner to its Dependents
+    # The Active Relation connects a Relation to a Dependent (which is can be a Component or a Board)
+    # The Passive Relation connects a Relation to a Owner (which is can be a Component or a Board)
+    has_many :dependent_relations, class_name: "RelationLink", 
+                                 dependent: :destroy, 
+                                 as: :owner
+
+
+    # Dependents are connected to a owner in a Passive Relation
+    # Strictly speaking you cannot choose an Owner for a Dependent,
+    # you can do just the opposite: choose a Dependent starting from a Owner
+    # 
+    # The current version support components and boards separately
+    has_many :dependent_components, through: :dependent_relations, 
+                                    source: :dependent, 
+                                    source_type: "Binda::Component"
+                                    
+
+    # Owner are connected to its Dependents in a Active Relation
+    # meaning its possible to connect a Owner to as many Dependents
+    # as it's needed.
+    # 
+    # The current version support components and boards separately
+    has_many :dependent_boards, through: :dependent_relations, 
+                                source: :dependent, 
+                                source_type: "Binda::Board"
+
+
+    # Owner are connected to its Dependents in a Active Relation
+    # meaning its possible to connect a Owner to as many Dependents
+    # as it's needed.
+    # 
+    # The current version support components and boards separately
+    has_many :dependent_repeaters, through: :dependent_relations, 
+                                source: :dependent, 
+                                source_type: "Binda::Repeater"
+
+
+    # Makes sure that the group of related components doesn't include the component that owns the group
+    # in other words makes sure that the component doesn't relate to itself
+    validates_each :dependent_component_ids do |model, attr, value| 
+      if model.fieldable_type == 'Binda::Component' && value.include?(model.fieldable_id)
+        model.errors.add(attr, "#{FieldSetting.find(model.field_setting_id).name.capitalize} contains a reference to the current #{model.fieldable_type.constantize.find(model.fieldable_id).structure.name.capitalize}")
+      end
+    end    
+
+    # Makes sure that the group of related components doesn't include the component that owns the group
+    # in other words makes sure that the component doesn't relate to itself
+    validates_each :dependent_board_ids do |model, attr, value| 
+      if model.fieldable_type == 'Binda::Board' && value.include?(model.fieldable_id)
+        model.errors.add(attr, "#{FieldSetting.find(model.field_setting_id).name.capitalize} contains a reference to the current #{model.fieldable_type.constantize.find(model.fieldable_id).structure.name.capitalize}")
+      end
+    end
+
+  end
+end

data/app/models/binda/relation_link.rb

@@ -0,0 +1,11 @@
+module Binda
+	class RelationLink < ApplicationRecord
+
+		belongs_to :owner, class_name: "Binda::Relation"
+		belongs_to :dependent, polymorphic: true
+
+		validates :owner_id, presence: true
+		validates :dependent_id, presence: true
+
+	end
+end

data/app/models/binda/repeater.rb

@@ -13,11 +13,11 @@ module Binda
 
     after_create :set_default_position
 
-
     # Set default position after create
     # 
     # This methods ensure that every repeater instance has an explicit position.
     #   The latest repeater created gets the highest position number.
+    #   The first position is 1 (not 0).
     # 
     # @return [object] Repeater instance
     def set_default_position

data/app/models/binda/selection.rb

@@ -4,14 +4,5 @@ module Binda
 		has_and_belongs_to_many :choices
 		belongs_to :field_setting
 
-		after_create :set_choice
-
-		# Set the default choice if the field must have at least one.
-		# This method run after the record is created.
-		def set_choice
-			return if self.field_setting.allow_null
-			self.choices << self.field_setting.default_choice if self.choices.empty?
-		end
-
 	end
 end

data/app/models/binda/structure.rb

@@ -2,10 +2,12 @@ module Binda
 	class Structure < ApplicationRecord
 
 		# Associations
-		has_many :components
-		has_one  :board
-		has_many :categories
-		has_many :field_groups
+		has_many :components, dependent: :destroy
+		has_one  :board, dependent: :destroy
+		has_many :categories, dependent: :destroy
+		has_many :field_groups, dependent: :destroy
+
+		has_and_belongs_to_many :field_settings
 
 		# Validations
 		validates :name, presence: true
@@ -19,15 +21,15 @@ module Binda
 
 		after_create :add_default_field_group
 		after_create :add_instance_details
-    after_create :set_default_position
+		after_create :set_default_position
 
 		# Friendly id preference on slug generation
 		#
 		# Method inherited from friendly id 
 		# @see https://github.com/norman/friendly_id/issues/436
-	  def should_generate_new_friendly_id?
-	    slug.blank? || name_changed?
-	  end
+		def should_generate_new_friendly_id?
+			slug.blank? || name_changed?
+		end
 
 		#
 		# Sets the validation rules to accept and save an attribute
@@ -51,39 +53,39 @@ module Binda
 		#   field group called 'General Details' after the structure is created.
 		# @return [redirect]
 		def add_default_field_group
-      # Creates a default empty field group 
-      field_group = self.field_groups.build( name: 'General Details', position: 1 )
-      # Unless there is a problem...
-      unless field_group.save
-        return redirect_to structure_path( self.slug ), flash: { error: 'General Details group hasn\'t been created' }
-      end
-    end
+			# Creates a default empty field group 
+			field_group = self.field_groups.build( name: 'General Details', position: 1 )
+			# Unless there is a problem...
+			unless field_group.save
+				return redirect_to structure_path( self.slug ), flash: { error: 'General Details group hasn\'t been created' }
+			end
+		end
 
-    # Add details based on instance type
-    # 
-    # If instance_type is set to 'setting' it generates a default Binda::Setting instance after creation. 
-    #   The generated instance will be associated to the structure and named after it.
-    #   It also disable categories (this could be a different method, or method could be more explicit)
-    def add_instance_details
-    	if self.instance_type == 'board'
-    		self.update_attribute 'has_categories', false
-	    	board = self.build_board( name: self.name )
-	      unless board.save
-	        return redirect_to structure_path( self.slug ), flash: { error: 'The board instance hasn\'t been created' }
-	      end
-	    end
-    end
+		# Add details based on instance type
+		# 
+		# If instance_type is set to 'setting' it generates a default Binda::Setting instance after creation. 
+		#   The generated instance will be associated to the structure and named after it.
+		#   It also disable categories (this could be a different method, or method could be more explicit)
+		def add_instance_details
+			if self.instance_type == 'board'
+				self.update_attribute 'has_categories', false
+				board = self.build_board( name: self.name )
+				unless board.save
+					return redirect_to structure_path( self.slug ), flash: { error: 'The board instance hasn\'t been created' }
+				end
+			end
+		end
 
-    # Set default position after create
-    # 
-    # This methods ensure that every repeater instance has an explicit position.
-    #   The latest repeater created gets the highest position number.
-    # 
-    # @return [object] Repeater instance
-    def set_default_position
-        position = Structure.all.length
-        self.update_attribute 'position', position
-    end
+		# Set default position after create
+		# 
+		# This methods ensure that every repeater instance has an explicit position.
+		#   The latest repeater created gets the highest position number.
+		# 
+		# @return [object] Repeater instance
+		def set_default_position
+				position = Structure.all.length
+				self.update_attribute 'position', position
+		end
 
 	end
 end

data/app/models/binda/video.rb

@@ -0,0 +1,7 @@
+module Binda
+	class Video < Asset
+
+    mount_uploader :video, VideoUploader
+
+	end
+end

data/app/models/concerns/binda/default_helpers.rb

@@ -0,0 +1,186 @@
+module Binda
+	# Binda comes with a bunch of helpers to make life easier.
+	module DefaultHelpers
+		extend ActiveSupport::Concern
+
+		included do 
+		end
+
+	  class_methods do
+
+			# Get components
+			# 
+			# This method retrieves **all components** belonging to a specific structure. 
+			#   See the following example.
+			#   
+			# @example Assuming you have two structures 'page' and 'post':
+			# 	B.get_components()
+			# 	# returns all components from all structures
+			# 	
+			# 	B.get_components(['page', 'post'])
+			# 	# returns pages and posts, i.e. all components belonging to 'page' and 'post' structures
+			# 
+			#   B.get_components('page')
+			#   # returns all pages
+			#   
+			#		B.get_components('page').find_by(slug: 'my-first-page')
+			#		# returns `my-first-page`
+			#   
+			#   # expand query
+			#   B.get_components('page').where(publish_state: 'published').order('position')
+			#   
+			#   # reduce N+1 query issue by including dependencies
+			#   B.get_components('page').includes(:strings, :texts, repeaters: [:images, :selections])
+			#   
+			# @param slug [string] The slug of the structure to which the components belong
+			# @param slug [array] The slugs of the structures to which the components belongs
+			#   
+			# @return [ActiveRelation Object] if slug is nil or is an array
+			# 
+			def get_components slug = nil
+				if slug.nil?
+					Component.all
+				else
+					# Generate query
+					Component.where( structure_id: Structure.where( slug: slug ) )
+				end
+			end
+
+			# Get boards
+			# 
+			# This method retrieves **boards**.
+			#   See the following example.
+			#   
+			# @example Assuming you have a `default-dashboard`
+			# 	B.get_boards()
+			# 	# returns all boards of all structures
+			# 
+			#   B.get_boards('default-dashboard').first
+			#   # returns the board
+			#   
+			#   # reduce N+1 query issue by including dependencies
+			#   B.get_boards('default-dashboard').includes(:strings, :texts, repeaters: [:images, :selections]).first
+			#   
+			# @param slug [string] The slug of the structure on which the board is based
+			# @param slug [array] The slugs of the structures to which the board belongs
+			#   
+			# @return [ActiveRelation Object] if slug is nil or is an array  
+			# 
+			def get_boards slug = nil
+				if slug.nil?
+					Board.all
+				else
+					Board.where( structure_id: Structure.where( slug: slug ) )
+				end
+			end
+
+			# Get categories
+			# 
+			# This method retrieves **categories**.
+			#   See the following example.
+			#   
+			# @example Assuming you have two structures 'page' and 'post':
+			# 	B.get_categories()
+			# 	# returns all categories belonging to all structures
+			# 
+			#   B.get_categories('page')
+			#   # returns all categories belonging to the 'page' structure
+			#   
+			#   B.get_categories(['page', 'post'])
+			#   # returns all categories belonging to 'page' structure and the ones belonging to 'post' structure
+			#   
+			# @param slug [string] The slug of the structure to which categories belong
+			# @param slug [array] The slugs of the structures to which categories belong
+			#   
+			# @return [ActiveRelation Object] 
+			# 
+			def get_categories slug = nil
+				if slug.nil?
+					Category.all
+				else
+					Category.where( structure_id: Structure.where( slug: slug ) )
+				end
+			end
+
+			# Get field settings
+			# 
+			# This method retrieves **field settings**.
+			#   See the following example.
+			# 	
+			# @example Assuming you have two field settings 'subtitle' and 'description':
+			# 	B.get_field_settings()
+			# 	# returns all field settings
+			# 	
+			# 	B.get_field_settings('subtitle')
+			# 	# returns an ActiveRelation (a sort of Array) containing the 'subtitle' field setting
+			# 	
+			# @param slug [string] The slug of a specific field setting
+			# @param slug [array] The slugs of the selected field settings
+			# 
+			# @return [ActiveRelation Object] 
+			# 
+			def get_field_settings slug = nil
+				if slug.nil?
+					FieldSetting.all
+				else
+					FieldSetting.where(slug: slug)
+				end
+			end
+
+			# Get each owner of all relations with the specified slug (or slugs)
+			#
+			# @param slug [string] The slug of the field setting to which the relations belong
+			# @param slug [array] The slugs of the field settings to which the relations belong
+			# 
+			# @return [Array] 
+			# 
+			def get_relation_owners field_slug
+				owner_class = Structure.includes(field_groups: :field_settings)
+					.where(binda_field_settings: {id: FieldSetting.where(slug: field_slug)})
+					.first
+				obj = "Binda::#{owner_class.instance_type.classify}".constantize
+					.distinct
+					.includes(relations: :dependent_components)
+					.where(binda_relations: {field_setting_id: FieldSetting.where(slug: field_slug)})
+				raise ArgumentError, "There isn't any instance with a relation associated to the current slug (#{field_slug}).", caller if obj.nil?
+				return obj
+			end
+
+
+			# Get each dependent of all relations with the specified slug (or slugs)
+			#
+			# This can be useful to retrieve only the instances which have a owner. For example, you have several 
+			#   'event' components, where each one is related to several 'artist' components with a 'partecipants' 
+			#   relation field where every event owns some artists. 
+			#   If you want to retrieve all artists which have been involved in at least one event you can try with
+			#   `B.get_relation_dependents('partecipants')`.
+			#   
+			# You can also ask for all instance type of dependent or specify 'components' or 'boards' using 
+			#   the second parameter.
+			#
+			# @param slug [string] The slug of the field setting to which the relations belong
+			# 
+			# @return [Array] 
+			# 
+			def get_relation_dependents field_slug, instance_type = nil
+				raise ArgumentError, "There isn't any instance named: #{instance_type}. Make sure is either 'component' or 'board'", caller if !instance_type.nil? && ['board','component'].include?(instance_type)
+				
+				dependents = []
+				if instance_type != 'board'
+					dependent_components = Component.distinct
+						.includes(:owner_components)
+						.where(binda_relations: {field_setting_id: FieldSetting.where(slug: field_slug)})
+					dependents = [ *dependents, *dependent_components ]
+				elsif instance_type != 'component'
+					dependent_boards = Board.distinct
+						.includes(:owner_components)
+						.where(binda_relations: {field_setting_id: FieldSetting.where(slug: field_slug)})
+					dependents = [ *dependents, *dependent_boards ]
+				end
+				
+				raise ArgumentError, "There isn't any instance with a relation associated to the current slug (#{field_slug}).", caller unless dependents.any?
+				return dependents
+			end
+	  end
+	end
+end

data/app/models/concerns/binda/fieldable_associations.rb

@@ -15,22 +15,74 @@ module Binda
 	    #   - get_fieldables (see here below)
 	    #   - get_field_types (see here below)
 	    #   - component_params (app/controllers/binda/components_controller.rb)
+
 	    has_many :texts,         as: :fieldable, dependent: :delete_all
 	    has_many :strings,       as: :fieldable, dependent: :delete_all
 	    has_many :dates,         as: :fieldable, dependent: :delete_all
 	    has_many :galleries,     as: :fieldable, dependent: :delete_all
 	    has_many :assets,        as: :fieldable, dependent: :delete_all
+	    has_many :images,        as: :fieldable, dependent: :delete_all
+	    has_many :videos,        as: :fieldable, dependent: :delete_all
 	    has_many :radios,        as: :fieldable, dependent: :delete_all 
 	    has_many :selections,    as: :fieldable, dependent: :delete_all 
 	    has_many :checkboxes,    as: :fieldable, dependent: :delete_all 
 	    # Repeaters need destroy_all, not delete_all
 	    has_many :repeaters,     as: :fieldable, dependent: :destroy
+			has_many :relations,     as: :fieldable, dependent: :destroy 
+
+
+    	has_many :owner_relations, class_name: "RelationLink", 
+                                dependent: :destroy, 
+                                as: :dependent
+
+	    # Owner are connected to its Dependents in a Active Relation
+	    # meaning its possible to connect a Owner to as many Dependents
+	    # as it's needed.
+	    # 
+	    # The current version support components and boards separately
+	    has_many :owner_components, through: :owner_relations, 
+	                                source: :owner
 
-			# has_many :bindings
-			# has_many :assets, class_name: 'Admin::Asset', through: :bindings
+	    has_many :owner_boards, through: :owner_relations, 
+	                            source: :owner
 
-	    accepts_nested_attributes_for :texts, :strings, :dates, :assets, :galleries, :repeaters, :radios, :selections, :checkboxes, allow_destroy: true
+	    has_many :owner_repeaters, through: :owner_relations, 
+	                            source: :owner 
 
+
+	    accepts_nested_attributes_for :texts, :strings, :dates, :assets, :images, :videos, :galleries, :repeaters, :radios, :selections, :checkboxes, :relations, allow_destroy: true
+
+			validates_associated :texts
+			validates_associated :strings
+			validates_associated :dates
+			validates_associated :assets
+			validates_associated :images
+			validates_associated :videos
+			validates_associated :repeaters
+			validates_associated :radios
+			validates_associated :selections
+			validates_associated :checkboxes
+			validates_associated :relations
+
+      after_save :generate_fields
+
+      # Uncomment these "validate do" loop to better debug validation.
+      # This makes method gather errors of the associated records and
+      # make them available to the instance object. After using this method 
+      # you will be able to see the actual error inside `instance.errors` array.
+      # Example: @component.errors #=> [ ... ]
+      # 
+		  # validate do |instance|
+		  #   instance.texts.each do |text|
+		  #   	binding.pry
+		  #     next if text.valid?
+		  #     text.errors.full_messages.each do |msg|
+		  #       # you can customize the error message here:
+		  #       errors[:base] << "Error in #{text.field_setting.name} (text): #{msg}"
+		  #     end
+		  #   end
+		  # end
+	
 		end
 
 		# Get the object related to that field setting
@@ -40,15 +92,15 @@ module Binda
 		# @return [string] Returns the content of the text 
 		# @return [error]  Raise an error if no record is found
 		def get_text field_slug 
-			obj = self.texts.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) && t.type = 'Binda::Text' }
+			obj = self.texts.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) && t.type != 'Binda::String' }	
 			unless obj.nil?
 				obj.content
 			else
 				you_mean_string = !self.strings.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) && t.type = 'Binda::String' }.nil?
 				if you_mean_string
-					raise ArgumentError, "This slug is associated to a string not a text. Use get_string() instead.", caller
+					raise ArgumentError, "This slug (#{field_slug}) is associated to a string not a text. Use get_string() instead on instance (#{self.class.name} ##{self.id}).", caller
 				else
-					raise ArgumentError, "There isn't any text associated to the current slug.", caller
+					raise ArgumentError, "There isn't any text associated to the current slug (#{field_slug}) on instance (#{self.class.name} ##{self.id}).", caller
 				end
 			end
 		end
@@ -58,7 +110,8 @@ module Binda
 		# @param field_slug [string] The slug of the field setting
 		# @return [boolean]
 		def has_text field_slug 
-			obj = self.texts.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) && t.type = 'Binda::Text' }
+			obj = self.texts.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) && t.type != 'Binda::String' }
+			raise ArgumentError, "There isn't any text associated to the current slug (#{field_slug}) on instance (#{self.class.name} ##{self.id}).", caller if obj.nil?
 			if obj.present?
 				return !obj.content.blank?
 			else
@@ -73,15 +126,15 @@ module Binda
 		# @return [string] Returns the content of the string 
 		# @return [error]  Raise an error if no record is found
 		def get_string field_slug 
-			obj = self.strings.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) && t.type = 'Binda::String' }
+			obj = self.strings.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) && t.type == 'Binda::String' }
 			unless obj.nil?
 				obj.content
 			else
 				you_mean_text = !self.strings.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) && t.type = 'Binda::Text' }.nil?
 				if you_mean_text
-					raise ArgumentError, "This slug is associated to a text not a string. Use get_text() instead.", caller
+					raise ArgumentError, "This slug (#{field_slug}) is associated to a text not a string. Use get_text() instead on instance (#{self.class.name} ##{self.id}).", caller
 				else
-					raise ArgumentError, "There isn't any string associated to the current slug.", caller
+					raise ArgumentError, "There isn't any string associated to the current slug (#{field_slug}) on instance (#{self.class.name} ##{self.id}).", caller
 				end
 			end
 		end
@@ -91,7 +144,8 @@ module Binda
 		# @param field_slug [string] The slug of the field setting
 		# @return [boolean]
 		def has_string field_slug 
-			obj = self.strings.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) && t.type = 'Binda::String' }
+			obj = self.strings.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) && t.type == 'Binda::String' }
+			raise ArgumentError, "There isn't any string associated to the current slug (#{field_slug}) on instance (#{self.class.name} ##{self.id}).", caller if obj.nil?
 			if obj.present?
 				return !obj.content.blank?
 			else
@@ -104,8 +158,11 @@ module Binda
 		# @param field_slug [string] The slug of the field setting
 		# @return [boolean]
 		def has_image field_slug 
-			obj = self.assets.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) }.image
-			return obj.present?
+			obj = self.images.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) }
+			# Alternative query
+			# obj = Image.where(field_setting_id: FieldSetting.get_id( field_slug ), fieldable_id: self.id, fieldable_type: self.class.to_s ).first
+			raise ArgumentError, "There isn't any image associated to the current slug (#{field_slug}) on instance (#{self.class.name} ##{self.id}).", caller if obj.nil?
+			return obj.image.present?
 		end
 
 		# Get the image url based on the size provided, 
@@ -139,7 +196,23 @@ module Binda
 		# @return [string] The info requested if present
 		# @return [boolean] Returns false if no info is found or if image isn't found
 		def get_image_info field_slug, size, info 
-			obj = self.assets.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) }
+			obj = self.images.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) }
+			# Alternative query
+			# obj = Image.where(field_setting_id: FieldSetting.get_id( field_slug ), fieldable_id: self.id, fieldable_type: self.class.to_s ).first
+			raise ArgumentError, "There isn't any image associated to the current slug (#{field_slug}) on instance (#{self.class.name} ##{self.id}).", caller if obj.nil?
+			if obj.image.present?
+				if obj.image.respond_to?(size) && %w[thumb medium large].include?(size)
+					obj.image.send(size).send(info)
+				else
+					obj.image.send(info)
+				end
+			end
+		end
+
+		def get_image_dimension field_slug
+			obj = self.images.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) }
+
+			raise ArgumentError, "There isn't any image associated to  the current slug (#{field_slug}) on instance (#{self.class.name} ##{self.id}).", caller if obj.nil?
 			if obj.image.present?
 				if obj.image.respond_to?(size) && %w[thumb medium large].include?(size)
 					obj.image.send(size).send(info)
@@ -149,6 +222,56 @@ module Binda
 			end
 		end
 
+		# Check if the field has an attached video
+		# 
+		# @param field_slug [string] The slug of the field setting
+		# @return [boolean]
+		def has_video field_slug 
+			obj = self.videos.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) }
+			# Alternative query
+			# obj = Image.where(field_setting_id: FieldSetting.get_id( field_slug ), fieldable_id: self.id, fieldable_type: self.class.to_s ).first
+			raise ArgumentError, "There isn't any video associated to the current slug (#{field_slug}) on instance (#{self.class.name} ##{self.id}).", caller if obj.nil?
+			return obj.video.present?
+		end
+
+		# Get the video url based on the size provided, 
+		#   default is Carrierwave default (usually the real size)
+		# 
+		# @param field_slug [string] The slug of the field setting
+		# @param size [string] The size. It can be 'thumb' 200x200 cropped, 
+		#   'medium' 700x700 max size, 'large' 1400x1400 max size, or blank
+		# @return [string] The url of the video
+		def get_video_url field_slug
+			get_video_info( field_slug, 'url' )
+		end
+
+		# Get the video path based on the size provided, 
+		#   default is Carrierwave default (usually the real size)
+		# 
+		# @param field_slug [string] The slug of the field setting
+		# @param size [string] The size. It can be 'thumb' 200x200 cropped, 
+		#   'medium' 700x700 max size, 'large' 1400x1400 max size, or blank
+		# @return [string] The url of the video
+		def get_video_path field_slug
+			get_video_info( field_slug, 'path' )
+		end
+
+		# Get the object related to that field setting
+		# 
+		# @param field_slug [string] The slug of the field setting
+		# @param info [string] String of the info to be retrieved
+		# @return [string] The info requested if present
+		# @return [boolean] Returns false if no info is found or if image isn't found
+		def get_video_info field_slug, info 
+			obj = self.videos.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) }
+			# Alternative query
+			# obj = video.where(field_setting_id: FieldSetting.get_id( field_slug ), fieldable_id: self.id, fieldable_type: self.class.to_s ).first
+			raise ArgumentError, "There isn't any video associated to the current slug (#{field_slug}) on instance (#{self.class.name} ##{self.id}).", caller if obj.nil?
+			if obj.video.present?
+				obj.video.send(info)
+			end
+		end
+
 		# Check if the field has an attached date
 		# 
 		# @param field_slug [string] The slug of the field setting
@@ -156,6 +279,7 @@ module Binda
 		# @return [boolean] Reutrn false if nothing is found
 		def has_date field_slug 
 			obj = self.dates.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) }
+			raise ArgumentError, "There isn't any date associated to the current slug (#{field_slug}) on instance (#{self.class.name} ##{self.id}).", caller if obj.nil?
 			if obj.present?
 				return !obj.date.nil?
 			else
@@ -169,7 +293,8 @@ module Binda
 		# @return [boolean]
 		def get_date field_slug 
 			obj = self.dates.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) }
-			obj.date unless obj.nil?
+			raise ArgumentError, "There isn't any date associated to the current slug (#{field_slug}) on instance (#{self.class.name} ##{self.id}).", caller if obj.nil?
+			obj.date
 		end
 
 		# Check if exists any repeater with that slug
@@ -178,6 +303,7 @@ module Binda
 		# @return [boolean]
 		def has_repeater field_slug 
 			obj = self.repeaters.find_all{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) }
+			raise ArgumentError, "There isn't any repeater associated to the current slug (#{field_slug}) on instance (#{self.class.name} ##{self.id}).", caller if obj.nil?
 			return obj.present?
 		end
 
@@ -187,7 +313,8 @@ module Binda
 		# @return [hash]
 		def get_repeater field_slug 
 			obj = self.repeaters.find_all{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) }
-			obj.sort_by(&:position) unless obj.nil?
+			raise ArgumentError, "There isn't any repeater associated to the current slug (#{field_slug}) on instance (#{self.class.name} ##{self.id}).", caller if obj.nil?
+			obj.sort_by(&:position)
 		end
 
 		# Get the radio choice
@@ -196,46 +323,165 @@ module Binda
 		#   only the first one will be retrieved.
 		# 
 		# @param field_slug [string] The slug of the field setting
-		# @return [hash] A hash of containing the label and value of the selected choice.
+		# @return [hash] A hash of containing the label and value of the selected choice. `{ label: 'the label', value: 'the value'}`
 		def get_radio_choice field_slug
-			obj = self.radios.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) }
+			field_setting = FieldSetting.find_by(slug:field_slug)
+			obj = self.radios.find{ |t| t.field_setting_id == field_setting.id }
+			raise ArgumentError, "There isn't any radio associated to the current slug (#{field_slug}) on instance (#{self.class.name} ##{self.id}).", caller if obj.nil?
+			raise "There isn't any choice available for the current radio (#{field_slug}) on instance (#{self.class.name} ##{self.id})." unless field_setting.choices.any?
 			return { label: obj.choices.first.label, value: obj.choices.first.value }
 		end
 
 		# Get the select choices
 		# 
 		# @param field_slug [string] The slug of the field setting
-		# @return [hash] A hash of containing the label and value of the selected choice.
+		# @return [hash] A hash of containing the label and value of the selected choice. `{ label: 'the label', 'value': 'the value'}`
 		def get_selection_choice field_slug
-			# select cannot be chosen has variable name, therefore is prefixed with 's'
-			obj = self.selections.find{ |t| t.field_setting_id = FieldSetting.get_id( field_slug ) }
+			field_setting = FieldSetting.find_by(slug:field_slug)
+			obj = self.selections.find{ |t| t.field_setting_id == field_setting.id }
+			raise ArgumentError, "There isn't any radio associated to the current slug (#{field_slug}) on instance (#{self.class.name} ##{self.id}).", caller if obj.nil?
+			raise "There isn't any choice available for the current radio (#{field_slug}) on instance (#{self.class.name} ##{self.id})." unless field_setting.choices.any?
 			return { label: obj.choices.first.label, value: obj.choices.first.value }
 		end
 
 		# Get the checkbox choice
 		# 
 		# @param field_slug [string] The slug of the field setting
-		# @return [hash] A hash of labels and values of the selected choices.
+		# @return [array] An array of labels and values of the selected choices. `[{ label: '1st label', value: '1st-value'}, { label: '2nd label', value: '2nd-value'}]`
 		def get_checkbox_choices field_slug
-			obj = self.checkboxes.find{ |t| t.field_setting_id = FieldSetting.get_id( field_slug ) }
-			obj_hash = {}
+			field_setting = FieldSetting.find_by(slug:field_slug)
+			obj = self.checkboxes.find{ |t| t.field_setting_id == field_setting.id }
+			raise ArgumentError, "There isn't any checkbox associated to the current slug (#{field_slug}) on instance (#{self.class.name} ##{self.id}).", caller if obj.nil?
+			raise "There isn't any choice available for the current radio (#{field_slug}) on instance (#{self.class.name} ##{self.id})." unless field_setting.choices.any?
+			obj_array = []
 			obj.choices.order('label').each do |o|
-				obj_hash << { label: obj.choices.first.label, value: obj.choices.first.value }
+				obj_array << { label: o.label, value: o.value }
 			end
-			return obj_hash
+			return obj_array
+		end
+
+		# Check if has related components
+		# 
+		# @param field_slug [string] The slug of the field setting
+		# @return [boolean]
+		def has_related_components field_slug
+			obj = self.relations.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) }
+			raise ArgumentError, "There isn't any related field associated to the current slug (#{field_slug}) on instance (#{self.class.name} ##{self.id}).", caller if obj.nil?
+			return obj.dependent_relations.any?
+		end
+
+		# Alias for has_related_components
+		def has_dependent_components field_slug
+			has_related_components field_slug
+		end
+
+		# Get related components
+		# 
+		# @param field_slug [string] The slug of the field setting
+		# @return [array] An array of components
+		def get_related_components field_slug
+			obj = self.relations.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) }
+			raise ArgumentError, "There isn't any related field associated to the current slug (#{field_slug}) on instance (#{self.class.name} ##{self.id}).", caller if obj.nil?
+			return obj.dependent_relations.map{|relation| relation.dependent}
+		end
+
+		# Alias for get_related_components
+		def get_dependent_components field_slug
+			get_related_components field_slug
+		end
+
+		# Get all components which owns a relation where the current instance is a dependent
+		# 
+		# @param field_slug [string] The slug of the field setting of the relation
+		# @return [array] An array of components and/or boards
+		def get_owner_components field_slug
+			# obj = self.owner_relations.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) }
+			obj = Relation.where(field_setting_id: B.get_field_settings(field_slug)).includes(dependent_relations: :dependent).where(binda_relation_links: {dependent_type: self.class.name})
+			raise ArgumentError, "There isn't any relation associated to the current slug (#{field_slug}) where the current instance (#{self.class.name} ##{self.id}) is a dependent.", caller if obj.nil?
+			return obj
+		end
+
+		# Check if has related boards
+		# 
+		# @param field_slug [string] The slug of the field setting
+		# @return [boolean]
+		def has_related_boards field_slug
+			obj = self.relations.find{ |t| t.field_setting_id == FieldSetting.get_id( field_slug ) }
+			raise ArgumentError, "There isn't any related field associated to the current slug (#{field_slug}) on instance (#{self.class.name} ##{self.id}).", caller if obj.nil?
+			return obj.dependent_relations.any?
+		end
+
+		# Get related boards
+		# 
+		# @param field_slug [string] The slug of the field setting
+		# @return [array] An array of boards
+		def get_related_boards field_slug
+			obj = self.relations.find{ |t| t.field_setting_idid == FieldSetting.get_id( field_slug ) }
+			raise ArgumentError, "There isn't any related field associated to the current slug (#{field_slug}) on instance (#{self.class.name} ##{self.id}).", caller if obj.nil?
+			return obj.dependent_relations.map{|relation| relation.dependent}
 		end
 
 		# Find or create a field by field setting and field type
-		# This is used in Binda's form
+		# 
+		# This is used in Binda's editor views.
+		#   
+		# Please, check the code to know more about the way this method works as it's pretty complex yet important.
 		# 
 		# @param field_setting_id [string] The field setting id
 		# @param field_type [string] THe field type
 		def find_or_create_a_field_by field_setting_id, field_type
-			if FieldSetting.get_field_classes.include?( field_type.capitalize ) && field_setting_id.is_a?( Integer )
-				self.send( field_type.pluralize ).find_or_create_by( field_setting_id: field_setting_id )
+			if FieldSetting.get_field_classes.include?( field_type.classify ) && field_setting_id.is_a?( Integer )
+				# It's mandatory to use `select{}.first`!!! 
+				# If you use any ActiveRecord method (like `where` of `find`) the validation errors are wiped out 
+				# from the object and not rendered next to the form in the editor view
+				obj = self.send( field_type.pluralize ).select{|rf| rf.field_setting_id == field_setting_id}.first
+				if obj.nil?
+					# As we are using the `select{}.first` method, asynchronous requests passing through 
+					# this method will create some inconsistentcy between this `self` object and the real object. 
+					# In other words `self` should be reloaded, but we won't reload it otherwise we will 
+					# erase the errors shipped with it initially. Therefore we will check again with `find_or_create_by!`.
+					# This leads to another issue, which is: errors coming from asynchronous requests won't be considered
+					# as the `self` object is the initial one, not the "updated" one. At the current time this is not
+					# a problem because the only asynchronous requests are for brand new records which don't need validation.
+					return self.send( field_type.pluralize ).find_or_create_by!( field_setting_id: field_setting_id ) 
+				else
+					return obj
+				end
 			else
-				raise ArgumentError, "One parameter in find_or_create_a_field_by() is not correct.", caller
+				raise ArgumentError, "One parameter in find_or_create_a_field_by() is not correct on instance (#{self.class.name} ##{self.id}).", caller
 			end
 		end
+
+    # This method is called upon the creation/update of a fieldable record (component, board or repeater) 
+    #   and generates all fields related to each field settings which belongs to it.
+    # 
+    # This avoids any situation in which, for example, a component have a field setting for a text
+    #   but there is no text (meaning `Binda::Text` instance) that correspond to that field setting.
+    #   This causes issues when looping a bunch of components which will thow a error if you try to access
+    #   a component field, as some might have it some might not. This make sure that you can always expect 
+    #   to find a field instance which might be empty, but certainly it exists.
+    #   
+    # TODO check if find_or_create_a_field_by method should be used instead (it's used in editors views)
+    # 
+    def generate_fields
+  		# If this is a component or a board
+    	if self.respond_to?('structure')
+	    	field_settings = FieldSetting.where(field_group_id: FieldGroup.where(structure_id: self.structure.id))
+	    	field_settings.each do |field_setting|
+	    		"Binda::#{field_setting.field_type.classify}".constantize.find_or_create_by!(
+	    			fieldable_id: self.id, fieldable_type: self.class.name, field_setting_id: field_setting.id )
+	    	end
+    	# If this is a repeater
+    	else
+    		self.field_setting.children.each do |field_setting|
+	    		"Binda::#{field_setting.field_type.classify}".constantize.find_or_create_by!(
+	    			fieldable_id: self.id, fieldable_type: self.class.name, field_setting_id: field_setting.id )
+    		end
+	    end
+    end
+
+		# TODO: Update all helpers replacing `find` method with ruby `select`. 
+		# This should improve performance avoiding generating useless ActiveRecord objects.
+
 	end
 end