binda 0.0.2

data/app/controllers/binda/field_groups_controller.rb

@@ -0,0 +1,114 @@
+require_dependency "binda/application_controller"
+
+module Binda
+  class FieldGroupsController < ApplicationController
+    before_action :set_structure
+    before_action :set_field_group, only: [:show, :edit, :update, :destroy]
+
+    def index
+      @field_groups = @structure.field_groups.order('position').all
+    end
+
+    def show
+      redirect_to action: :edit
+    end
+
+    def new
+      @field_group = @structure.field_groups.build()
+    end
+
+    def edit
+    end
+
+    def create
+      @field_group = @structure.field_groups.build(field_group_params)
+
+      if @field_group.save
+        reset_field_settings_cache
+        redirect_to structure_field_group_path( @structure.slug, @field_group.slug ), notice: 'Field group was successfully created.'
+      else
+        redirect_to new_structure_field_group_path( @structure.slug ), flash: { alert: @field_group.errors }
+      end
+    end
+
+    def update
+      # Create new fields if any
+      new_params[:new_field_settings].each do |field_setting|
+        unless field_setting[:name].blank?
+          new_field_setting = @field_group.field_settings.create( field_setting )
+          unless new_field_setting
+            return redirect_to edit_structure_field_group_path( @structure.slug, @field_group.slug ), flash: { error: new_field_setting.errors }
+          end
+        end
+      end
+
+      # Update the other ones
+      if @field_group.update(field_group_params)
+        reset_field_settings_cache
+        redirect_to structure_field_group_path( @structure.slug, @field_group.slug ), notice: 'Field group was successfully updated.'
+      else
+        redirect_to edit_structure_field_group_path( @structure.slug, @field_group.slug ), flash: { alert: @field_group.errors }
+      end
+    end
+
+    def destroy
+      @field_group.destroy
+      reset_field_settings_cache
+      redirect_to structure_path( @structure.slug ), notice: 'Field group was successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_structure
+        @structure = Structure.friendly.find( params[:structure_id] )
+      end
+
+      def set_field_group
+        @field_group = FieldGroup.friendly.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def field_group_params
+        params.require(:field_group).permit(
+          :name, 
+          :slug, 
+          :description, 
+          :position, 
+          :layout,
+          :structure_id,
+          field_settings_attributes: [
+            :id, 
+            :field_group_id,
+            :field_setting_id,
+            :name, 
+            :slug,
+            :description,
+            :field_type,
+            :position,
+            :required,
+            :default_text,
+            :ancestry
+          ])
+      end
+
+      def new_params
+        params.require(:field_group).permit( 
+          new_field_settings:[ 
+            :field_group_id, 
+            :field_setting_id,
+            :name, 
+            :slug,
+            :description, 
+            :field_type, 
+            :position,
+            :required,
+            :ancestry
+            ])
+      end
+
+      def reset_field_settings_cache
+        Binda::FieldSetting.reset_field_settings_array
+      end
+
+  end
+end

data/app/controllers/binda/field_settings_controller.rb

@@ -0,0 +1,66 @@
+require_dependency "binda/application_controller"
+
+module Binda
+  class FieldSettingsController < ApplicationController
+    before_action :set_structure
+    before_action :set_field_group
+    before_action :set_field_setting, only: [:show, :edit, :update, :destroy]
+
+    def index
+      @field_settings = @field_group.field_settings.order('position').all
+    end
+
+    def show
+      redirect_to action: :edit
+    end
+
+    def new
+      @field_setting = @field_group.field_settings.build()
+    end
+
+    def edit
+    end
+
+    def create
+      @field_setting = @field_group.field_settings.build(field_setting_params)
+
+      if @field_setting.save
+        redirect_to structure_field_group_field_setting_path( @structure.slug, @field_group.slug, @field_setting.slug ), notice: 'Field setting was successfully created.'
+      else
+        redirect_to new_structure_field_group_field_setting_path( @structure.slug, @field_group.slug ), flash: { alert: @field_setting.errors }
+      end
+    end
+
+    def update
+      if @field_setting.update(field_setting_params)
+        redirect_to structure_field_group_field_setting_path( @structure.slug, @field_group.slug, @field_setting.slug ), notice: 'Field setting was successfully updated.'
+      else
+        redirect_to edit_structure_field_group_field_setting_path( @structure.slug, @field_group.slug, @field_setting.slug ), flash: { alert: @field_setting.errors }
+      end
+    end
+
+    def destroy
+      @field_setting.destroy
+      redirect_to structure_field_group_path( @structure.slug, @field_group.slug ), notice: 'Field setting and all dependent content were successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_structure
+        @structure = Structure.friendly.find( params[:structure_id] )
+      end
+
+      def set_field_group
+        @field_group = FieldGroup.friendly.find( params[:field_group_id] )
+      end
+
+      def set_field_setting
+        @field_setting = FieldSetting.friendly.find( params[:id] )
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def field_setting_params
+        params.require(:field_setting).permit(:name, :slug, :description, :position, :required, :default_text, :field_group_id, :field_type )
+      end
+  end
+end

