cm-admin 0.3.0 → 0.4.3

data/lib/cm_admin/model.rb

@@ -1,19 +1,27 @@
 require_relative 'constants'
 require_relative 'models/action'
+require_relative 'models/custom_action'
 require_relative 'models/field'
+require_relative 'models/form_field'
 require_relative 'models/blocks'
 require_relative 'models/column'
 require_relative 'models/filter'
 require_relative 'models/export'
+require_relative 'models/cm_show_section'
+require_relative 'models/tab'
+require_relative 'models/dsl_method'
+require_relative 'models/controller_method'
 require 'pagy'
 require 'axlsx'
-
+require 'cocoon'
 
 module CmAdmin
   class Model
     include Pagy::Backend
     include Models::Blocks
-    attr_accessor :available_actions, :actions_set, :available_fields, :permitted_fields, :current_action, :params, :filters
+    include Models::DslMethod
+    include Models::ControllerMethod
+    attr_accessor :available_actions, :actions_set, :available_fields, :permitted_fields, :current_action, :params, :filters, :available_tabs
     attr_reader :name, :ar_model
 
     # Class variable for storing all actions
@@ -25,7 +33,8 @@ module CmAdmin
       @ar_model = entity
       @available_actions ||= []
       @current_action = nil
-      @available_fields ||= {index: [], show: [], edit: [], new: []}
+      @available_tabs ||= []
+      @available_fields ||= {index: [], show: [], edit: {fields: []}, new: {fields: []}}
       @params = nil
       @filters ||= []
       instance_eval(&block) if block_given?
@@ -39,6 +48,29 @@ module CmAdmin
       def all_actions
         @all_actions || []
       end
+
+      def find_by(search_hash)
+        CmAdmin.cm_admin_models.find { |x| x.name == search_hash[:name] }
+      end
+    end
+
+    def custom_controller_action(action_name, params)
+      current_action = CmAdmin::Models::Action.find_by(self, name: action_name.to_s)
+      if current_action
+        @current_action = current_action
+        @ar_object = @ar_model.find(params[:id])
+        if @current_action.child_records
+          child_records = @ar_object.send(@current_action.child_records)
+          @associated_model = CmAdmin::Model.find_by(name: @ar_model.reflect_on_association(@current_action.child_records).klass.name)
+          if child_records.is_a? ActiveRecord::Relation
+            @associated_ar_object = filter_by(params, child_records)
+          else
+            @associated_ar_object = child_records
+          end
+          return @ar_object, @associated_model, @associated_ar_object
+        end
+        return @ar_object
+      end
     end
 
     # Insert into actions according to config block
@@ -53,166 +85,7 @@ module CmAdmin
       @actions_set = true
     end
 
