hancock_cms_cache 1.0.2

data/lib/hancock/cache/models/mongoid/fragment.rb

@@ -0,0 +1,259 @@
+module Hancock::Cache
+  module Models::Mongoid
+    module Fragment
+      extend ActiveSupport::Concern
+
+      included do
+
+        include Hancock::Cache::Snapshotable
+
+        index({name: 1}, {unique: true, background: true})
+        index({last_clear_user_id: 1, last_clear_time: 1}, {background: true})
+
+        field :name, type: String, localize: false, default: ""
+        scope :by_name, -> (_name) {
+          if _name.is_a?(Array)
+            where(:name.in => _name.compact.map(&:strip))
+          else
+            if _name.is_a?(String)
+              where(name: (_name and _name.strip))
+            else
+              where(name: _name)
+            end
+          end
+        }
+        scope :by_name_from_view, -> (_name) {
+          by_name(self.name_from_view(_name))
+        }
+        scope :find_by_name, -> (_name) {
+          by_name(_name).first
+        }
+        scope :find_by_name_from_view, -> (_name) {
+          by_name_from_view(_name).first
+        }
+
+        field :desc, type: String, localize: Hancock::Cache.config.localize, default: ""
+        field :virtual_path, type: String, localize: false, default: ""
+        field :is_html, type: Boolean, default: true
+
+        field :is_action_cache, type: Boolean, default: false
+        scope :is_action_cache, ->  {
+          where(is_action_cache: true)
+        }
+
+        field :on_ram, type: Boolean, default: false
+        scope :on_ram, ->  {
+          where(on_ram: true)
+        }
+        attr_accessor :on_ram_data
+        def load_data_on_ram
+          if self.on_ram and !self.name.blank?
+            self.on_ram_data = Rails.cache.read(self.name)
+          end
+        end
+
+        field :last_clear_time, type: DateTime
+        if Hancock.rails4?
+          belongs_to :last_clear_user, class_name: Mongoid::Userstamp.config.user_model_name, autosave: false
+        else
+          belongs_to :last_clear_user, class_name: Mongoid::Userstamp.config.user_model_name, autosave: false, optional: true, required: false
+
+          if relations.has_key?("updater") and defined?(::Mongoid::History)
+            belongs_to :updater, class_name: ::Mongoid::History.modifier_class_name, optional: true, validate: false
+            _validators.delete(:updater)
+            _validate_callbacks.each do |callback|
+              if callback.raw_filter.respond_to?(:attributes) and callback.raw_filter.attributes.include?(:updater)
+                _validate_callbacks.delete(callback)
+              end
+            end
+          end
+        end
+
+        has_and_belongs_to_many :parents, class_name: "Hancock::Cache::Fragment", inverse_of: nil
+        field :parent_names, type: Array, default: []
+        def set_parent_names
+          self.parent_names = self.parents.distinct(:name)
+        end
+        def set_parent_names!
+          self.set_parent_names and self.save
+        end
+        def update_parent_names!
+          self.set_parent_names and self.class.where(id: self.id).update(parent_names: self.parent_names)
+        end
+        before_save do
+          if self.parent_ids_changed?
+            self.set_parent_names
+          end
+          self
+        end
+        def set_parent_ids
+          self.parent_ids = self.class.by_name(self.parent_names).distinct(:_id) unless self.parent_names.blank?
+        end
+        def set_parent_ids!
+          self.set_parent_ids and self.save
+        end
+        def update_parent_ids!
+          self.set_parent_ids and self.class.where(id: self.id).update(parent_ids: self.parent_ids, parent_names: self.parent_names)
+        end
+
+        def reset_parents
+          self.parent_ids = self.parents.distinct(:_id)
+        end
+        def reset_parents!
+          self.reset_parents and self.save
+        end
+        def self.reset_parents!
+          self.all.map(&:reset_parents!)
+        end
+
+        def name_n_desc
+          "#{self.name}<hr>#{self.desc}".html_safe
+        end
+        def parents_str
+          self.parents.map(&:name).join(", ")
+        end
+        def name_n_desc_n_parents
+          "#{self.name}<hr>#{self.desc}<hr>#{parents_str}".html_safe
+        end
+
+        def last_clear_data
+          "#{self.last_clear_time}<hr>#{self.last_clear_user}".html_safe
+        end
+        def snapshot_data
+          "#{self.last_dump_snapshot_time}<hr>#{self.last_restore_snapshot_time}<hr>#{self.get_snapshot(false)}".html_safe
+        end
+
+        def data(prettify = true)
+          _data = Rails.cache.read(self.name)
+          if prettify
+            if self.is_html
+              "<pre>#{CGI::escapeHTML(Nokogiri::HTML.fragment(_data).to_xhtml(indent: 2))}</pre>".html_safe
+            else
+              _data
+            end
+          else
+            _data
+          end
+        end
+
+        def set_last_clear_user(forced_user = nil)
+          unless forced_user
+            return false unless Mongoid::Userstamp.has_current_user?
+            self.last_clear_user = Mongoid::Userstamp.current_user
+          else
+            self.last_clear_user = forced_user
+          end
+        end
+
+        def self.set_for_object(key_name, obj)
+          if key_name.is_a?(Array)
+            return key_name.map do |k|
+              set_for_object(k, obj) unless k.blank?
+            end
+          else
+            _frag = self.where(name: key_name).first
+            _frag and _frag.set_for_object obj
+          end
+        end
+        def self.set_for_objects(key_name, _class)
+          if key_name.is_a?(Array)
+            return key_name.map do |k|
+              set_for_objects(k, _class) unless k.blank?
+            end
+          else
+            _frag = self.where(name: key_name).first
+            _frag and _frag.set_for_objects _class
+          end
+        end
+
+        # def set_for_object(obj)
+        #   if obj.is_a?(Hash)
+        #     if obj[:model].present?
+        #       if obj[:ids].present?
+        #         return obj[:ids].map do |_id|
+        #           set_for_object({model: obj[:model], id: _id}) unless _id.blank?
+        #         end
+        #       else
+        #         if obj[:id].nil?
+        #           return set_for_objects(obj[:model])
+        #         else
+        #           obj = obj[:model].where(id: obj[:id]).first
+        #         end
+        #       end
+        #     else
+        #       return false
+        #     end
+        #
+        #   elsif obj.is_a?(Array)
+        #     return obj.map do |_obj|
+        #       set_for_object(_obj) unless _obj.blank?
+        #     end
+        #   end
+        #
+        #   if obj
+        #     if obj.is_a?(Class)
+        #       set_for_objects obj
+        #     else
+        #       unless obj.cache_keys.include?(self.name)
+        #         obj.set(cache_keys_str: (obj.cache_keys << self.name).uniq.join("\n"))
+        #         obj.reload
+        #       end
+        #     end
+        #   end
+        # end
+        # def set_for_objects(_class)
+        #   _class.all.map { |obj|
+        #     unless obj.cache_keys.include?(self.name)
+        #       obj.set(cache_keys_str: (obj.cache_keys << self.name).uniq.join("\n"))
+        #       obj.reload
+        #     end
+        #   }
+        # end
+
+        def self.set_for_setting(key_name, setting_obj)
+          if key_name.is_a?(Array)
+            return key_name.map do |k|
+              set_for_setting(k, setting_obj) unless k.blank?
+            end
+          else
+            _frag = self.where(name: key_name).first
+            _frag and _frag.set_for_setting setting_obj
+          end
+        end
+        # def set_for_setting(setting_obj)
+        #   if defined?(RailsAdminModelSettings)
+        #     if setting_obj.is_a?(Hash)
+        #       unless setting_obj[:keys].present?
+        #         if setting_obj[:key].nil?
+        #           return set_for_setting({ns: setting_obj[:ns], key: //})
+        #         else
+        #           setting_obj = RailsAdminSettings::Setting.where(ns: setting_obj[:ns], key: setting_obj[:key]).first
+        #         end
+        #
+        #       else
+        #         return setting_obj[:keys].map do |k|
+        #           set_for_setting({ns: setting_obj[:ns], key: k}) unless k.blank?
+        #         end
+        #       end
+        #
+        #     elsif setting_obj.is_a?(Array)
+        #       return setting_obj.map do |obj|
+        #         set_for_setting(obj) unless obj.blank?
+        #       end
+        #     end
+        #
+        #     setting_obj and set_for_object(setting_obj) and setting_obj.reload
+        #   end
+        # end
+
+      end
+
+      class_methods do
+        def track_history?
+          false
+        end
+      end
+
+    end
+  end
+end

