login_attack_report 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cfb4e080dba8769ccaeaf9ef1716703178a86445
-  data.tar.gz: 1386ffc5e883023c61c5891d56ffcdd21444368d
+  metadata.gz: 83b80275b8c644e56b383ad22135a52e94e3188d
+  data.tar.gz: ae64da9fc95fb5131185f4add79e6ba46e16e860
 SHA512:
-  metadata.gz: e1db48fc2ea2ced4a8b7bff8f195a0eead38de60a7267e1282cdc9eb2fcea5b882510a6e3434c7da3e2d3ab3afebdfa5c51a3e7ef5e9379e6fdae416c9f7d64e
-  data.tar.gz: 34a9dab676b40a8ce061095310da08a2105755774b28c73c3a9a156cba955958b3289603adb8b962ba06e345d4e175c025584a24a8936731ac8e8ee10a0fb53c
+  metadata.gz: 9ade69377b319c33560880822e528a63aab873213a7d74e5ed12564cdc4a1b823989f6a91283404190889903ab7da66c90ba1c10209f50e3e37c8aff57212739
+  data.tar.gz: fa8c39bff1431eb75406f3bf9ad1aace546270f6d08dbfecc0c908f4898f10246c8706d8217cb231c55d3b337bc89496d795dbc21824dff4eeeaf96b72066f5c

data/.gitignore

@@ -1,4 +1,5 @@
 *.gem
+*.swp
 .bundle
 .config
 .rbenv-version

data/Gemfile

@@ -1,4 +1,4 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in login_attack_report3.gemspec
+# Specify your gem's dependencies in login_attack_report.gemspec
 gemspec

data/README.md

@@ -1,4 +1,4 @@
-# LoginAttackReport3
+# LoginAttackReport
 
 TODO: Write a gem description
 