-    def cm_show(&block)
-      @current_action = CmAdmin::Models::Action.find_by(self, name: 'show')
-      puts "Top of the line"
-      yield
-      # action.instance_eval(&block)
-      puts "End of the line"
-    end
-
-    def cm_index(&block)
-      @current_action = CmAdmin::Models::Action.find_by(self, name: 'index')
-      yield
-      # action.instance_eval(&block)
-    end
-
-    def cm_edit(&block)
-      action = CmAdmin::Models::Action.find_by(self, name: 'edit')
-      action.instance_eval(&block)
-    end
-
-    def show(params)
-      @current_action = CmAdmin::Models::Action.find_by(self, name: 'show')
-      @ar_object = @ar_model.find(params[:id])
-    end
-
-    def index(params)
-      @current_action = CmAdmin::Models::Action.find_by(self, name: 'index')
-      # Based on the params the filter and pagination object to be set
-      @ar_object = filter_by(params, filter_params=filter_params(params))
-    end
-
-    def filter_by(params, filter_params={}, sort_params={})
-      filtered_result = OpenStruct.new
-      sort_column = "users.created_at"
-      sort_direction = %w[asc desc].include?(sort_params[:sort_direction]) ? sort_params[:sort_direction] : "asc"
-      sort_params = {sort_column: sort_column, sort_direction: sort_direction}
-      final_data = filtered_data(filter_params)
-      pagy, records = pagy(final_data)
-      filtered_result.data = records
-      filtered_result.pagy = pagy
-      # filtered_result.facets = paginate(page, raw_data.size)
-      # filtered_result.sort = sort_params
-      # filtered_result.facets.sort = sort_params
-      return filtered_result
-    end
-
-    def filtered_data(filter_params)
-      records = self.name.constantize.where(nil)
-      if filter_params
-        filter_params.each do |scope, scope_value|
-          records = self.send("cm_#{scope}", scope_value, records)
-        end
-      end
-      records
-    end
-
-    def cm_search(scope_value, records)
-      return nil if scope_value.blank?
-      table_name = records.table_name
-
-      @filters.select{|x| x if x.filter_type.eql?(:search)}.each do |filter|
-        terms = scope_value.downcase.split(/\s+/)
-        terms = terms.map { |e|
-          (e.gsub('*', '%').prepend('%') + '%').gsub(/%+/, '%')
-        }
-        sql = ""
-        filter.db_column_name.each.with_index do |column, i|
-          sql.concat("#{table_name}.#{column} ILIKE ?")
-          sql.concat(' OR ') unless filter.db_column_name.size.eql?(i+1)
-        end
-
-        records = records.where(
-          terms.map { |term|
-            sql
-          }.join(' AND '),
-          *terms.map { |e| [e] * filter.db_column_name.size }.flatten
-        )
-      end
-      records
-    end
-
-    def new(params)
-      @ar_object = @ar_model.new
-    end
-
-    def edit(params)
-      @ar_object = @ar_model.find(params[:id])
-    end
-
-    def update(params)
-      @ar_object = @ar_model.find(params[:id])
-      @ar_object.update(resource_params(params))
-    end
-
-    def create(params)
-      @ar_object = @ar_model.new(resource_params(params))
-    end
-
-    def resource_params(params)
-      permittable_fields = @permitted_fields || @ar_model.columns.map(&:name).reject { |i| CmAdmin::REJECTABLE_FIELDS.include?(i) }.map(&:to_sym)
-      params.require(self.name.underscore.to_sym).permit(*permittable_fields)
-    end
-
-    def page_title(title)
-      if @current_action
-        @current_action.page_title = title
-      end
-    end
-
-    def page_description(description)
-      if @current_action
-        @current_action.page_description = description
-      end
-    end
-
-    def field(field_name, options={})
-      puts "For printing field #{field_name}"
-      @available_fields[:show] << CmAdmin::Models::Field.new(field_name, options)
-    end
-
-    def column(field_name, options={})
-      unless @available_fields[:index].map{|x| x.db_column_name.to_sym}.include?(field_name)
-        puts "For printing column #{field_name}"
-        @available_fields[:index] << CmAdmin::Models::Column.new(field_name, options)
-      end
-    end
-
-    def all_db_columns(options={})
-      field_names = self.instance_variable_get(:@ar_model)&.columns&.map{|x| x.name.to_sym}
-      if options.include?(:exclude) && field_names
-        excluded_fields = (Array.new << options[:exclude]).flatten.map(&:to_sym)
-        field_names -= excluded_fields
-      end
-      field_names.each do |field_name|
-        column field_name
-      end
-    end
-
-    def self.find_by(search_hash)
-      CmAdmin.cm_admin_models.find { |x| x.name == search_hash[:name] }
-    end
 
-    # Custom actions
-    # eg
-    # class User < ApplicationRecord
-    #   cm_admin do
-    #     custom_action name: 'submit', verb: 'post', path: ':id/submit' do
-    #       def user_submit
-    #         Code for action here...
-    #       end
-    #     end
-    #   end
-    # end
-    def custom_action(name: nil, verb: nil, layout: nil, partial: nil, path: nil, &block)
-      @available_actions << CmAdmin::Models::Action.new(name: name, verb: verb, layout: layout, partial: partial, path: path)
-      self.class.class_eval(&block)
-    end
-
-    def filter(db_column_name, filter_type, options={})
-      @filters << CmAdmin::Models::Filter.new(db_column_name: db_column_name, filter_type: filter_type, options: options)
-    end
     private
 
     # Controller defined for each model
@@ -227,7 +100,19 @@ module CmAdmin
             @model = CmAdmin::Model.find_by(name: controller_name.classify)
             @model.params = params
             @action = CmAdmin::Models::Action.find_by(@model, name: action_name)