data/lib/hancock/cache/rails_admin_ext/hancock_cache_clear.rb

@@ -0,0 +1,95 @@
+require 'rails_admin/config/actions'
+
+module RailsAdmin
+  module Config
+    module Actions
+      class HancockCacheClear < Base
+        RailsAdmin::Config::Actions.register(self)
+
+        # Is the action acting on the root level (Example: /admin/contact)
+        register_instance_option :root? do
+          false
+        end
+
+        register_instance_option :collection? do
+          false
+        end
+
+        # Is the action on an object scope (Example: /admin/team/1/edit)
+        register_instance_option :member? do
+          true
+        end
+
+        register_instance_option :controller do
+          proc do
+            ajax_link = Proc.new do |fv, badge|
+              # can_edit_obj = can?(:edit, @object)
+              # render json: {
+              #   text: fv.html_safe,
+              #   href: hancock_cache_clear_path(model_name: @abstract_model, id: @object.id),
+              #   class: 'label ' + badge,
+              #   url: index_path(model_name: @abstract_model)
+              # }
+            end
+            if params['id'].present?
+              begin
+                @object = @abstract_model.model.unscoped.find(params['id'])
+                if @object.clear!
+                  if params['ajax'].present?
+                    ajax_link.call('♻', 'label-success')
+                  else
+                    flash[:success] = I18n.t('admin.hancock_cache_clear.cleared', obj: @object, name: @object.name)
+                    # unless @object.parents.blank?
+                    #   flash[:info] = "Также, возможно необходимо сбросить кеш с этми ключами: #{@object.parents_str}"
+                    # end
+                  end
+                else
+                  if params['ajax'].present?
+                    render plain: @object.errors.full_messages.join(', '), layout: false, status: 422
+                  else
+                    flash[:error] = @object.errors.full_messages.join(', ')
+                  end
+                end
+              rescue Exception => e
+                if params['ajax'].present?
+                  render plain: I18n.t('admin.hancock_cache_clear.error', err: e.to_s), status: 422
+                else
+                  flash[:error] = I18n.t('admin.hancock_cache_clear.error', err: e.to_s)
+                end
+              end
+            else
+              if params['ajax'].present?
+                render plain: I18n.t('admin.hancock_cache_clear.no_id'), status: 422
+              else
+                flash[:error] = I18n.t('admin.hancock_cache_clear.no_id')
+              end
+            end
+
+            unless params['ajax'].present?
+              begin
+                fallback_location = index_path(model_name: @abstract_model, id: @object.id)
+              rescue
+                fallback_location = index_path(model_name: @abstract_model)
+              end
+              redirect_back(fallback_location: fallback_location)
+            end
+
+          end
+        end
+
+        register_instance_option :link_icon do
+          'icon-trash'
+        end
+
+        register_instance_option :pjax? do
+          false
+        end
+
+        register_instance_option :http_methods do
+          [:get]
+        end
+
+      end
+    end
+  end
+end