data/app/controllers/binda/galleries_controller.rb

@@ -0,0 +1,62 @@
+require_dependency "binda/application_controller"
+
+module Binda
+  class GalleriesController < ApplicationController
+    before_action :set_gallery, only: [:show, :edit, :update, :destroy]
+
+    # GET /galleries
+    def index
+      @galleries = Gallery.all
+    end
+
+    # GET /galleries/1
+    def show
+    end
+
+    # GET /galleries/new
+    def new
+      @gallery = Gallery.new
+    end
+
+    # GET /galleries/1/edit
+    def edit
+    end
+
+    # POST /galleries
+    def create
+      @gallery = Gallery.new(gallery_params)
+
+      if @gallery.save
+        redirect_to gallery_path( @gallery.id ), notice: 'Gallery was successfully created.'
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /galleries/1
+    def update
+      if @gallery.update(gallery_params)
+        redirect_to gallery_path( @gallery.id ), notice: 'Gallery was successfully updated.'
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /galleries/1
+    def destroy
+      @gallery.destroy
+      redirect_to galleries_url, notice: 'Gallery was successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_gallery
+        @gallery = Gallery.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def gallery_params
+        params.require(:gallery).permit( :position )
+      end
+  end
+end

data/app/controllers/binda/manage/users_controller.rb