-            @ar_object = @model.send(action_name, params)
+            @ar_object = @model.try(@action.parent || action_name, params)
+            @ar_object, @associated_model, @associated_ar_object = @model.custom_controller_action(action_name, params.permit!) if !@ar_object.present? && params[:id].present?
+            nested_tables = @model.available_fields[:new].except(:fields).keys
+            nested_tables += @model.available_fields[:edit].except(:fields).keys
+            @reflections = @model.ar_model.reflect_on_all_associations
+            nested_tables.each do |table_name|
+              reflection = @reflections.select {|x| x if x.name == table_name}.first
+              if reflection.macro == :has_many
+                @ar_object.send(table_name).build if action_name == "new" || action_name == "edit"
+              else
+                @ar_object.send(('build_' + table_name.to_s).to_sym) if action_name == "new"
+              end
+            end
             respond_to do |format|
               if %w(show index new edit).include?(action_name)
                 if request.xhr? && action_name.eql?('index')
@@ -241,11 +126,19 @@ module CmAdmin
                 else
                   format.html { render '/cm_admin/main/new' }
                 end
+              elsif action.class == CmAdmin::Models::CustomAction
+                redirect_url = request.referrer || "/cm_admin/#{@model.ar_model.table_name}/#{@ar_object.id}"
+                data = @action.parent == "index" ? @ar_object.data : @ar_object
+                if @action.code_block.call(@ar_object)
+                  format.html { redirect_to redirect_url }
+                else
+                  format.html { redirect_to redirect_url }
+                end
               elsif action.layout.present?
-                if action.partial.present?
-                  render partial: action.partial, layout: action.layout
+                if request.xhr? && action.partial.present?
+                  format.html { render partial: action.partial }
                 else
-                  render layout: action.layout
+                  format.html { render action.layout }
                 end
               end
             end
@@ -256,7 +149,13 @@ module CmAdmin
     end
 
     def filter_params(params)
-      params.require(:filters).permit(:search) if params[:filters]
+      # OPTIMIZE: Need to check if we can permit the filter_params in a better way
+      date_columns = @filters.select{|x| x.filter_type.eql?(:date)}.map(&:db_column_name)
+      range_columns = @filters.select{|x| x.filter_type.eql?(:range)}.map(&:db_column_name)
+      single_select_columns = @filters.select{|x| x.filter_type.eql?(:single_select)}.map(&:db_column_name)
+      multi_select_columns = @filters.select{|x| x.filter_type.eql?(:multi_select)}.map{|x| Hash["#{x.db_column_name}", []]}
+
+      params.require(:filters).permit(:search, date: date_columns, range: range_columns, single_select: single_select_columns, multi_select: multi_select_columns) if params[:filters]
     end
   end
 end

data/lib/cm_admin/models/action.rb

@@ -4,12 +4,28 @@ module CmAdmin
   module Models
     class Action
       include Actions::Blocks
-      attr_accessor :name, :verb, :layout, :partial, :path, :page_title, :page_description
+      attr_accessor :name, :verb, :layout_type, :layout, :partial, :path, :page_title, :page_description, :child_records, :is_nested_field, :nested_table_name, :parent, :display_if, :route_type, :code_block
 
-      def initialize(attributes = {})
+      def initialize(attributes = {}, &block)
+        if attributes[:layout_type].present? && attributes[:layout].nil? && attributes[:partial].nil?
+          case attributes[:layout_type]
+          when 'cm_association_index'
+            attributes[:layout] = '/cm_admin/main/associated_index'
+            attributes[:partial] = '/cm_admin/main/associated_table'
+          when 'cm_association_show'
+            attributes[:layout] = '/cm_admin/main/associated_show'
+          end
+        end
+        set_default_values
         attributes.each do |key, value|
           self.send("#{key.to_s}=", value)
         end
+        self.send("code_block=", block) if block_given?
+      end
+
+      def set_default_values
+        self.is_nested_field = false
+        self.display_if = true
       end
 
       class << self

data/lib/cm_admin/models/cm_show_section.rb

@@ -0,0 +1,20 @@
+module CmAdmin
+  module Models
+    class CmShowSection
+
+      attr_accessor :section_name, :available_section_fields
+
+      def initialize(section_name, &block)
+        @available_section_fields = []
+        @section_name = section_name
+        puts "-- reached here --"
+        instance_eval(&block)
+      end
+
+      def field(field_name, options={})
+        puts "For printing field #{field_name}"
+        @available_section_fields << CmAdmin::Models::Field.new(field_name, options)
+      end
+    end
+  end
+end