data/lib/hancock/cache/rails_admin_ext/hancock_cache_dump_snapshot.rb

@@ -0,0 +1,92 @@
+require 'rails_admin/config/actions'
+
+module RailsAdmin
+  module Config
+    module Actions
+      class HancockCacheDumpSnapshot < Base
+        RailsAdmin::Config::Actions.register(self)
+
+        # Is the action acting on the root level (Example: /admin/contact)
+        register_instance_option :root? do
+          false
+        end
+
+        register_instance_option :collection? do
+          false
+        end
+
+        # Is the action on an object scope (Example: /admin/team/1/edit)
+        register_instance_option :member? do
+          true
+        end
+
+        register_instance_option :controller do
+          proc do
+            ajax_link = Proc.new do |fv, badge|
+              # can_edit_obj = can?(:edit, @object)
+              # render json: {
+              #   text: fv.html_safe,
+              #   href: hancock_cache_clear_path(model_name: @abstract_model, id: @object.id),
+              #   class: 'label ' + badge,
+              #   url: index_path(model_name: @abstract_model)
+              # }
+            end
+            if params['id'].present?
+              begin
+                @object = @abstract_model.model.unscoped.find(params['id'])
+                if @object.dump_snapshot!
+                  if params['ajax'].present?
+                    ajax_link.call('♻', 'label-success')
+                  else
+                    flash[:success] = I18n.t('admin.hancock_cache_dump_snapshot.dumped', obj: @object)
+                  end
+                else
+                  if params['ajax'].present?
+                    render plain: @object.errors.full_messages.join(', '), layout: false, status: 422
+                  else
+                    flash[:error] = @object.errors.full_messages.join(', ')
+                  end
+                end
+              rescue Exception => e
+                if params['ajax'].present?
+                  render plain: I18n.t('admin.hancock_cache_dump_snapshot.error', err: e.to_s), status: 422
+                else
+                  flash[:error] = I18n.t('admin.hancock_cache_dump_snapshot.error', err: e.to_s)
+                end
+              end
+            else
+              if params['ajax'].present?
+                render plain: I18n.t('admin.hancock_cache_dump_snapshot.no_id'), status: 422
+              else
+                flash[:error] = I18n.t('admin.hancock_cache_dump_snapshot.no_id')
+              end
+            end
+
+            unless params['ajax'].present?
+              begin
+                fallback_location = index_path(model_name: @abstract_model, id: @object.id)
+              rescue
+                fallback_location = index_path(model_name: @abstract_model)
+              end
+              redirect_back(fallback_location: fallback_location)
+            end
+
+          end
+        end
+
+        register_instance_option :link_icon do
+          'fa fa-save'
+        end
+
+        register_instance_option :pjax? do
+          false
+        end
+
+        register_instance_option :http_methods do
+          [:get]
+        end
+
+      end
+    end
+  end
+end