@@ -0,0 +1,97 @@
+require_dependency "binda/application_controller"
+
+module Binda
+  class Manage::UsersController < ApplicationController
+    before_action :set_user, only: [:show, :edit, :update, :destroy]
+    before_action :check_if_is_superadmin, only: [:update, :destroy]
+
+    def index
+      @users = User.all
+    end
+
+    def show
+      redirect_to action: :edit
+    end
+
+    def new
+      @user = User.new
+    end
+
+    def edit
+    end
+
+    def create
+      @user = User.new( user_params )
+
+      respond_to do |format|
+        if @user.save
+          format.html { redirect_to manage_user_path( @user.id ), notice: 'User was successfully created.' }
+          format.xml  { head :ok }
+          format.json { render :show, status: :created, location: @user }
+        else
+          format.html { redirect_to new_manage_user_path, flash: { alert: @user.errors } }
+          format.xml  { head :bad_request }
+          format.json { render json: @user.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    def update
+      if @user.is_superadmin && !current_user.is_superadmin
+        redirect_to manage_users_url, notice: 'Sorry, you cannot edit a administrator.'
+      else
+        respond_to do |format|
+          if @user.update(user_params)
+            format.html { redirect_to manage_user_path( @user.id ), notice: 'User was successfully updated.' }
+            format.xml  { head :ok }
+            format.json { render :show, status: :ok, location: @user }
+          else
+            format.html { redirect_to edit_manage_user_path( @user.id ), flash: { alert: @user.errors } }
+            format.xml  { head :bad_request }
+            format.json { render json: @user.errors, status: :unprocessable_entity }
+          end
+        end
+      end
+    end
+
+    def destroy
+      if current_user.email == @user.email
+        redirect_to manage_users_url, flash: { alert: 'Sorry, you cannot delete your own account.' }
+      elsif !current_user.is_superadmin
+        redirect_to manage_users_url, flash: { alert: 'Sorry, you cannot delete an administrator.' }
+      else
+        @user.destroy
+        respond_to do |format|
+          format.html { redirect_to manage_users_url, notice: 'User was successfully destroyed.' }
+          format.xml  { head :ok }
+          format.json { head :no_content }
+        end
+      end
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_user
+        @user = User.find(params[:id])
+      end
+
+      # Never trust parameters from the scary internet, only allow the white list through.
+      def user_params
+        params.fetch(:user, {}).permit( :email, :password, :password_confirmation, :is_superadmin )
+      end
+
+      # https://github.com/plataformatec/devise/wiki/How-To%3a-Manage-users-through-a-CRUD-interface
+      def devise_fix
+        if params[:user][:password].blank?
+          params[:user].delete(:password)
+          params[:user].delete(:password_confirmation)
+        end
+      end
+
+      def check_if_is_superadmin
+        if current_user.is_superadmin
+          redirect_to manage_users_url, alert: 'Sorry, it\'s forbidden to modify this account.'
+        end
+      end
+  end
+end

data/app/controllers/binda/repeaters_controller.rb

@@ -0,0 +1,67 @@
+require_dependency "binda/application_controller"
+
+module Binda
+  class RepeatersController < ApplicationController
+    before_action :set_repeater, only: [:show, :edit, :update, :destroy]
+
+    # GET /repeaters
+    def index
+      @repeaters = Repeater.all
+    end
+
+    # GET /repeaters/1
+    def show
+    end
+
+    # GET /repeaters/new
+    def new
+      @repeater = Repeater.new
+    end
+
+    # GET /repeaters/1/edit
+    def edit
+    end
+
+    # POST /repeaters
+    def create
+      @repeater = Repeater.new(repeater_params)
+
+      if @repeater.save
+        redirect_to @repeater, notice: 'Repeater was successfully created.'
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /repeaters/1
+    def update
+      if @repeater.update(repeater_params)
+        redirect_to @repeater, notice: 'Repeater was successfully updated.'
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /repeaters/1
+    def destroy
+      @repeater.destroy
+      # redirect_to repeaters_url, notice: 'Repeater was successfully destroyed.'
+      if params['isAjax']
+        head :ok
+      else
+        redirect_to :back, notice: 'Field group was successfully destroyed.' 
+      end
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_repeater
+        @repeater = Repeater.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def repeater_params
+        params.require(:repeater).permit(:name, :slug)
+      end
+  end
+end

data/app/controllers/binda/settings_controller.rb

@@ -0,0 +1,75 @@
+require_dependency "binda/application_controller"
+
+module Binda
+  class SettingsController < ApplicationController
+    before_action :set_setting, only: [:show, :edit, :update, :destroy]
+
+    def index
+      @settings = Setting.all
+    end
+
+    def show
+      redirect_to action: :edit
+    end
+
+    def new
+      @setting = Setting.new
+    end
+
+    def edit
+    end
+
+    def create
+      @setting = Setting.new(setting_params)
+
+      if @setting.save
+        redirect_to setting_path( @setting.slug ), notice: 'Setting was successfully created.'
+      else
+        render :new
+      end
+    end
+
+    def update
+      if @setting.update(setting_params)
+        redirect_to setting_path( @setting.slug ), notice: 'Setting was successfully updated.'
+      else
+        render :edit
+      end
+    end
+
+    def destroy
+      @setting.destroy
+      redirect_to settings_url, notice: 'Setting was successfully destroyed.'
+    end
+
+    def dashboard
+      @settings  = Setting.all
+      @dashboard = Setting
+    end
+
+    def update_dashboard
+      dashboard_params[:settings].each do |id|
+        setting = Setting.find(id)
+        unless setting.update( dashboard_params[:settings][id.to_s] )
+          return redirect_to dashboard_path, flash: { error: setting.errors }
+        end
+      end
+      redirect_to dashboard_path, flash: { notice: 'Dashboard was successfully updated.' } 
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_setting
+        @setting = Setting.friendly.find(params[:id])
+      end
+
+      def dashboard_params
+        params.require(:dashboard).permit( settings: [ :id, :name, :content, :slug, :position, :is_true ] )
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def setting_params
+        params.require(:setting).permit(:name, :content, :slug, :position, :dashboard )
+      end
+  end
+end