active_admin-exportable 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 87e5645f5817a953c4cbc2ab61cc5f6de965981c695f7a196b19b2d2b37c8e96
+  data.tar.gz: 40010fe028c4815e8b74e5839df7497ac81e4c56e4b85e2ceb9d42de57a965ea
+SHA512:
+  metadata.gz: 4b95c94889333ce39ce407d46f4b00e7eadab3b03482126864a27f17f2902eda2a32c965137e343d7ca5a21347a21147b0a4ae02582c62d4daa6b471fe21cfb3
+  data.tar.gz: 60bbcaedf2a77a2dcb5929766e9f98e7299c26c974580769cc4d65e9baeefc96dff2d3fa72f12f58112991eb1106d74309736b530dd8255eb28ef2a223ba1cca

data/.gitignore

@@ -0,0 +1,5 @@
+.rspec
+.bundle/
+log/*.log
+pkg/
+Gemfile.lock

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+# Change Log
+
+## 0.1.0 - 2021-05-21
+- Initial release

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in activeadmin-subnav.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) Wagner Caixeta
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,45 @@
+# ActiveAdmin::Exportable
+
+Allow user to export/import of ActiveRecord records and associated records in ActiveAdmin.
+
+# Usage
+
+Add "exportable" to
+
+```ruby
+ActiveAdmin.register Blog do
+  exportable includes: [:posts], format: :json, remove_ids: true, filename_method: :my_custom_filename_method
+end
+```
+# Options
+
+## includes
+Default: []
+
+Use the same syntax of ActiveRecord includes.
+
+## format
+Default: 'json'
+
+Export will accept anything "to_format", like json and yaml, but import will only accept 'json' and 'yaml'.
+
+## remove_ids
+Default: true
+
+The export will remove ids and association ids to avoid conflict on import in another system.
+The import process can restore associations creating new ids.
+
+## filename_method
+If you dont define this the name os files will be "#{the_resource_class_name}_#{id}"
+
+# Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_admin-exportable', '~> 0.1.0'
+```
+
+And then execute:
+
+    $ bundle

data/Rakefile

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'

data/active_admin-exportable.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_admin/exportable/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'active_admin-exportable'
+  spec.version       = ActiveAdmin::Exportable::VERSION
+  spec.authors       = ['Wagner Caixeta']
+  spec.email         = ['wagner.caixeta@gmail.com.com']
+  spec.summary       = 'A export/import tool for ActiveAdmin.'
+  spec.description   = 'Allow user to export/import of ActiveRecord records and associated records in ActiveAdmin.'
+  spec.homepage      = 'https://github.com/zorab47/active_admin-exportable'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activeadmin'
+
+  spec.add_development_dependency 'activerecord'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  # required for active admin
+  spec.add_development_dependency 'sass-rails'
+end

data/app/admin/exportable/import.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+ActiveAdmin.register_page 'Import' do
+  menu parent: 'Exportable'
+  controller do
+    private
+
+    def import_options
+      allow_update = ActiveModel::Type::Boolean.new.cast(params[:import][:allow_update])
+      file_path = params[:import][:file]&.path
+      format = params[:import][:format]
+      raise 'Format is required.' if format.blank?
+      raise 'File is required.' if file_path.blank?
+
+      { path: file_path, format: format, allow_update: allow_update }
+    end
+  end
+
+  content do
+    columns do
+      column do
+        div do
+          active_admin_form_for 'import', url: 'import/upload' do |f|
+            f.inputs name: 'Import', class: 'inputs' do
+              f.input :format, collection: %i[json yaml], input_html: { value: 'json' }
+              f.input :allow_update, as: :boolean
+              f.input :file, as: :file
+              f.action :submit
+            end
+          end
+        end
+      end
+    end
+  end
+
+  page_action :upload, method: :post do
+    imported = ActiveAdmin::Exportable::Importer.new(**import_options)
+    imported.import
+    redirect_to admin_import_path, notice: 'Imported'
+  rescue StandardError => e
+    redirect_to admin_import_path, flash: { error: e.message }
+  end
+end

data/lib/active_admin/exportable.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'active_admin'
+require 'active_admin/exportable/version'
+require 'active_admin/exportable/engine'
+require 'active_admin/exportable/exporter'
+require 'active_admin/exportable/importer'
+
+module ActiveAdmin
+  module Exportable
+    extend ActiveSupport::Concern
+
+    def exportable(options = {})
+      includes = options.fetch(:includes) { [] }
+      remove_ids = options.fetch(:remove_ids, true)
+      filename_method = options[:filename_method]
+      format = options.fetch(:format, :json)
+      enable_resource_exportion(includes: includes, remove_ids: remove_ids, filename_method: filename_method,
+                                format: format)
+    end
+
+    private
+
+    def enable_resource_exportion(includes:, remove_ids:, filename_method:, format:)
+      action_item(*compatible_action_item_parameters) do
+        if controller.action_methods.include?('new') && authorized?(ActiveAdmin::Auth::CREATE,
+                                                                    active_admin_config.resource_class)
+          link_to(
+            I18n.t(
+              :export_model,
+              default: 'Export %{model}',
+              scope: [:active_admin],
+              model: active_admin_config.resource_label
+            ),
+            { action: :export }
+          )
+        end
+      end
+
+      member_action :export do
+        resource = resource_class.find(params[:id])
+
+        authorize! ActiveAdmin::Auth::CREATE, resource
+
+        exported = ActiveAdmin::Exportable::Exporter.new(resource, includes: includes,
+                                                                   remove_ids: remove_ids).export.send("to_#{format}")
+        filename = "#{resource.send(filename_method)}.#{format}" if filename_method.present?
+        filename ||= "#{resource_class.name.downcase}_#{resource.id}.#{format}"
+
+        send_data exported, type: "application/#{format}", filename: filename
+      end
+    end
+
+    # For ActiveAdmin `action_item` compatibility.
+    #
+    # - When ActiveAdmin is less than 1.0.0.pre1 exclude name parameter from
+    #   calls to `action_item` for compatibility.
+    # - When 1.0.0.pre1 or greater provide name to `action_item` to avoid the
+    #   warning message, and later an error.
+    #
+    # Returns Array of parameters.
+    def compatible_action_item_parameters
+      parameters = [{ only: %i[show edit] }]
+      parameters.unshift(:exportable_export) if action_item_name_required?
+      parameters
+    end
+
+    def action_item_name_required?
+      method(:action_item).parameters.count == 3
+    end
+  end
+end
+
+ActiveAdmin::ResourceDSL.include ActiveAdmin::Exportable

data/lib/active_admin/exportable/engine.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Exportable
+    class Engine < Rails::Engine
+      initializer 'active_admin' do |_app|
+        ActiveAdmin.before_load do |app|
+          app.load_paths << File.expand_path('../../../app/admin', __dir__)
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/exportable/exporter.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Exportable
+    class Exporter
+      # TODO: extract this to other gem.
+      def initialize(record, includes: [], remove_ids: false)
+        unless record.is_a?(ActiveRecord::Relation) || record.is_a?(ActiveRecord::Base)
+          raise ArgumentError, 'You need provide an ActiveRecord record as argument.'
+        end
+
+        @root = RootStruct.new(node: record, includes: includes, remove_ids: remove_ids)
+      end
+
+      def export
+        @root.data
+      end
+
+      def to_file(path:)
+        File.open(path, 'w') { |f| f.write to_json }
+      end
+
+      def to_json(*_args)
+        export.to_json
+      end
+
+      class RootStruct
+        def initialize(node:, remove_ids:, includes: [])
+          @node = node
+          @includes = includes
+          @remove_ids = remove_ids
+        end
+
+        def data
+          if @node.respond_to?(:size)
+            @node.map do |n|
+              generate_data(node: n, includes: @includes)
+            end
+          else
+            generate_data(node: @node, includes: @includes)
+          end
+        end
+
+        private
+
+        def generate_data(node:, includes:)
+          attributes = node.attributes
+          a_data = associations_data(node: node, includes: includes)
+
+          if @remove_ids
+            attributes.delete('id')
+            a_data.map do |a|
+              [a[:foreign_type], a[:foreign_key]] if a[:kind] == 'belongs_to'
+            end.flatten.compact.each do |key|
+              attributes.delete(key)
+            end
+          end
+
+          {
+            class_name: node.class.name,
+            attributes: attributes,
+            associations: a_data
+          }
+        end
+
+        def associations_data(node:, includes:)
+          association_data = generate_association_data(node: node, includes: includes)
+          return [association_data.data] if association_data.instance_of?(AssociationStruct)
+
+          association_data.flatten.map(&:data)
+        end
+
+        def generate_association_data(node:, includes:)
+          return [] if includes.nil? || includes.empty?
+
+          case includes
+          when Hash
+            generate_association_data_for_hash(node: node, includes: includes)
+          when Array
+            generate_association_data_for_array(node: node, includes: includes)
+          when Symbol
+            generate_association_data_for_symbol(node: node, includes: includes)
+          end
+        end
+
+        def generate_association_data_for_hash(node:, includes:)
+          includes.map do |association_name, inner_includes|
+            AssociationStruct.new(record: node, association_name: association_name, remove_ids: @remove_ids,
+                                  next_level_includes: inner_includes)
+          end
+        end
+
+        def generate_association_data_for_array(node:, includes:)
+          includes.map do |association_name|
+            # It needs to "pass" again because we don't know the element's kinds.
+            generate_association_data(node: node, includes: association_name)
+          end
+        end
+
+        def generate_association_data_for_symbol(node:, includes:)
+          if node.respond_to?(:size)
+            node.map do |inner_node|
+              AssociationStruct.new(record: inner_node, association_name: includes, remove_ids: @remove_ids)
+            end
+          else
+            AssociationStruct.new(record: node, association_name: includes, remove_ids: @remove_ids)
+          end
+        end
+      end
+
+      class AssociationStruct
+        def initialize(record:, association_name:, remove_ids:, next_level_includes: nil)
+          @next_level_includes = next_level_includes
+          @reflection = record.association(association_name).reflection
+          @association = record.send(association_name)
+          @remove_ids = remove_ids
+        end
+
+        def data
+          {
+            name: @reflection.name,
+            inverse: @reflection.inverse_of&.name,
+            foreign_key: @reflection.foreign_key,
+            foreign_type: @reflection.foreign_type,
+            kind: @reflection.class.name.match(/.*::(?<shortname>\w+)Reflection/)['shortname'].underscore,
+            content: RootStruct.new(node: @association, includes: @next_level_includes, remove_ids: @remove_ids).data
+          }.compact
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/exportable/importer.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Exportable
+    class Importer
+      def initialize(path: nil, data: nil, json: nil, yaml: nil, allow_update: false, ignore_ids: false, format: nil)
+        @data = data if data.present?
+        @data ||= path_to_data(path, format: format) if path.present?
+        @data ||= json_to_data(json) if json.present?
+        @data ||= yaml_to_data(yaml) if yaml.present?
+        @allow_update = allow_update
+        @ignore_ids = ignore_ids
+      end
+
+      def import
+        ActiveRecord::Base.transaction do
+          process_associations_content(@data)
+        end
+      end
+
+      private
+
+      def path_to_data(path, format: nil)
+        format ||= path.match(/.(?<format>\w+)$/)[:format]
+        case format.to_s
+        when 'json'
+          json_to_data(File.open(path).read)
+        when 'yaml'
+          yaml_to_data(File.open(path).read)
+        end
+      end
+
+      def json_to_data(json)
+        JSON.parse(json)
+      end
+
+      def yaml_to_data(yaml)
+        YAML.safe_load(yaml)
+      end
+
+      def process_associations_content(content, relation: nil, relation_name: nil)
+        if content.is_a?(Array)
+          content.each do |c|
+            process_data(c.with_indifferent_access, relation: relation, relation_name: relation_name)
+          end
+        else
+          process_data(content.with_indifferent_access, relation: relation, relation_name: relation_name)
+        end
+      end
+
+      def process_data(data, relation: nil, relation_name: nil)
+        record = update_or_create_record_from_data(data)
+        assign_relation_if_needed(record, relation, relation_name)
+        create_and_assign_belongs_to_associations(record, data)
+        record.save!
+        create_non_belongs_to_associations(record, data)
+        record
+      rescue StandardError => e
+        raise "#{e.message} - details: #{record.inspect}"
+      end
+
+      def update_or_create_record_from_data(data)
+        record = find_or_initialize_from_data(data)
+        return record if !@allow_update && !record.new_record?
+
+        record.attributes = data[:attributes]
+        record
+      end
+
+      def find_or_initialize_from_data(data)
+        klass = data[:class_name].constantize
+        data[:attributes][:id] = nil if @ignore_ids
+        where_opts = if data[:attributes][:id].present?
+                       { id: data[:attributes][:id] }
+                     elsif klass.respond_to?(:exportable_search_attributes)
+                       klass.exportable_search_attributes.to_h { |x| [x, data[:attributes][x]] }
+                     end
+        record = klass.where(where_opts).take if where_opts.present?
+        record || klass.new
+      end
+
+      def assign_relation_if_needed(record, relation, relation_name)
+        record.send("#{relation_name}=", relation) if relation.present?
+      end
+
+      def create_and_assign_belongs_to_associations(record, data)
+        filter_belongs_to_associations(data).each do |association_data|
+          association_record = process_data(association_data[:content])
+          record.send("#{association_data[:name]}=", association_record)
+        end
+      end
+
+      def create_non_belongs_to_associations(record, data)
+        filter_non_belongs_to_associations(data).each do |association_data|
+          process_associations_content(association_data[:content], relation: record,
+                                                                   relation_name: association_data[:inverse])
+        end
+      end
+
+      def filter_belongs_to_associations(data)
+        data[:associations].select { |a| a[:kind] == 'belongs_to' }
+      end
+
+      def filter_non_belongs_to_associations(data)
+        data[:associations].reject { |a| a[:kind] == 'belongs_to' }
+      end
+    end
+  end
+end

data/lib/active_admin/exportable/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module Exportable
+    VERSION = '0.1.0'
+  end
+end

data/spec/exportable_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ActiveAdmin::Exportable do
+  describe 'extends ResourceDSL' do
+    it 'by adding #exportable' do
+      dsl = ActiveAdmin::ResourceDSL
+
+      expect(dsl.public_instance_methods).to include(:exportable)
+    end
+  end
+
+  it 'enables form-based exportion by default' do
+    dsl = ActiveAdmin::ResourceDSL.new(double('config'))
+
+    expect(dsl).to receive(:enable_resource_exportion_via_form)
+
+    dsl.exportable
+  end
+
+  it 'enables save-based exportion with option `via: :save`' do
+    dsl = ActiveAdmin::ResourceDSL.new(double('config'))
+
+    expect(dsl).to receive(:enable_resource_exportion_via_save)
+
+    dsl.exportable(via: :save)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'active_admin/exportable'
+
+RSpec.configure do |config|
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect
+    mocks.verify_partial_doubles = true
+  end
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: active_admin-exportable
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Wagner Caixeta
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-05-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activeadmin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  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'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: sass-rails
+  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: Allow user to export/import of ActiveRecord records and associated records
+  in ActiveAdmin.
+email:
+- wagner.caixeta@gmail.com.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- active_admin-exportable.gemspec
+- app/admin/exportable/import.rb
+- lib/active_admin/exportable.rb
+- lib/active_admin/exportable/engine.rb
+- lib/active_admin/exportable/exporter.rb
+- lib/active_admin/exportable/importer.rb
+- lib/active_admin/exportable/version.rb
+- spec/exportable_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/zorab47/active_admin-exportable
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.17
+signing_key:
+specification_version: 4
+summary: A export/import tool for ActiveAdmin.
+test_files:
+- spec/exportable_spec.rb
+- spec/spec_helper.rb