data/lib/cm_admin/models/column.rb

@@ -1,14 +1,59 @@
 module CmAdmin
   module Models
     class Column
-      attr_accessor :db_column_name, :column_type, :header, :format, :prefix, :exportable
+      attr_accessor :field_name, :field_type, :header, :format, :prefix, :suffix, :exportable, :round,
+      :cm_css_class, :link, :url, :custom_method, :helper_method, :managable, :lockable
 
-      def initialize(db_column_name, attributes = {})
-        @db_column_name = db_column_name
+      def initialize(field_name, attributes = {})
+        @field_name = field_name
+        set_default_values
         attributes.each do |key, value|
           self.send("#{key.to_s}=", value)
         end
-        @exportable = true if attributes[:exportable].nil?
+
+        #formatting header (either field_name or value present in header attribute)
+        self.send("header=", format_header)
+      end
+
+      #returns a string value as a header (either field_name or value present in header attribute)
+      def format_header
+        self.header.present? ? self.header.to_s.gsub(/_/, ' ')&.upcase : self.field_name.to_s.gsub(/_/, ' ').upcase
+      end
+
+      def set_default_values
+        self.exportable = true
+        self.managable = true
+        self.lockable = false
+      end
+
+      #formatting value for different data types
+      def self.format_data_type(column, value)
+        case column.column_type
+        when :string
+          if column.format.present?
+            column.format = [column.format] if column.format.is_a? String
+            column.format.each do |formatter|
+              value = value.send(formatter)
+            end
+          end
+        when :datetime
+          format_value = column.format.present? ? column.format.to_s : '%d/%m/%Y'
+          value = value.strftime(format_value)
+        when :enum
+          value = value.titleize
+        when :decimal
+          round_to = column.round.present? ? column.round.to_i : 2
+          value = value.round(round_to)
+        when :custom
+
+        end
+        return value
+      end
+
+      class << self
+        def find_by(model, search_hash)
+          model.available_fields.find { |i| i.name == search_hash[:name] }
+        end
       end
 
     end

data/lib/cm_admin/models/controller_method.rb

@@ -0,0 +1,76 @@
+module CmAdmin
+  module Models
+    module ControllerMethod
+      extend ActiveSupport::Concern
+
+      def show(params)
+        @current_action = CmAdmin::Models::Action.find_by(self, name: 'show')
+        @ar_object = @ar_model.find(params[:id])
+      end
+  
+      def index(params)
+        @current_action = CmAdmin::Models::Action.find_by(self, name: 'index')
+        # Based on the params the filter and pagination object to be set
+        @ar_object = filter_by(params, nil, filter_params(params))
+      end
+  
+      def new(params)
+        @current_action = CmAdmin::Models::Action.find_by(self, name: 'new')
+        @ar_object = @ar_model.new
+      end
+  
+      def edit(params)
+        @current_action = CmAdmin::Models::Action.find_by(self, name: 'edit')
+        @ar_object = @ar_model.find(params[:id])
+      end
+  
+      def update(params)
+        @ar_object = @ar_model.find(params[:id])
+        @ar_object.assign_attributes(resource_params(params))
+        @ar_object
+      end
+
+
+      def create(params)
+        @ar_object = @ar_model.new(resource_params(params))
+      end
+
+      def filter_by(params, records, filter_params={}, sort_params={})
+        filtered_result = OpenStruct.new
+        sort_column = "created_at"
+        sort_direction = %w[asc desc].include?(sort_params[:sort_direction]) ? sort_params[:sort_direction] : "asc"
+        sort_params = {sort_column: sort_column, sort_direction: sort_direction}
+        records = self.name.constantize.where(nil) if records.nil?
+        final_data = CmAdmin::Models::Filter.filtered_data(filter_params, records, @filters)
+        pagy, records = pagy(final_data)
+        filtered_result.data = records
+        filtered_result.pagy = pagy
+        # filtered_result.facets = paginate(page, raw_data.size)
+        # filtered_result.sort = sort_params
+        # filtered_result.facets.sort = sort_params
+        return filtered_result
+      end
+  
+      def resource_params(params)
+        permittable_fields = @permitted_fields || @ar_model.columns.map(&:name).reject { |i| CmAdmin::REJECTABLE_FIELDS.include?(i) }.map(&:to_sym)
+        permittable_fields += @ar_model.reflect_on_all_attachments.map {|x|
+          if x.class.name.include?('HasOne')
+            x.name
+          elsif x.class.name.include?('HasMany')
+            Hash[x.name.to_s, []]
+          end
+        }.compact
+        nested_tables = self.available_fields[:new].except(:fields).keys
+        nested_tables += self.available_fields[:edit].except(:fields).keys
+        nested_fields = nested_tables.map {|table|
+          Hash[
+            table.to_s + '_attributes',
+            table.to_s.singularize.titleize.constantize.columns.map(&:name).reject { |i| CmAdmin::REJECTABLE_FIELDS.include?(i) }.map(&:to_sym) + [:id, :_destroy]
+          ]
+        }
+        permittable_fields += nested_fields
+        params.require(self.name.underscore.to_sym).permit(*permittable_fields)
+      end
+    end
+  end
+end