@@ -7,7 +7,7 @@ TODO: Write a gem description
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'login_attack_report3'
+gem 'login_attack_report'
 ```
 
 And then execute:
@@ -16,7 +16,7 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install login_attack_report3
+    $ gem install login_attack_report
 
 ## Usage
 
@@ -24,7 +24,7 @@ TODO: Write usage instructions here
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/login_attack_report3/fork )
+1. Fork it ( https://github.com/[my-github-username]/login_attack_report/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/lib/login_attack_report/frameworks/active_record/models/login_attack_report_version.rb

@@ -0,0 +1,7 @@
+require 'login_attack_report/login_attack_report_version_concern'
+
+module LoginAttackReport
+  class LoginAttackReportVersion < ::ActiveRecord::Base
+    include LoginAttackReport::LoginAttackReportVersionConcern
+  end
+end

data/lib/login_attack_report/frameworks/active_record.rb

@@ -0,0 +1,4 @@
+#Dir[File.join(File.dirname(__FILE__), 'active_record', 'models', 'login_attack_report', '*.rb')].each do |file|
+#  require "login_attack_report/frameworks/active_record/models/#{File.basename(file, '.rb')}"
+#end
+require "login_attack_report/frameworks/active_record/models/login_attack_report_version.rb"

data/lib/login_attack_report/frameworks/rails/engine.rb

@@ -0,0 +1,7 @@
+module LoginAttackReport
+  module Rails
+    class Engine < ::Rails::Engine
+      paths['app/models'] << 'lib/login_attack_report/frameworks/active_record/models'
+    end
+  end
+end

data/lib/login_attack_report/frameworks/rails.rb

@@ -0,0 +1,6 @@
+require 'login_attack_report/frameworks/rails/engine'
+
+module LoginAttackReport
+  module Rails
+  end
+end

data/lib/login_attack_report/has_login_attack_report.rb

@@ -0,0 +1,504 @@
+require 'active_support/core_ext/object' # provides the `try` method
+
+module LoginAttackReport
+  module Model
+
+    def self.included(base)
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+      # Declare this in your model to track every create, update, and destroy.  Each version of
+      # the model is available in the `versions` association.
+      #
+      # Options:
+      # :on            the events to track (optional; defaults to all of them).  Set to an array of
+      #                `:create`, `:update`, `:destroy` as desired.
+      # :class_name    the name of a custom Version class.  This class should inherit from `PaperTrail::Version`.
+      # :ignore        an array of attributes for which a new `Version` will not be created if only they change.
+      #                it can also aceept a Hash as an argument where the key is the attribute to ignore (a `String` or `Symbol`),
+      #                which will only be ignored if the value is a `Proc` which returns truthily.
+      # :if, :unless   Procs that allow to specify conditions when to save versions for an object
+      # :only          inverse of `ignore` - a new `Version` will be created only for these attributes if supplied
+      #                it can also aceept a Hash as an argument where the key is the attribute to track (a `String` or `Symbol`),
+      #                which will only be counted if the value is a `Proc` which returns truthily.
+      # :skip          fields to ignore completely.  As with `ignore`, updates to these fields will not create
+      #                a new `Version`.  In addition, these fields will not be included in the serialized versions
+      #                of the object whenever a new `Version` is created.
+      # :meta          a hash of extra data to store.  You must add a column to the `versions` table for each key.
+      #                Values are objects or procs (which are called with `self`, i.e. the model with the paper
+      #                trail).  See `PaperTrail::Controller.info_for_paper_trail` for how to store data from
+      #                the controller.
+      # :versions      the name to use for the versions association.  Default is `:versions`.
+      # :version       the name to use for the method which returns the version the instance was reified from.
+      #                Default is `:version`.
+      # :save_changes  whether or not to save changes to the object_changes column if it exists. Default is true
+      #
+      def has_paper_trail(options = {})
+        # Lazily include the instance methods so we don't clutter up
+        # any more ActiveRecord models than we have to.
+        send :include, InstanceMethods
+
+        class_attribute :version_association_name
+        self.version_association_name = options[:version] || :version
+
+        # The version this instance was reified from.
+        attr_accessor self.version_association_name
+
+        class_attribute :version_class_name
+        self.version_class_name = options[:class_name] || 'PaperTrail::Version'
+
+        class_attribute :paper_trail_options
+        self.paper_trail_options = options.dup
+
+        [:ignore, :skip, :only].each do |k|
+          paper_trail_options[k] =
+            [paper_trail_options[k]].flatten.compact.map { |attr| attr.is_a?(Hash) ? attr.stringify_keys : attr.to_s }
+        end
+
+        paper_trail_options[:meta] ||= {}
+        paper_trail_options[:save_changes] = true if paper_trail_options[:save_changes].nil?
+
+        class_attribute :versions_association_name
+        self.versions_association_name = options[:versions] || :versions
+
+        attr_accessor :paper_trail_event
+
+        if ::ActiveRecord::VERSION::MAJOR >= 4 # `has_many` syntax for specifying order uses a lambda in Rails 4
+          has_many self.versions_association_name,
+            lambda { order(model.timestamp_sort_order) },
+            :class_name => self.version_class_name, :as => :item
+        else
+          has_many self.versions_association_name,
+            :class_name => self.version_class_name,
+            :as         => :item,
+            :order      => self.paper_trail_version_class.timestamp_sort_order
+        end
+
+        options[:on] ||= [:create, :update, :destroy]
+        options_on = Array(options[:on]) # so that a single symbol can be passed in without wrapping it in an `Array`
+        after_create  :record_create, :if => :save_version? if options_on.include?(:create)
+        if options_on.include?(:update)
+          before_save   :reset_timestamp_attrs_for_update_if_needed!, :on => :update
+          after_update  :record_update, :if => :save_version?
+          after_update  :clear_version_instance!
+        end
+        after_destroy :record_destroy, :if => :save_version? if options_on.include?(:destroy)
+
+        # Reset the transaction id when the transaction is closed
+        after_commit :reset_transaction_id
+        after_rollback :reset_transaction_id
+        after_rollback :clear_rolled_back_versions
+      end
+
+      # Switches PaperTrail off for this class.
+      def paper_trail_off!
+        PaperTrail.enabled_for_model(self, false)
+      end
+
+      def paper_trail_off
+        warn "DEPRECATED: use `paper_trail_off!` instead of `paper_trail_off`. Support for `paper_trail_off` will be removed in PaperTrail 4.0"
+        self.paper_trail_off!
+      end
+
+      # Switches PaperTrail on for this class.
+      def paper_trail_on!
+        PaperTrail.enabled_for_model(self, true)
+      end
+
+      def paper_trail_on
+        warn "DEPRECATED: use `paper_trail_on!` instead of `paper_trail_on`. Support for `paper_trail_on` will be removed in PaperTrail 4.0"
+        self.paper_trail_on!
+      end
+
+      def paper_trail_enabled_for_model?
+        return false unless self.include?(PaperTrail::Model::InstanceMethods)
+        PaperTrail.enabled_for_model?(self)
+      end
+
+      def paper_trail_version_class
+        @paper_trail_version_class ||= version_class_name.constantize
+      end
+
+      # Used for Version#object attribute
+      def serialize_attributes_for_paper_trail!(attributes)
+        # don't serialize before values before inserting into columns of type `JSON` on `PostgreSQL` databases
+        return attributes if self.paper_trail_version_class.object_col_is_json?
+
+        serialized_attributes.each do |key, coder|
+          if attributes.key?(key)
+            # Fall back to current serializer if `coder` has no `dump` method
+            coder = PaperTrail.serializer unless coder.respond_to?(:dump)
+            attributes[key] = coder.dump(attributes[key])
+          end
+        end
+      end
+
+      def unserialize_attributes_for_paper_trail!(attributes)
+        # don't serialize before values before inserting into columns of type `JSON` on `PostgreSQL` databases
+        return attributes if self.paper_trail_version_class.object_col_is_json?
+
+        serialized_attributes.each do |key, coder|
+          if attributes.key?(key)
+            coder = PaperTrail.serializer unless coder.respond_to?(:dump)
+            attributes[key] = coder.load(attributes[key])
+          end
+        end
+      end
+
+      # Used for Version#object_changes attribute
+      def serialize_attribute_changes_for_paper_trail!(changes)
+        # don't serialize before values before inserting into columns of type `JSON` on `PostgreSQL` databases
+        return changes if self.paper_trail_version_class.object_changes_col_is_json?
+
+        serialized_attributes.each do |key, coder|
+          if changes.key?(key)
+            # Fall back to current serializer if `coder` has no `dump` method
+            coder = PaperTrail.serializer unless coder.respond_to?(:dump)
+            old_value, new_value = changes[key]
+            changes[key] = [coder.dump(old_value),
+                            coder.dump(new_value)]
+          end
+        end
+      end
+
+      def unserialize_attribute_changes_for_paper_trail!(changes)
+        # don't serialize before values before inserting into columns of type `JSON` on `PostgreSQL` databases
+        return changes if self.paper_trail_version_class.object_changes_col_is_json?
+
+        serialized_attributes.each do |key, coder|
+          if changes.key?(key)
+            coder = PaperTrail.serializer unless coder.respond_to?(:dump)
+            old_value, new_value = changes[key]
+            changes[key] = [coder.load(old_value),
+                            coder.load(new_value)]
+          end
+        end
+      end
+    end
+
+    # Wrap the following methods in a module so we can include them only in the
+    # ActiveRecord models that declare `has_paper_trail`.
+    module InstanceMethods
+      # Returns true if this instance is the current, live one;
+      # returns false if this instance came from a previous version.
+      def live?
+        source_version.nil?
+      end
+
+      # Returns who put the object into its current state.
+      def paper_trail_originator
+        (source_version || send(self.class.versions_association_name).last).try(:whodunnit)
+      end
+
+      def originator
+        warn "DEPRECATED: use `paper_trail_originator` instead of `originator`. Support for `originator` will be removed in PaperTrail 4.0"
+        self.paper_trail_originator
+      end
+
+      # Invoked after rollbacks to ensure versions records are not created
+      # for changes that never actually took place
+      def clear_rolled_back_versions
+        send(self.class.versions_association_name).reload
+      end
+
+      # Returns the object (not a Version) as it was at the given timestamp.
+      def version_at(timestamp, reify_options={})
+        # Because a version stores how its object looked *before* the change,
+        # we need to look for the first version created *after* the timestamp.
+        v = send(self.class.versions_association_name).subsequent(timestamp, true).first
+        return v.reify(reify_options) if v
+        self unless self.destroyed?
+      end
+
+      # Returns the objects (not Versions) as they were between the given times.
+      def versions_between(start_time, end_time, reify_options={})
+        versions = send(self.class.versions_association_name).between(start_time, end_time)
+        versions.collect { |version| version_at(version.send PaperTrail.timestamp_field) }
+      end
+
+      # Returns the object (not a Version) as it was most recently.
+      def previous_version
+        preceding_version = source_version ? source_version.previous : send(self.class.versions_association_name).last
+        preceding_version.reify if preceding_version
+      end
+
+      # Returns the object (not a Version) as it became next.
+      # NOTE: if self (the item) was not reified from a version, i.e. it is the
+      #  "live" item, we return nil.  Perhaps we should return self instead?
+      def next_version
+        subsequent_version = source_version.next
+        subsequent_version ? subsequent_version.reify : self.class.find(self.id)
+      rescue
+        nil
+      end
+
+      def paper_trail_enabled_for_model?
+        self.class.paper_trail_enabled_for_model?
+      end
+
+      # Executes the given method or block without creating a new version.
+      def without_versioning(method = nil)
+        paper_trail_was_enabled = self.paper_trail_enabled_for_model?
+        self.class.paper_trail_off!
+        method ? method.to_proc.call(self) : yield(self)
+      ensure
+        self.class.paper_trail_on! if paper_trail_was_enabled
+      end
+
+      # Utility method for reifying. Anything executed inside the block will appear like a new record
+      def appear_as_new_record
+        instance_eval {
+          alias :old_new_record? :new_record?
+          alias :new_record? :present?
+        }
+        yield
+        instance_eval { alias :new_record? :old_new_record? }
+      end
+
+      # Temporarily overwrites the value of whodunnit and then executes the provided block.
+      def whodunnit(value)
+        raise ArgumentError, 'expected to receive a block' unless block_given?
+        current_whodunnit = PaperTrail.whodunnit
+        PaperTrail.whodunnit = value
+        yield self
+      ensure
+        PaperTrail.whodunnit = current_whodunnit
+      end
+
+      # Mimicks behavior of `touch` method from `ActiveRecord::Persistence`, but generates a version
+      #
+      # TODO: lookinto leveraging the `after_touch` callback from `ActiveRecord` to allow the
+      #  regular `touch` method go generate a version as normal. May make sense to switch the `record_update`
+      #  method to leverage an `after_update` callback anyways (likely for v4.0.0)
+      def touch_with_version(name = nil)
+        raise ActiveRecordError, "can not touch on a new record object" unless persisted?
+
+        attributes = timestamp_attributes_for_update_in_model
+        attributes << name if name
+        current_time = current_time_from_proper_timezone
+
+        attributes.each { |column| write_attribute(column, current_time) }
+        # ensure a version is written even if the `:on` collection is empty
+        record_update(true) if paper_trail_options[:on] == []
+        save!(:validate => false)
+      end
+
+      private
+
+      def source_version
+        send self.class.version_association_name
+      end
+
+      def record_create
+        if paper_trail_switched_on?
+          data = {
+            :event     => paper_trail_event || 'create',
+            :whodunnit => PaperTrail.whodunnit
+          }
+          if respond_to?(:created_at)
+            data[PaperTrail.timestamp_field] = created_at
+          end
+          if paper_trail_options[:save_changes] && changed_notably? && self.class.paper_trail_version_class.column_names.include?('object_changes')
+            data[:object_changes] = self.class.paper_trail_version_class.object_changes_col_is_json? ? changes_for_paper_trail :
+              PaperTrail.serializer.dump(changes_for_paper_trail)
+          end
+          if self.class.paper_trail_version_class.column_names.include?('transaction_id')
+            data[:transaction_id] = PaperTrail.transaction_id
+          end
+          version = send(self.class.versions_association_name).create! merge_metadata(data)
+          set_transaction_id(version)
+          save_associations(version)
+        end
+      end
+
+      def record_update(force = nil)
+        if paper_trail_switched_on? && (force || changed_notably?)
+          object_attrs = object_attrs_for_paper_trail(attributes_before_change)
+          data = {
+            :event     => paper_trail_event || 'update',
+            :object    => self.class.paper_trail_version_class.object_col_is_json? ? object_attrs : PaperTrail.serializer.dump(object_attrs),
+            :whodunnit => PaperTrail.whodunnit
+          }
+          if respond_to?(:updated_at)
+            data[PaperTrail.timestamp_field] = updated_at
+          end
+          if paper_trail_options[:save_changes] && self.class.paper_trail_version_class.column_names.include?('object_changes')
+            data[:object_changes] = self.class.paper_trail_version_class.object_changes_col_is_json? ? changes_for_paper_trail :
+              PaperTrail.serializer.dump(changes_for_paper_trail)
+          end
+          if self.class.paper_trail_version_class.column_names.include?('transaction_id')
+            data[:transaction_id] = PaperTrail.transaction_id
+          end
+          version = send(self.class.versions_association_name).create merge_metadata(data)
+          set_transaction_id(version)
+          save_associations(version)
+        end
+      end
+
+      def changes_for_paper_trail
+        _changes = changes.delete_if { |k,v| !notably_changed.include?(k) }
+        if PaperTrail.serialized_attributes?
+          self.class.serialize_attribute_changes_for_paper_trail!(_changes)
+        end
+        _changes.to_hash
+      end
+
+      # Invoked via`after_update` callback for when a previous version is reified and then saved
+      def clear_version_instance!
+        send("#{self.class.version_association_name}=", nil)
+      end
+
+      def reset_timestamp_attrs_for_update_if_needed!
+        return if self.live? # invoked via callback when a user attempts to persist a reified `Version`
+        timestamp_attributes_for_update_in_model.each do |column|
+          # ActiveRecord 4.2 deprecated `reset_column!` in favor of `restore_column!`
+          if respond_to?("restore_#{column}!")
+            send("restore_#{column}!")
+          else
+            send("reset_#{column}!")
+          end
+        end
+      end
+
+      def record_destroy
+        if paper_trail_switched_on? and not new_record?
+          object_attrs = object_attrs_for_paper_trail(attributes_before_change)
+          data = {
+            :item_id   => self.id,
+            :item_type => self.class.base_class.name,
+            :event     => paper_trail_event || 'destroy',
+            :object    => self.class.paper_trail_version_class.object_col_is_json? ? object_attrs : PaperTrail.serializer.dump(object_attrs),
+            :whodunnit => PaperTrail.whodunnit
+          }
+          if self.class.paper_trail_version_class.column_names.include?('transaction_id')
+            data[:transaction_id] = PaperTrail.transaction_id
+          end
+          version = self.class.paper_trail_version_class.create(merge_metadata(data))
+          send("#{self.class.version_association_name}=", version)
+          send(self.class.versions_association_name).send :load_target
+          set_transaction_id(version)
+          save_associations(version)
+        end
+      end
+
+      # saves associations if the join table for `VersionAssociation` exists
+      def save_associations(version)
+        return unless PaperTrail.config.track_associations?
+        self.class.reflect_on_all_associations(:belongs_to).each do |assoc|
+          assoc_version_args = {
+              :version_id => version.id,
+              :foreign_key_name => assoc.foreign_key
+          }
+
+          if assoc.options[:polymorphic]
+            associated_record = send(assoc.name) if send(assoc.foreign_type)
+            if associated_record && associated_record.class.paper_trail_enabled_for_model?
+              assoc_version_args.merge!(:foreign_key_id => associated_record.id)
+            end
+          elsif assoc.klass.paper_trail_enabled_for_model?
+            assoc_version_args.merge!(:foreign_key_id => send(assoc.foreign_key))
+          end
+
+          PaperTrail::VersionAssociation.create(assoc_version_args) if assoc_version_args.has_key?(:foreign_key_id)
+        end
+      end
+
+      def set_transaction_id(version)
+        return unless self.class.paper_trail_version_class.column_names.include?('transaction_id')
+        if PaperTrail.transaction? && PaperTrail.transaction_id.nil?
+           PaperTrail.transaction_id = version.id
+           version.transaction_id = version.id
+           version.save
+        end
+      end
+
+      def reset_transaction_id
+        PaperTrail.transaction_id = nil
+      end
+
+      def merge_metadata(data)
+        # First we merge the model-level metadata in `meta`.
+        paper_trail_options[:meta].each do |k,v|
+          data[k] =
+            if v.respond_to?(:call)
+              v.call(self)
+            elsif v.is_a?(Symbol) && respond_to?(v)
+              # if it is an attribute that is changing in an existing object,
+              # be sure to grab the current version
+              if has_attribute?(v) && send("#{v}_changed?".to_sym) && data[:event] != 'create'
+                send("#{v}_was".to_sym)
+              else
+                send(v)
+              end
+            else
+              v
+            end
+        end
+        # Second we merge any extra data from the controller (if available).
+        data.merge(PaperTrail.controller_info || {})
+      end
+
+      def attributes_before_change
+        attributes.tap do |prev|
+          enums = self.respond_to?(:defined_enums) ? self.defined_enums : {}
+          changed_attributes.select { |k,v| self.class.column_names.include?(k) }.each do |attr, before|
+            before = enums[attr][before] if enums[attr]
+            prev[attr] = before
+          end
+        end
+      end
+
+      # returns hash of attributes (with appropriate attributes serialized),
+      # ommitting attributes to be skipped
+      def object_attrs_for_paper_trail(attributes_hash)
+        attrs = attributes_hash.except(*self.paper_trail_options[:skip])
+        if PaperTrail.serialized_attributes?
+          self.class.serialize_attributes_for_paper_trail!(attrs)
+        end
+        attrs
+      end
+
+      # This method is invoked in order to determine whether it is appropriate to generate a new version instance.
+      # Because we are now using `after_(create/update/etc)` callbacks, we need to go out of our way to
+      # ensure that during updates timestamp attributes are not acknowledged as a notable changes
+      # to raise false positives when attributes are ignored.
+      def changed_notably?
+        if self.paper_trail_options[:ignore].any? && (changed & self.paper_trail_options[:ignore]).any?
+          (notably_changed - timestamp_attributes_for_update_in_model.map(&:to_s)).any?
+        else
+          notably_changed.any?
+        end
+      end
+
+      def notably_changed
+        only = self.paper_trail_options[:only].dup
+        # remove Hash arguments and then evaluate whether the attributes (the keys of the hash) should also get pushed into the collection
+        only.delete_if do |obj|
+          obj.is_a?(Hash) && obj.each { |attr, condition| only << attr if condition.respond_to?(:call) && condition.call(self) }
+        end
+        only.empty? ? changed_and_not_ignored : (changed_and_not_ignored & only)
+      end
+
+      def changed_and_not_ignored
+        ignore = self.paper_trail_options[:ignore].dup
+         # remove Hash arguments and then evaluate whether the attributes (the keys of the hash) should also get pushed into the collection
+        ignore.delete_if do |obj|
+          obj.is_a?(Hash) && obj.each { |attr, condition| ignore << attr if condition.respond_to?(:call) && condition.call(self) }
+        end
+        skip = self.paper_trail_options[:skip]
+        changed - ignore - skip
+      end
+
+      def paper_trail_switched_on?
+        PaperTrail.enabled? && PaperTrail.enabled_for_controller? && self.paper_trail_enabled_for_model?
+      end
+
+      def save_version?
+        if_condition     = self.paper_trail_options[:if]
+        unless_condition = self.paper_trail_options[:unless]
+        (if_condition.blank? || if_condition.call(self)) && !unless_condition.try(:call, self)
+      end
+    end
+  end
+end

data/lib/login_attack_report/login_attack_report_version_concern.rb

@@ -0,0 +1,85 @@
+require 'active_support/concern'
+
+module LoginAttackReport
+  module LoginAttackReportVersionConcern
+    extend ::ActiveSupport::Concern
+
+    module ClassMethods
+      def login_ok_limit_over
+        # TODO config
+        model = :User
+        login_limit = 200
+        login_err_limit = 50
+
+        PaperTrail::Version
+          .where(item_type: model)
+          .where(
+            'created_at >= ? and created_at <= ? and ' \
+            'object_changes like \'%sign_in_count:%\'',
+            Time.now.prev_month.beginning_of_month,
+            Time.now.prev_month.end_of_month
+          ).group(:item_id).having("count(item_id) > #{login_limit}")
+      end
+
+      def alert_login_ng_limit_over
+        # TODO config
+        model = :User
+        login_limit = 200
+        login_err_limit = 50
+
+        PaperTrail::Version
+          .where(item_type: model)
+          .where(
+            'created_at >= ? and created_at <= ? and ' \
+            'object_changes like \'%sign_in_count:%\'',
+            Time.now.prev_month.beginning_of_month,
+            Time.now.prev_month.end_of_month
+          ).group(:item_id).having("count(item_id) > #{login_limit}")
+      end
+      def alert_ip_limit_over
+        # TODO config
+        model = :User
+        login_limit = 200
+        login_err_limit = 50
+        alert_ip_limit_over = PaperTrail::Version
+                              .where(item_type: model)
+                              .where(
+                                'created_at >= ? and created_at <= ? and ' \
+                                '(object_changes like \'%sign_in_count:%\' or ' \
+                                  'object_changes like \'--- !ruby/hash:ActiveSupport::HashWithIndifferentAccess\nfailed_attempts:%\'' \
+                                ')',
+                                Time.now.prev_month.beginning_of_month,
+                                Time.now.prev_month.end_of_month
+                              )
+
+        if alert_ip_limit_over.present?
+          ok_hash = Hash.new({})
+          ng_hash = Hash.new({})
+          alert_ip_limit_over.find_each do |version|
+            # アクセス元ipアドレス取得
+            if /current_sign_in_ip/ =~ version.object_changes
+              current_sign_in_ip = YAML.load(version.object_changes)['current_sign_in_ip'][1]
+            else
+              current_sign_in_ip = YAML.load(version.object)['current_sign_in_ip']
+            end
+            # ログイン成功回数取得
+            if /sign_in_count/ =~ version.object_changes
+              if ok_hash[current_sign_in_ip].present?
+                ok_hash[current_sign_in_ip] += 1
+              else
+                ok_hash[current_sign_in_ip] = 1
+              end
+            # ログイン失敗回数取得
+            else
+              if ng_hash[current_sign_in_ip].present?
+                ng_hash[current_sign_in_ip] += 1
+              else
+                ng_hash[current_sign_in_ip] = 1
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/login_attack_report/version.rb

@@ -1,3 +1,3 @@
 module LoginAttackReport
-  VERSION = "0.0.1"
+  VERSION = '0.0.2'
 end

data/lib/login_attack_report.rb

@@ -1,4 +1,14 @@
-require "login_attack_report/version"
+require 'login_attack_report/version'
+require 'active_support'
+require 'active_record'
+require 'paper_trail'
+require 'rails'
+
+Dir[File.join(File.dirname(__FILE__), 'login_attack_report', '*.rb')].each do |file|
+  require File.join('login_attack_report', File.basename(file, '.rb'))
+end
+require 'login_attack_report/frameworks/active_record'
+require 'login_attack_report/frameworks/rails'
 
 module LoginAttackReport
   # Your code goes here...
@@ -6,3 +16,7 @@ module LoginAttackReport
     "call new_method"
   end
 end
+
+ActiveSupport.on_load(:active_record) do
+  include LoginAttackReport::Model
+end

data/login_attack_report.gemspec

@@ -19,13 +19,16 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.required_rubygems_version = '>= 1.3.6'
+  spec.required_rubygems_version = '>= 1.9.0'
 
-  spec.add_dependency 'rails', '>= 4.0.0'
-  spec.add_dependency 'paper_trail', '>= 3.0.0'
+  spec.add_dependency 'rails', ['>= 3.0', '< 6.0']
+  spec.add_dependency 'activerecord', ['>= 3.0', '< 6.0']
+  spec.add_dependency 'activesupport', ['>= 3.0', '< 6.0']
+  spec.add_dependency 'paper_trail', ['>= 3.0', '< 6.0']
   spec.add_dependency 'devise', '>= 3.2.2'
 
   spec.add_development_dependency 'bundler', '~> 1.7'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'pry'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: login_attack_report
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - taru m
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-18 00:00:00.000000000 Z
+date: 2015-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,28 +16,80 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: paper_trail
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: devise
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +146,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: login attack report in Rails.
 email:
 - Write your email address
@@ -109,6 +175,12 @@ files:
 - README.md
 - Rakefile
 - lib/login_attack_report.rb
+- lib/login_attack_report/frameworks/active_record.rb
+- lib/login_attack_report/frameworks/active_record/models/login_attack_report_version.rb
+- lib/login_attack_report/frameworks/rails.rb
+- lib/login_attack_report/frameworks/rails/engine.rb
+- lib/login_attack_report/has_login_attack_report.rb
+- lib/login_attack_report/login_attack_report_version_concern.rb
 - lib/login_attack_report/version.rb
 - login_attack_report.gemspec
 - spec/login_attack_report_spec.rb
@@ -130,7 +202,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.6
+      version: 1.9.0
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.0