formily 0.0.5.5.7

data/app/assets/stylesheets/formily/modal/iframe.scss

@@ -0,0 +1,29 @@
+.formily-modal-container {
+  display: none;
+  position: fixed;
+  height: 100%;
+  width: 100%;
+  top: 0;
+  left: 0;
+  z-index: 9999;
+  background-color: rgba(0, 0, 0, 0.65);
+
+  #formily_iframe_modal {
+    display: block;
+    position: absolute;
+    border: 2px solid #000000;
+    border-radius: 0 0 5px 5px;
+    top: 50%;
+    left: 50%;
+    background-color: #ffffff;
+    overflow: auto;
+    -webkit-overflow-scrolling: touch;
+
+    iframe {
+      position: static;
+      display: block;
+      height: 100%;
+      width: 100%;
+    }
+  }
+}

data/app/assets/stylesheets/formily_iframe.scss

@@ -0,0 +1,64 @@
+//=require foundation
+//=require formily/foundation_fix
+//=require formily/jquery.datetimepicker.min
+//=require formily/inputs/multi_file
+//=require formily/inputs/date_time
+//=require formily/base/fonts
+
+html, body {
+  display: block;
+  height: 100%;
+  width: 100%;
+}
+
+body {
+  position: relative;
+  overflow: auto;
+  -webkit-overflow-scrolling: touch;
+}
+
+body.formily {
+  width: 100%;
+  height: 100%;
+  padding: 0;
+  font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+  margin: 0 auto;
+  background-color: #EDE7F6;
+
+  .header {
+    display: block;
+    height: 37px;
+    margin: 0;
+    padding: 0;
+
+    text-align: left;
+    line-height: 30px;
+    font-size: 20px;
+
+    color: #ffffff;
+    background-color: #000000;
+
+    a.close-iframe-btn {
+      float: right;
+      color: #ffffff;
+      text-decoration: none;
+      margin: 4px 10px 0 0;
+    }
+
+    a.formily-edit .ff-icon-pencil, a.formily-edit span {
+      color: #fff;
+      font-size: 12px
+    }
+  }
+
+  .wrapper {
+    display: block;
+    margin: 0;
+    padding: 0;
+    background-color: #ffffff;
+
+    .content {
+      padding: 10px 10px 10px 10px;
+    }
+  }
+}

data/app/assets/stylesheets/foundation_formily.scss

@@ -0,0 +1,20 @@
+//=require foundation
+//=require formily/foundation_fix
+//=require formily/base/fonts
+//=require formily/editor
+//=require formily/jquery.datetimepicker.min
+//=require formily/inputs/multi_file
+//=require formily/inputs/date_time
+
+
+html, body {
+  display: block;
+  height: 100%;
+  width: 100%;
+}
+
+body {
+  position: relative;
+  overflow: auto;
+  -webkit-overflow-scrolling: touch;
+}

data/app/controllers/formily/file_controller.rb

@@ -0,0 +1,17 @@
+# coding: utf-8
+class Formily::FileController < FormilyController
+
+  before_action :authenticate_user! if (true if Devise rescue false)
+
+  def show
+    f = Formily::File.find(params[:id])
+    send_file Rails.root.join(f.file.path), type: f.file_content_type, disposition: 'inline'
+  end
+
+  def destroy
+    file = Formily::File.find(params[:id])
+    file.destroy
+    render nothing: true, status: :ok
+  end
+
+end

data/app/controllers/formily/form_types_controller.rb

@@ -0,0 +1,46 @@
+# coding: utf-8
+class Formily::FormTypesController < FormilyController
+
+  before_action :get_form_type, only: [:edit, :update, :destroy]
+
+
+  def index
+    @form_types = Formily::FormType.all
+  end
+
+  def new
+    @form_type = Formily::FormType.new
+  end
+
+  def create
+    form_type = Formily::FormType.new(form_type_params)
+    form_type.save
+
+    redirect_to formily_form_types_path
+  end
+
+  def edit
+  end
+
+  def update
+    @form_type.update(form_type_params)
+    redirect_to formily_form_types_path
+  end
+
+  def destroy
+    @form_type.destroy
+    redirect_to formily_form_types_path
+  end
+
+
+  private
+
+    def get_form_type
+      @form_type = Formily::FormType.find(params[:id])
+    end
+
+    def form_type_params
+      params.require(:formily_form_type).permit(:title)
+    end
+
+end

data/app/controllers/formily/formilyable_controller.rb