data/lib/cm_admin/models/custom_action.rb

@@ -0,0 +1,13 @@
+require_relative 'actions/blocks'
+
+module CmAdmin
+  module Models
+    class CustomAction < Action
+      class << self
+        def find_by(model, search_hash)
+          model.available_actions.find { |i| i.name == search_hash[:name] }
+        end
+      end
+    end
+  end
+end

data/lib/cm_admin/models/dsl_method.rb

@@ -0,0 +1,122 @@
+module CmAdmin
+  module Models
+    module DslMethod
+      extend ActiveSupport::Concern
+
+      def cm_index(page_title: nil ,page_description: nil, &block)
+        @current_action = CmAdmin::Models::Action.find_by(self, name: 'index')
+        @current_action.page_title = page_title
+        @current_action.page_description = page_description
+        yield
+        # action.instance_eval(&block)
+      end
+
+      def cm_show(page_title: nil,page_description: nil,&block)
+        @current_action = CmAdmin::Models::Action.find_by(self, name: 'show')
+        @current_action.page_title = page_title
+        @current_action.page_description = page_description
+        yield
+      end
+  
+      def cm_edit(page_title: nil,page_description: nil, &block)
+        @current_action = CmAdmin::Models::Action.find_by(self, name: 'edit')
+        @current_action.page_title = page_title
+        @current_action.page_description = page_description
+        yield
+      end
+  
+      def cm_new(page_title: nil,page_description: nil,&block)
+        @current_action = CmAdmin::Models::Action.find_by(self, name: 'new')
+        @current_action.page_title = page_title
+        @current_action.page_description = page_description
+        yield
+      end
+
+      def page_title(title)
+        if @current_action
+          @current_action.page_title = title
+        end
+      end
+  
+      def page_description(description)
+        if @current_action
+          @current_action.page_description = description
+        end
+      end
+  
+      def tab(tab_name, custom_action, associated_model: nil, layout_type: nil, layout: nil, partial: nil, &block)
+        if custom_action.to_s == ''
+          @current_action = CmAdmin::Models::Action.find_by(self, name: 'show')
+          @available_tabs << CmAdmin::Models::Tab.new(tab_name, '', &block)
+        else
+          action = CmAdmin::Models::Action.new(name: custom_action.to_s, verb: :get, path: ':id/'+custom_action, layout_type: layout_type, layout: layout, partial: partial, child_records: associated_model)
+          @available_actions << action
+          @current_action = action
+          @available_tabs << CmAdmin::Models::Tab.new(tab_name, custom_action, &block)
+        end
+        yield if block
+      end
+  
+      def cm_show_section(section_name, &block)
+        @available_fields[@current_action.name.to_sym] ||= []
+        @available_fields[@current_action.name.to_sym] << CmAdmin::Models::CmShowSection.new(section_name, &block)
+      end
+  
+      def form_field(field_name, options={}, arg=nil)
+        unless @current_action.is_nested_field
+          @available_fields[@current_action.name.to_sym][:fields] << CmAdmin::Models::FormField.new(field_name, options[:input_type], options)
+        else
+          @available_fields[@current_action.name.to_sym][@current_action.nested_table_name] ||= []
+          @available_fields[@current_action.name.to_sym][@current_action.nested_table_name] << CmAdmin::Models::FormField.new(field_name, options[:input_type], options)
+        end
+      end
+  
+      def nested_form_field(field_name, &block)
+        @current_action.is_nested_field = true
+        @current_action.nested_table_name = field_name
+        yield
+      end
+  
+      def column(field_name, options={})
+        @available_fields[@current_action.name.to_sym] ||= []
+        if @available_fields[@current_action.name.to_sym].select{|x| x.lockable}.size > 0 && options[:lockable]
+          raise "Only one column can be locked in a table."
+        end
+        unless @available_fields[@current_action.name.to_sym].map{|x| x.field_name.to_sym}.include?(field_name)
+          @available_fields[@current_action.name.to_sym] << CmAdmin::Models::Column.new(field_name, options)
+        end
+      end
+  
+      def all_db_columns(options={})
+        field_names = self.instance_variable_get(:@ar_model)&.columns&.map{|x| x.name.to_sym}
+        if options.include?(:exclude) && field_names
+          excluded_fields = (Array.new << options[:exclude]).flatten.map(&:to_sym)
+          field_names -= excluded_fields
+        end
+        field_names.each do |field_name|
+          column field_name
+        end
+      end
+
+      # Custom actions
+      # eg
+      # class User < ApplicationRecord
+      #   cm_admin do
+      #     custom_action name: 'submit', verb: 'post', path: ':id/submit' do
+      #       def user_submit
+      #         Code for action here...
+      #       end
+      #     end
+      #   end
+      # end
+      def custom_action(name: nil, verb: nil, layout: nil, partial: nil, path: nil, display_if: lambda { |arg| return true }, route_type: nil, &block)
+        @available_actions << CmAdmin::Models::CustomAction.new(name: name, verb: verb, layout: layout, partial: partial, path: path, parent: self.current_action.name, display_if: display_if, route_type: route_type, &block)
+        # self.class.class_eval(&block)
+      end
+
+      def filter(db_column_name, filter_type, options={})
+        @filters << CmAdmin::Models::Filter.new(db_column_name: db_column_name, filter_type: filter_type, options: options)
+      end
+    end
+  end
+end

