backframe 0.0.49 → 1.0.0

data/lib/backframe/actioncontroller/acts_as_resource.rb

@@ -1,92 +0,0 @@
-# encoding: utf-8
-
-require 'active_support'
-
-require 'backframe/actioncontroller/acts_as_resource/actions'
-
-module Backframe
-  module ActsAsResource
-    extend ActiveSupport::Concern
-
-    class_methods do
-      def acts_as_resource(resource, *args)
-        arguments = args[0] || {}
-
-        @resource = resource
-        @resource_opts = arguments
-
-        include Helpers
-
-        member_methods = [:show,:edit,:update,:destroy]
-        if arguments.key?(:has_many)
-          member_methods.concat(arguments[:has_many])
-        end
-
-        if arguments.key?(:only)
-          member_methods = (member_methods.to_set & arguments[:only].to_set).to_a
-        end
-
-        if arguments.key?(:except)
-          member_methods = (member_methods.to_set - arguments[:except].to_set).to_a
-        end
-
-        before_action :load_item, only: member_methods
-
-        include Actions::Index     if include_method?(arguments, :index)
-        include Actions::Create    if include_method?(arguments, :create)
-        include Actions::Show      if include_method?(arguments, :show)
-        include Actions::Edit      if include_method?(arguments, :edit)
-        include Actions::Update    if include_method?(arguments, :update)
-        include Actions::UpdateAll if include_method?(arguments, :update)
-        include Actions::Destroy   if include_method?(arguments, :destroy)
-
-        if arguments.key?(:has_many)
-          arguments[:has_many].each do |association|
-            class_eval <<-EOV
-              def #{association}
-                page(@item.#{association})
-              end
-            EOV
-          end
-        end
-      end
-
-      def resource; @resource; end
-      def resource_opts; @resource_opts; end
-
-      private
-
-      def include_method?(arguments, method)
-        (arguments[:only].present? && arguments[:only].include?(method)) ||
-          (arguments[:except].present? && !arguments[:except].include?(method)) ||
-          (arguments[:only].nil? && arguments[:except].nil?)
-      end
-    end
-  end
-
-  module Helpers
-    def resource
-      self.class.resource.constantize
-    rescue NameError
-      instance_eval self.class.resource
-    end
-
-    def load_item
-      @item = resource.find(params[:id])
-    end
-
-    def allowed_params
-      allowed = params.permit(self.class.resource_opts[:allowed])
-      self.class.resource_opts[:allowed].each do |attribute|
-        if attribute.is_a?(Hash)
-          attribute.each do |key,value|
-            if value.is_a?(Array) && !allowed.key?(key)
-              allowed[key] = []
-            end
-          end
-        end
-      end
-      allowed
-    end
-  end
-end

data/lib/backframe/actioncontroller/acts_as_resource/actions.rb

@@ -1,100 +0,0 @@
-# encoding: utf-8
-
-module Backframe
-  module ActsAsResource
-    module Actions
-      module Index
-        def index
-          page(resource.includes(self.class.resource_opts[:include]), nil)
-        end
-      end
-
-      module Create
-        def create
-          @item = resource.new(allowed_params)
-          if @item.save
-            if @item.respond_to?(:activities)
-              Activity.create!(subject: current_user, text: 'created {object1}', object1: @item)
-            end
-
-            render json: @item, status: 201, adapter: Backframe::ActsAsAPI::Adapter
-          else
-            resource_error_response(@item, 422)
-          end
-        end
-      end
-
-      module Show
-        def show
-          render json: @item, adapter: Backframe::ActsAsAPI::Adapter
-        end
-      end
-
-      module Edit
-        def edit
-          json = {}
-          self.class.resource_opts[:allowed].each do |attribute|
-            if(attribute.is_a?(Hash))
-              attribute.each do |key,val|
-                json[key] = @item.send(key)
-              end
-            else
-              json[attribute] = @item.send(attribute)
-            end
-          end
-          render json: json
-        end
-      end
-
-      module Update
-        def update
-          if @item.update_attributes(allowed_params)
-            if @item.respond_to?(:activities)
-              Activity.create!(subject: current_user, text: 'updated {object1}', object1: @item)
-            end
-            render json: @item
-          else
-            resource_error_response(@item, 422)
-          end
-        end
-      end
-
-      module UpdateAll
-        def update_all
-          records = []
-
-          ActiveRecord::Base.transaction do
-            records = update_all_params.map(&method(:update_record))
-          end
-
-          render json: records, adapter: Backframe::ActsAsAPI::Adapter
-        end
-
-        private
-
-        def update_record(attrs)
-          attrs = attrs.with_indifferent_access
-          record = resource.find(attrs[:id])
-          record.attributes = attrs
-          record.save!
-          record
-        end
-
-        def update_all_params
-          permitted = self.class.resource_opts[:allowed] << :id
-          params.permit(records: permitted)[:records] || []
-        end
-      end
-
-      module Destroy
-        def destroy
-          if @item.destroy
-            render nothing: true, status: 204
-          else
-            resource_error_response(@item, 422)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/backframe/actioncontroller/acts_as_session.rb

@@ -1,80 +0,0 @@
-# encoding: utf-8
-
-require 'active_support'
-require 'active_support/inflector'
-
-module Backframe
-  module ActsAsSession
-    extend ActiveSupport::Concern
-
-    class_methods do
-      def acts_as_session(model, *args)
-
-        arguments = args[0] || {}
-
-        class_eval <<-EOV
-
-          layout 'signin'
-          before_action :redirect_if_signed_in, :except => [:application,:destroy]
-          before_action :authenticate_#{model.underscore}, :only => :application
-
-          def application
-            render :layout => false
-          end
-
-          def new
-            @user = #{model}.new
-          end
-
-          def create
-            if @user = #{model}.where('LOWER(email) = ?', params[:#{model.underscore}][:email].downcase).first
-              if @user.locked_out?
-                flash[:error] = I18n.t(:session_locked)
-                session[:signin_locked] = true
-                redirect_to '#{arguments[:prefix]}/signin'
-              elsif @user.authenticate(params[:#{model.underscore}][:password])
-                @user.signin(:success)
-                session.delete(:signin_locked)
-                session[:#{model.underscore}_id] = @user.id
-                url = session[:redirect_to] || '#{arguments[:redirect]}'
-                redirect_to url
-              else
-                @user.signin(:failed)
-                if @user.locked_out?
-                  session[:signin_locked] = true
-                  flash[:error] = I18n.t(:session_locking)
-                else
-                  flash[:error] = I18n.t(:session_invalid)
-                end
-                redirect_to '#{arguments[:prefix]}/signin'
-              end
-            else
-              flash[:error] = I18n.t(:session_not_found)
-              redirect_to '#{arguments[:prefix]}/signin'
-            end
-          end
-
-          def destroy
-            flash[:success] = I18n.t(:session_signout)
-            session.delete(:redirect_to)
-            session.delete(:#{model.underscore}_id)
-            redirect_to '#{arguments[:prefix]}/signin'
-          end
-
-          private
-
-            def authenticate_#{model.underscore}
-              if !signed_in?
-                flash[:warning] = I18n.t(:session_interception)
-                session[:redirect_to] = request.path
-                redirect_to '#{arguments[:prefix]}/signin'
-              end
-            end
-
-        EOV
-
-      end
-    end
-
-  end
-end

data/lib/backframe/activerecord/acts_as_activable.rb

@@ -1,50 +0,0 @@
-# encoding: utf-8
-
-module Backframe
-  module ActsAsActivable
-  
-    extend ActiveSupport::Concern
-
-    def self.included(base)
-      base.send :extend, ClassMethods
-    end
-
-    module ClassMethods
-
-      def acts_as_activable(entity, text, link)
-
-        class_eval <<-EOV
-
-          def activities
-            conditions = []
-            conditions << '("activities"."object1_type"=? AND "activities"."object1_id"=?)'
-            conditions << '("activities"."object2_type"=? AND "activities"."object2_id"=?)'
-            conditions << '"activities"."subject_type"=? && "activities"."subject_id"=?' if self.is_a?(Admin) || self.is_a?(Customer)
-            fragment = [conditions.join(' OR '), self.class.name, self.id, self.class.name, self.id]
-            fragment.concat([self.class.name, self.id]) if self.is_a?(Admin) || self.is_a?(Customer)
-            Activity.where(fragment)
-          end
-
-          def activity_entity
-            "#{entity}"
-          end
-
-          def activity_text
-            self.#{text}
-          end
-
-          def activity_link
-            link = "#{link}"
-            "#{link}".scan(/\\\[([\\\w\\\_]*)\\\]/).each do |token|
-              link = link.gsub('['+token.first+']', self.send(token.first).to_s)
-            end
-            link
-          end
-        EOV
-
-      end
-
-    end
-
-  end
-end

data/lib/backframe/activerecord/acts_as_distinct.rb

@@ -1,49 +0,0 @@
-# encoding: utf-8
-
-module Backframe
-  module ActsAsDistinct
-
-    extend ActiveSupport::Concern
-
-    def self.included(base)
-      base.send :extend, ClassMethods
-    end
-
-    module ClassMethods
-
-      def acts_as_distinct(*args)
-
-        field = args[0]
-        arguments = args[1]
-
-        class_eval <<-EOV
-
-          after_initialize :set_default_#{field}, :if => Proc.new { |m| m.new_record? && m.#{arguments[:parent]}.present? }
-          after_save :toggle_#{field}_distinction, :if => Proc.new { |m| m.#{arguments[:parent]}.present? && m.#{field} && (m.new_record? || m.#{field}_changed?) }
-
-          scope :#{field.to_s.gsub('is_', '')}, -> { where(:#{field} => true) }
-
-          def #{field.to_s.gsub('is_', '')}?
-            return self.#{field}
-          end
-
-          private
-
-            def set_default_#{field}
-              self.#{field} = self.#{arguments[:parent]}.#{arguments[:association]}.empty?
-            end
-
-            def toggle_#{field}_distinction
-              self.#{arguments[:parent]}.#{arguments[:association]}.where('id != ?', self.id).each do |item|
-                item.update_attributes(:#{field} => false)
-              end
-            end
-
-        EOV
-
-      end
-
-    end
-
-  end
-end

data/lib/backframe/activerecord/acts_as_enum.rb

@@ -1,62 +0,0 @@
-# encoding: utf-8
-
-module Backframe
-  module ActsAsEnum
-    extend ActiveSupport::Concern
-
-    def self.included(base)
-      base.send :extend, ClassMethods
-    end
-
-    module ClassMethods
-
-      def acts_as_enum(*args)
-
-        field = args[0]
-        arguments = args[1]
-
-        if arguments.key?(:required)
-
-          validates_presence_of field
-
-        end
-
-        if arguments.key?(:default)
-
-          after_initialize "init_#{field}".to_sym, :if => Proc.new { |d| d.new_record? }
-
-          class_eval <<-EOV
-            def init_#{field}
-              self.#{field} ||= '#{arguments[:default]}'
-            end
-          EOV
-
-        end
-
-        if arguments.key?(:in)
-
-          validates_inclusion_of field, :in => arguments[:in]
-
-          class_eval <<-EOV
-            scope :#{field}_is, -> (*options) { where('"#{self.table_name}"."#{field}" IN (?)', (options.is_a?(Array) ? options : [options])) }
-
-            def #{field}_is?(*options)
-              (options.is_a?(Array) ? options : [options]).map(&:to_s).include?(self.#{field})
-            end
-          EOV
-
-          class_eval <<-EOV
-            scope :#{field}_not, -> (*options) { where('"#{self.table_name}"."#{field}" NOT IN (?)', (options.is_a?(Array) ? options : [options])) }
-
-            def #{field}_not?(*options)
-              !(options.is_a?(Array) ? options : [options]).map(&:to_s).include?(self.#{field})
-            end
-          EOV
-
-        end
-
-      end
-
-    end
-  end
-end

data/lib/backframe/activerecord/acts_as_orderable.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-
-module Backframe
-  module ActsAsOrderable
-    extend ActiveSupport::Concern
-
-    def self.included(base)
-      base.send :extend, ClassMethods
-    end
-
-    module ClassMethods
-
-      def acts_as_orderable(field, args = {})
-
-        class_eval <<-EOV
-          validates_presence_of :#{field}
-
-          before_validation :set_#{field}, :on => :create
-          after_destroy :reorder_#{field}
-
-          default_scope -> { order(:#{field} => :asc) }
-
-          def set_#{field}
-            self.#{field} ||= (self.#{args[:on]}.#{self.name.tableize}.any?) ? self.#{args[:on]}.#{self.name.tableize}.maximum(:#{field}) + 1 : 0
-          end
-
-          def reorder_#{field}
-            self.#{args[:on]}.#{self.name.tableize}.order(:#{field} => :asc).each_with_index do |item, index|
-              item.update_column(:#{field}, index)
-            end
-          end
-
-        EOV
-
-      end
-
-    end
-
-  end
-end