@@ -0,0 +1,98 @@
+# coding: utf-8
+class Formily::FormilyableController < FormilyController
+
+  def index
+    @forms = Formily::Form.all
+    @select_forms = Formily::Form.select(:id, :title)
+    @related_forms = Formily::FormilyableForm.order(created_at: :desc)
+
+    @related_forms = if params[:all].present?
+                       Formily::FormilyableForm.order(created_at: :desc)
+                     else
+                       Formily::FormilyableForm.joins(:form).order(created_at: :desc).where(formily_forms: {is_deleted: false})
+                     end
+  end
+
+  def new
+    #  Set user data
+    if params[:model_name].present?
+      session[:model] = {
+        'model_name' => params[:model_name],
+        'model_id' => params[:model_id],
+        'user_id' => params[:user_id]
+      }
+    end
+
+    @related_model = session[:model]
+
+    @forms = Formily::FormilyableForm.includes(:form).
+      where(formilyable_type: @related_model['model_name'], formilyable_id: @related_model['model_id'])
+    @model = get_model
+    @select_forms = Formily::Form.where.not(id: @model.formily_forms.pluck(:id))
+  end
+
+  def create
+    formilyable = Formily::FormilyableForm.new(formilyable_params)
+
+    url = params[:iframe].present? ? new_formily_formilyable_path(iframe: true) : formily_forms_assign_path
+
+    if formilyable.save
+      redirect_to url
+    else
+      redirect_to url
+    end
+  end
+
+  def destroy
+    formilyable = Formily::FormilyableForm.find(params[:id])
+    formilyable.destroy
+
+    url = params[:iframe].present? ? new_formily_formilyable_path(iframe: true) : formily_forms_assign_path
+
+    redirect_to url
+  end
+
+  def select_data
+
+    model = params[:formilyable_type].safe_constantize
+
+    ids = Formily::FormilyableForm.where(formilyable_type: params[:formilyable_type], form_id: params[:form_id]).pluck(:formilyable_id)
+
+    data = model.where.not(id: ids)
+
+    render json: data.to_json(only: [:id], methods: :formily_title)
+
+  end
+
+  def connect
+    @page_name = 'Formily forms | Connect'
+    @forms = Formily::Form.all
+
+    @not_manage = true
+
+    @model = @model_name.safe_constantize.find(@model_id)
+
+    @select_forms = Formily::Form.where.not(id: @model.formily_forms.pluck(:id))
+
+  end
+
+
+  private
+
+    def formilyable_params
+      params.permit(:form_id, :formilyable_id, :formilyable_type)
+    end
+
+    def formily_layout
+      if params[:iframe].present?
+        'formily_iframe'
+      else
+        ApplicationController.new.send(:_layout).virtual_path.split('/').last
+      end
+    end
+
+    def get_model
+      session[:model]['model_name'].safe_constantize.find(session[:model]['model_id'])
+    end
+
+end

data/app/controllers/formily/forms_controller.rb

@@ -0,0 +1,133 @@
+# coding: utf-8
+class Formily::FormsController < FormilyController
+
+  before_action :save_params
+
+  def index
+    @forms = if params[:all].present?
+               Formily::Form.includes(:form_type).all
+             else
+               Formily::Form.includes(:form_type).where(is_deleted: false)
+             end
+  end
+
+  def new
+    @form = Formily::Form.new(id: 0)
+  end
+
+  def show
+    @form = Formily::Form.find(params[:id])
+    model = params[:model_name].safe_constantize
+    @obj_rel = model.find(params[:model_id])
+
+    @submit = @form.submits.find_by(id: params[:submit_id])
+
+    if @submit.blank?
+      @submit = Formily::Submit.create({form_id: @form.id, resource_id: params[:model_id],
+                                        user_id: params[:user_id], resource_type: params[:model_name]})
+    end
+
+  end
+
+  def edit
+    @form = Formily::Form.includes(:inputs).find(params[:id])
+  end
+
+  def create
+    form = Formily::Form.new(form_params)
+
+    if form.save
+      if params[:inputs]
+        params[:inputs].each do |input|
+          i = form.inputs.build(input.to_hash.except('group_inputs'))
+          i.save
+          if input[:group_inputs]
+            input[:group_inputs].each do |gi|
+              t = i.inputs.build(gi.to_hash)
+              t.save
+            end
+          end
+        end
+      end
+
+      redirect_to formily_forms_path(@params_hash)
+    else
+      redirect_to formily_forms_path(@params_hash)
+    end
+
+  end
+
+  def update
+
+    form = if params[:id].to_i == 0
+             Formily::Form.create
+           else
+             Formily::Form.find(params[:id])
+           end
+
+    form.update(form_params)
+
+    render json: {id: form.id}, status: :ok
+  end
+
+  def destroy
+    form = Formily::Form.find(params[:id])
+    count  = Formily::Submit.where(form_id: form.id).count
+
+    if count > 0
+      form.update(is_deleted: true)
+    else
+      form.destroy
+    end
+
+    redirect_to formily_forms_path(@params_hash)
+  end
+
+  def preview
+    form = Formily::Form.find_by(id: params[:formily_form][:id])
+    form ||= Formily::Form.new
+    submit = Formily::Submit.new(created_at: DateTime.now)
+    render partial: 'preview', layout: false, locals: {:@form => form, :@obj_rel => form, :@submit => submit}
+  end
+
+
+  def reload_formily_table
+    user_id = params[:user_id]
+    obj_rel = params[:resource_type].safe_constantize.find(params[:resource_id])
+
+    render locals: {obj_rel: obj_rel, user_id: user_id, flag: params[:flag].present?}, layout: false
+  end
+
+
+  def add_new_response
+    submit = Formily::Submit.where(params.permit(:form_id, :resource_id, :user_id, :resource_type))
+               .order(created_at: :desc).first
+
+    if submit.blank? || submit.state == 0 || submit.input_values.count == 0
+      render json: {msg: 'Complete the outstanding form instead of adding a new copy'}, status: :unprocessable_entity
+    else
+      submit = Formily::Submit.new(params.permit(:form_id, :resource_id, :user_id, :resource_type))
+      submit.save
+      render json: {}, status: :ok
+    end
+  end
+
+  private
+
+    def form_params
+      params.require(:formily_form).permit(:title, :description, :form_type_id)
+    end
+
+    def save_params
+      @params_hash = {}
+      @params_hash[:iframe] = true if params[:iframe]
+      @params_hash[:model_id] = params[:model_id]
+      @params_hash[:model_name] = params[:model_name]
+      @params_hash[:user_id] = params[:user_id]
+
+      @model_id = @params_hash[:model_id]
+      @model_name = @params_hash[:model_name]
+      @user_id = @params_hash[:user_id]
+    end
+
+end