data/lib/cm_admin/models/export.rb

@@ -2,19 +2,30 @@ module CmAdmin
   module Models
     class Export
       class << self
-        def generate_excel(klass_name, columns = [])
+        def generate_excel(klass_name, columns = [], helpers)
           klass = klass_name.constantize
-          records = get_records(klass, columns)
+          model = CmAdmin::Model.find_by({name: klass_name})
+          records = get_records(klass, model, columns, helpers)
           file_path = "#{Rails.root}/tmp/#{klass}_data_#{DateTime.now.strftime("%Y-%m-%d_%H-%M-%S")}.xlsx"
           create_workbook(records, columns, file_path)
           return file_path
         end
 
-        def get_records(klass, columns)
+        def get_records(klass, model, columns, helpers)
           records = klass
+          custom_fields = model.available_fields[:index].map{|field| field if field.field_type == :custom}.compact
+          normal_fields = model.available_fields[:index].map{|field| field unless field.field_type == :custom}.compact
           deserialized_columns = CmAdmin::Utils.deserialize_csv_columns(columns, :as_json_params)
           # This includes isn't recursve, a full solution should be recursive
-          records.includes(deserialized_columns[:include].keys).find_each.as_json(deserialized_columns)
+          records_arr = []
+          records.includes(deserialized_columns[:include].keys).find_each do |record|
+            record_hash = record.as_json({only: normal_fields.map(&:field_name)})
+            custom_fields.each do |field|
+              record_hash[field.field_name.to_sym] = helpers.send(field.helper_method, record, field.field_name)
+            end
+            records_arr << record_hash
+          end
+          records_arr
         end
 
         def create_workbook(records, class_name, file_path)
@@ -34,7 +45,7 @@ module CmAdmin
         end
 
         def exportable_columns(klass)
-          klass.available_fields[:index].map{|x| x.exportable ? x.db_column_name : ""}.reject { |c| c.empty? }
+          klass.available_fields[:index].map{|x| x.exportable ? x.field_name : ""}.reject { |c| c.empty? }
         end
 
       end

data/lib/cm_admin/models/field.rb

@@ -1,7 +1,8 @@
 module CmAdmin
   module Models
     class Field
-      attr_accessor :field_name, :label, :header
+
+      attr_accessor :field_name, :label, :header, :field_type, :format, :precision, :helper_method, :preview, :custom_link, :precision
 
       def initialize(field_name, attributes = {})
         @field_name = field_name