data/lib/hancock/cache/rails_admin_ext/hancock_cache_global_clear.rb

@@ -0,0 +1,74 @@
+require 'rails_admin/config/actions'
+
+module RailsAdmin
+  module Config
+    module Actions
+      class HancockCacheGlobalClear < Base
+        RailsAdmin::Config::Actions.register(self)
+
+        # Is the action acting on the root level (Example: /admin/contact)
+        register_instance_option :root? do
+          false
+        end
+
+        register_instance_option :collection? do
+          true
+        end
+
+        # Is the action on an object scope (Example: /admin/team/1/edit)
+        register_instance_option :member? do
+          false
+        end
+
+        register_instance_option :route_fragment do
+          'hancock_cache_global_clear'
+        end
+
+        register_instance_option :controller do
+          Proc.new do |klass|
+            # @config = ::HancockCacheGlobalClear::Configuration.new @abstract_model
+            if request.get?
+              render action: @action.template_name
+
+            elsif request.post?
+              case params[:type].to_s
+              when "global"
+                begin
+                  Rails.cache.clear
+                  ::Hancock::Cache::Fragment.all.to_a.map(&:clear_dry!)
+                  flash[:success] = 'Весь кеш очищен'
+                rescue Exception => ex
+                  flash[:error] = 'Ошибка'
+                end
+              when "fragments"
+                begin
+                  # Hancock::Cache::Fragment.all.to_a.map do |f|
+                  #   f.clear!
+                  # end
+                  ::Hancock::Cache::Fragment.clear_all
+                  flash[:success] = 'Кеш очищен'
+                rescue Exception => ex
+                  flash[:error] = 'Ошибка'
+                end
+              else
+                flash[:error] = 'Неверно указан тип кеша для сброса'
+              end
+
+              redirect_to hancock_cache_global_clear_path(model_name: 'hancock~cache~fragment'.freeze)
+
+            end
+          end
+        end
+
+        register_instance_option :link_icon do
+          'icon-refresh'
+        end
+
+        register_instance_option :http_methods do
+          [:get, :post]
+        end
+
+      end
+    end
+  end
+end