data/app/controllers/formily/iframe/forms_controller.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+class Formily::Iframe::FormsController < FormilyController
+
+  def show
+    @form = Formily::Form.find(params[:id])
+
+    model = params[:model_name].safe_constantize
+
+    @obj_rel = model.blank? ? nil : model.find(params[:model_id])
+
+    @submit = @form.submits.find_by(id: params[:submit_id])
+
+    if @submit.blank?
+      @submit = Formily::Submit.create({form_id: @form.id, resource_id: params[:model_id],
+                                        user_id: params[:user_id], resource_type: params[:model_name]})
+    end
+  end
+
+  def add
+  end
+
+
+  private
+    def formily_layout
+      'formily_iframe'
+    end
+
+end

data/app/controllers/formily/inputs_controller.rb

@@ -0,0 +1,113 @@
+# coding: utf-8
+class Formily::InputsController < FormilyController
+
+  def create
+    input = Formily::Input.create(input_params)
+    render json: {id: input.id}, status: :ok
+  end
+
+  def update
+    input = Formily::Input.find(params[:id])
+    input.update(input_params)
+    render nothing: true, status: :ok
+  end
+
+  def destroy
+    input = Formily::Input.find(params[:id])
+
+    count = Formily::InputValue.where(input_id: input.id).count
+
+    if input.inputs.count > 0
+      count += Formily::InputValue.where(input_id: input.inputs.map(&:id)).count
+    end
+
+    if input.type == 'Formily::RadioInput'
+      count += Formily::InputValue.where(input_id: input.group_input_id).count
+    end
+
+    if input.type == 'Formily::OptionInput'
+      count += Formily::InputValue.where(input_id: input.group_input_id).count
+    end
+
+    if count > 0
+      input.update(is_deleted: true)
+    else
+      input.destroy
+    end
+
+    render nothing: true, status: :ok
+  end
+
+  def render_input_html
+    if params[:type].present?
+      @input = params[:type].constantize.new(params.permit(:id, :name, :label, :description, :type,
+                                                           :field_order, :tag_attributes, :default_value))
+      render layout: false
+    end
+  end
+
+  def render_related
+
+    if params[:related_arr]
+
+      if params[:related_arr].blank?
+        models = Formily.formily_models
+        data = []
+
+        models.each do |model|
+          data << {label: model.to_s, value: model.to_s}
+          data << {
+            label: model.to_s + '->' + model.formily_form_related_model.to_s,
+            value: model.to_s + '->' + model.formily_form_related_model.to_s
+          }
+        end
+
+        render json: data.to_json, status: :ok
+
+      else
+
+        model = if params[:related_arr][0] =~ /->/
+                  params[:related_arr][0].sub(/.*?->/, '').safe_constantize
+                else
+                  params[:related_arr][0].safe_constantize
+                end
+
+        if model
+          tmp = model.new
+
+          params[:related_arr][1..-1].each do |attr|
+            tmp = tmp.send('build_' + attr) rescue nil
+            tmp = tmp.send(attr) rescue nil unless tmp
+          end
+
+          if tmp && tmp.class.superclass.name =~ /\Aactiverecord/i
+            model = tmp.class
+            data = []
+            if model.reflect_on_all_associations.any?
+              model.reflect_on_all_associations.each do |ref|
+                data << {label: ref.name, value: ref.name, macro: ref.macro} if ref.macro =~ /belongs_to/i
+              end
+            end
+            data += model.columns_hash.map{|k,v| {label: k, value: k}}
+
+            render json: data.to_json, status: :ok
+          else
+            render text: '', status: :ok
+          end
+
+        end
+      end
+
+    else
+      render text: '', status: :ok
+    end
+
+  end
+
+  private
+    def input_params
+      params.permit(:id, :name, :type, :label, :description, :group_input_id,
+                    :field_order, :default_value, :tag_attributes, :form_id)
+    end
+
+end